diff --git a/.gitignore b/.gitignore index 2f1b0d1f..7475b8e1 100644 --- a/.gitignore +++ b/.gitignore @@ -2,4 +2,6 @@ __pycache__ .ipynb_checkpoints .vscode .env +.venv +shell.nix storage_credentials.json diff --git a/apps/legacy_app/notebooks/Analyze_user_behavior_across_different_lending_protocols.ipynb b/apps/legacy_app/notebooks/Analyze_user_behavior_across_different_lending_protocols.ipynb index fe56f24e..4f706596 100644 --- a/apps/legacy_app/notebooks/Analyze_user_behavior_across_different_lending_protocols.ipynb +++ b/apps/legacy_app/notebooks/Analyze_user_behavior_across_different_lending_protocols.ipynb @@ -66,12 +66,20 @@ "outputs": [], "source": [ "# importing necessary libraries\n", + "import os\n", + "import sys\n", "import pandas as pd\n", + "sys.path.append('..')\n", "import matplotlib.pyplot as plt\n", "import seaborn as sns\n", "from matplotlib_venn import venn3\n", - "from sqlalchemy import create_engine\n", - "import gcsfs" + "import requests\n", + "import numpy as np\n", + "from sklearn.preprocessing import StandardScaler\n", + "from collections import defaultdict, Counter\n", + "import re\n", + "import src.helpers\n", + "import math" ] }, { @@ -84,86 +92,336 @@ }, { "cell_type": "markdown", - "id": "99f508d9-4c05-4058-9974-ca6f6398ae88", + "id": "c5820bcd-27a7-4a72-b2c9-8b81dda59110", "metadata": {}, "source": [ - "#### From Postgress" + "#### From GCS" ] }, { "cell_type": "code", - "execution_count": 2, - "id": "fb9b9d7d-1abc-498b-8358-7c12cb01b0f4", + "execution_count": 6, + "id": "2624ecf7-a4de-4ed6-b075-4a7b1ea5a1c3", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing zklend from Google Storage...\n", + "Processing nostra_alpha from Google Storage...\n", + "Processing nostra_mainnet from Google Storage...\n", + "Processing hashstack_v0 from Google Storage...\n", + "Processing hashstack_v1 from Google Storage...\n", + "Combined dataframe shape: (1776234, 9)\n" + ] + } + ], "source": [ - "# from sqlalchemy import create_engine\n", - "\n", - "# # List of protocols (table names in the PostgreSQL database)\n", - "# protocols = [\"zklend\", \"nostra_alpha\", \"nostra_mainnet\", \"hashstack_v0\", \"hashstack_v1\"]\n", - "\n", - "# # Database connection string\n", - "# db_connection_string = 'postgresql://username:password@hostname:port/database'\n", - "\n", - "# # Load data from PostgreSQL\n", - "# postgres_df_list = []\n", - "# engine = create_engine(db_connection_string)\n", + "def load_protocol_data(protocols: list[str]) -> pd.DataFrame:\n", + " \"\"\"\n", + " Load data from Google Storage for the specified protocols and combine them into a single DataFrame.\n", + " \n", + " Parameters:\n", + " protocols (list[str]): A list of protocol names to load data for.\n", + " \n", + " Returns:\n", + " pd.DataFrame: A DataFrame containing the combined data from all specified protocols.\n", + " \n", + " \"\"\" \n", + " combined_protocols_df = pd.DataFrame()\n", + " \n", + " for protocol in protocols:\n", + " # Read from google storage\n", + " try:\n", + " url = f\"https://storage.googleapis.com/derisk-persistent-state/{protocol}_data/loans.parquet\" \n", + " print(f\"Processing {protocol} from Google Storage...\")\n", + " df_protocol = pd.read_parquet(url)\n", + " except:\n", + " print(\"Moving forward...\")\n", + " \n", + " df_protocol['Protocol'] = protocol\n", + " combined_protocols_df = pd.concat([combined_protocols_df, df_protocol], ignore_index=True)\n", + " return combined_protocols_df\n", "\n", - "# for protocol in protocols:\n", - "# df = pd.read_sql_table(protocol, con=engine)\n", - "# df['Protocol'] = protocol\n", - "# postgres_df_list.append(df)\n", + "# List of protocols\n", + "PROTOCOLS = ['zklend', 'nostra_alpha', 'nostra_mainnet', 'hashstack_v0', 'hashstack_v1']\n", "\n", - "# # Combine all PostgreSQL DataFrames into one\n", - "# df_loans_postgres = pd.concat(postgres_df_list, ignore_index=True)a" + "# Load the data\n", + "loans = load_protocol_data(PROTOCOLS)\n", + "print(f\"Combined dataframe shape: {loans.shape}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "6a9975f0-b5aa-49b4-bd47-b560d7c590e8", + "metadata": {}, + "outputs": [ + { + "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", + "
UserProtocolCollateral (USD)Risk-adjusted collateral (USD)Debt (USD)Health factorStandardized health factorCollateralDebt
00x4306021e30f9577351207140f90425b3e9e102ec5a42...zklend5744.5682314289.00952422.162648193.524234193.524234USDC: 113.3876, USDT: 4610.7524, STRK: 904.5577USDC: 10.0284, USDT: 10.0302, wstETH: 0.0006
10x30b399e06903676ada3eccd5522e0cca4c4ad0101468...zklend37.67146330.1371700.000000infinfETH: 0.0126
20x2f006034f567d5c2431bc4104b2cc7a1bf8f004bd00c...zklend102.45008681.9600690.387499211.510582211.510582ETH: 0.0311, USDC: 6.5088, USDT: 3.0144ETH: 0.0005
30x43e9ee859c0f85a6d5ab3f7ad26c50b9e9d8a8e10d0d...zklend-5.156963-4.1255700.000000infinf
40x22dd5ed1e4d359eca2e772ecefa57e31bb7756772850...zklend213.311298157.6511270.000000infinfwBTC: 0.0018, DAI: 23.1396, USDT: 83.3628
\n", + "
" + ], + "text/plain": [ + " User Protocol \\\n", + "0 0x4306021e30f9577351207140f90425b3e9e102ec5a42... zklend \n", + "1 0x30b399e06903676ada3eccd5522e0cca4c4ad0101468... zklend \n", + "2 0x2f006034f567d5c2431bc4104b2cc7a1bf8f004bd00c... zklend \n", + "3 0x43e9ee859c0f85a6d5ab3f7ad26c50b9e9d8a8e10d0d... zklend \n", + "4 0x22dd5ed1e4d359eca2e772ecefa57e31bb7756772850... zklend \n", + "\n", + " Collateral (USD) Risk-adjusted collateral (USD) Debt (USD) \\\n", + "0 5744.568231 4289.009524 22.162648 \n", + "1 37.671463 30.137170 0.000000 \n", + "2 102.450086 81.960069 0.387499 \n", + "3 -5.156963 -4.125570 0.000000 \n", + "4 213.311298 157.651127 0.000000 \n", + "\n", + " Health factor Standardized health factor \\\n", + "0 193.524234 193.524234 \n", + "1 inf inf \n", + "2 211.510582 211.510582 \n", + "3 inf inf \n", + "4 inf inf \n", + "\n", + " Collateral \\\n", + "0 USDC: 113.3876, USDT: 4610.7524, STRK: 904.5577 \n", + "1 ETH: 0.0126 \n", + "2 ETH: 0.0311, USDC: 6.5088, USDT: 3.0144 \n", + "3 \n", + "4 wBTC: 0.0018, DAI: 23.1396, USDT: 83.3628 \n", + "\n", + " Debt \n", + "0 USDC: 10.0284, USDT: 10.0302, wstETH: 0.0006 \n", + "1 \n", + "2 ETH: 0.0005 \n", + "3 \n", + "4 " + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "loans.head()" ] }, { "cell_type": "markdown", - "id": "c5820bcd-27a7-4a72-b2c9-8b81dda59110", + "id": "8f078115-7933-467c-978b-161a7546b1c8", "metadata": {}, "source": [ - "#### From GCS" + "### List of Current prices in USD for given tokens\n", + "Ethereum,Wrapped-Bitcoin,USD-coin,DAI,Tether,Wrapped-Steth,Lords" ] }, { "cell_type": "code", - "execution_count": 3, - "id": "bc9bd276-f6c0-4903-8f18-85e580de6f2d", + "execution_count": 9, + "id": "5ba21cdc-3a84-429d-a1e5-2380046230f5", "metadata": {}, "outputs": [], "source": [ - "# Dictionary of Parquet URLs\n", - "parquet_urls = {\n", - " \"zklend\": \"https://storage.googleapis.com/derisk-persistent-state/zklend_data/loans.parquet\",\n", - " \"nostra_alpha\": \"https://storage.googleapis.com/derisk-persistent-state/nostra_alpha_data/loans.parquet\",\n", - " \"nostra_mainnet\": \"https://storage.googleapis.com/derisk-persistent-state/nostra_mainnet_data/loans.parquet\",\n", - " \"hashstack_v0\": \"https://storage.googleapis.com/derisk-persistent-state/hashstack_v0_data/loans.parquet\",\n", - " \"hashstack_v1\": \"https://storage.googleapis.com/derisk-persistent-state/hashstack_v1_data/loans.parquet\",\n", - "}\n", + "def fetch_prices(collateral_token: str) -> float:\n", + " # Fetch underlying addresses and decimals\n", + " collateral_token_underlying_address = (\n", + " src.helpers.UNDERLYING_SYMBOLS_TO_UNDERLYING_ADDRESSES[collateral_token]\n", + " )\n", + " collateral_token_decimals = int(\n", + " math.log10(src.settings.TOKEN_SETTINGS[collateral_token].decimal_factor)\n", + " )\n", + " underlying_addresses_to_decimals = {\n", + " collateral_token_underlying_address: collateral_token_decimals\n", + " }\n", "\n", - "# Load data from GCS\n", - "gcs_df_list = []\n", - "for protocol, url in parquet_urls.items():\n", - " fs = gcsfs.GCSFileSystem()\n", - " gcs_path = url.replace('https://storage.googleapis.com/', '')\n", - " with fs.open(gcs_path, 'rb') as f:\n", - " df = pd.read_parquet(f, engine='pyarrow')\n", - " df['Protocol'] = protocol\n", - " gcs_df_list.append(df)\n", + " # Fetch prices\n", + " prices = src.helpers.get_prices(token_decimals=underlying_addresses_to_decimals)\n", + " collateral_token_price = prices[collateral_token_underlying_address]\n", "\n", - "# Combine all GCS DataFrames into one\n", - "df_loans = pd.concat(gcs_df_list, ignore_index=True)" + " return collateral_token_price" ] }, { "cell_type": "code", - "execution_count": null, - "id": "6a9975f0-b5aa-49b4-bd47-b560d7c590e8", + "execution_count": 24, + "id": "938f1b8f-eb9c-4508-9fa0-35eca038b3d0", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'ETH': 3664.7}\n", + "{'ETH': 3664.7, 'STRK': 0.6692467172063724}\n", + "{'ETH': 3664.7, 'STRK': 0.6692467172063724, 'USDT': 0.9979042580668577}\n", + "{'dai': {'usd': 1.0}, 'lords': {'usd': 0.206449}}\n", + "{'usd': 0.206449}\n", + "{'ETH': 3664.7, 'STRK': 0.6692467172063724, 'USDT': 0.9979042580668577, 'LORDS': 0.206449}\n", + "{'ETH': 3664.7, 'STRK': 0.6692467172063724, 'USDT': 0.9979042580668577, 'LORDS': 0.206449, 'WBTC': 96050.203262736}\n", + "{'dai': {'usd': 1.0}, 'lords': {'usd': 0.206449}}\n", + "{'usd': 1.0}\n", + "{'ETH': 3664.7, 'STRK': 0.6692467172063724, 'USDT': 0.9979042580668577, 'LORDS': 0.206449, 'WBTC': 96050.203262736, 'DAI': 1.0}\n", + "{'ETH': 3664.7, 'STRK': 0.6692467172063724, 'USDT': 0.9979042580668577, 'LORDS': 0.206449, 'WBTC': 96050.203262736, 'DAI': 1.0, 'USDC': 0.9979469343595746}\n", + "Some error occured\n", + "{'wrapped-steth': {'usd': 4347.19}}\n", + "{'ETH': 3664.7, 'STRK': 0.6692467172063724, 'USDT': 0.9979042580668577, 'LORDS': 0.206449, 'WBTC': 96050.203262736, 'DAI': 1.0, 'USDC': 0.9979469343595746, 'wstETH': 4347.19}\n" + ] + }, + { + "data": { + "text/plain": [ + "{'ETH': 3664.7,\n", + " 'STRK': 0.6692467172063724,\n", + " 'USDT': 0.9979042580668577,\n", + " 'LORDS': 0.206449,\n", + " 'WBTC': 96050.203262736,\n", + " 'DAI': 1.0,\n", + " 'USDC': 0.9979469343595746,\n", + " 'wstETH': 4347.19}" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "df_loans.head()" + "COLLATERAL_TOKENS = [\"ETH\", \"WBTC\", \"STRK\", \"USDC\", \"USDT\", \"DAI\", \"LORDS\", \"wstETH\"]\n", + "prices = {}\n", + "while(len(COLLATERAL_TOKENS) != 0):\n", + " try:\n", + " for token in COLLATERAL_TOKENS:\n", + " price = fetch_prices(token)\n", + " prices[token] = price\n", + " print(prices)\n", + " COLLATERAL_TOKENS.remove(token)\n", + " except:\n", + " url = 'https://api.coingecko.com/api/v3/simple/price'\n", + " if token == 'DAI' or token == 'LORDS':\n", + " token_ids = 'DAI,LORDS'\n", + " params = {\n", + " 'ids': token_ids,\n", + " 'vs_currencies': 'usd'\n", + " }\n", + " response = requests.get(url, params=params)\n", + " rem_prices = response.json()\n", + " print(rem_prices)\n", + " usd = rem_prices.get(token.lower())\n", + " print(usd)\n", + " prices[token] = usd['usd']\n", + " COLLATERAL_TOKENS.remove(token)\n", + " print(prices)\n", + " else:\n", + " token_ids = 'wrapped-steth'\n", + " params = {\n", + " 'ids': token_ids,\n", + " 'vs_currencies': 'usd'\n", + " }\n", + " response = requests.get(url, params=params)\n", + " rem_prices = response.json()\n", + " print(rem_prices)\n", + " usd = rem_prices.get('wrapped-steth')\n", + " prices[token] = usd['usd']\n", + " COLLATERAL_TOKENS.remove(token)\n", + " print(prices)\n", + " else:\n", + " print(\"Some error occured\")\n", + "prices" ] }, { @@ -177,13 +435,30 @@ }, { "cell_type": "code", - "execution_count": null, - "id": "c6a72339-26b1-49e6-943f-4bea5ba8b3a3", + "execution_count": 25, + "id": "57a5bed8-fb28-4ebc-83df-332021d03643", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "Protocol\n", + "zklend 1383629\n", + "nostra_mainnet 247540\n", + "nostra_alpha 143645\n", + "hashstack_v1 867\n", + "hashstack_v0 87\n", + "Name: User, dtype: int64" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "# the distribution of protocols among users\n", - "df_loans['Protocol'].value_counts()" + "top_protocols = loans.groupby('Protocol')['User'].nunique().sort_values(ascending=False)\n", + "top_protocols" ] }, { @@ -196,26 +471,23 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 26, "id": "084931be-14e4-4182-91dd-fa5701265967", "metadata": { "scrolled": true }, "outputs": [], "source": [ - "from collections import defaultdict, Counter\n", - "\n", - "liquidity_data = df_loans[df_loans['Collateral (USD)'] > 0]\n", + "active_loans = loans[loans['Collateral (USD)'] > 0]\n", "\n", "# Initialize a dictionary to store users and their associated protocols for liquidity\n", "user_protocols_liquidity = defaultdict(set)\n", "\n", "# Populate the dictionary\n", - "for _, row in liquidity_data.iterrows():\n", + "for _, row in active_loans.iterrows():\n", " user = row['User']\n", " protocol = row['Protocol']\n", " user_protocols_liquidity[user].add(protocol)\n", - "\n", "# Count the number of protocols each user lends on\n", "user_protocol_counts_liquidity = Counter([len(protocols) for protocols in user_protocols_liquidity.values()])\n", "\n", @@ -227,6 +499,98 @@ "protocol_count_df_liquidity = protocol_count_df_liquidity.sort_values(by='Number of Protocols')" ] }, + { + "cell_type": "code", + "execution_count": 27, + "id": "e0abeedd-dd39-46f0-a5b7-c8989b53f67c", + "metadata": {}, + "outputs": [], + "source": [ + "protocol_count_df_liquidity = protocol_count_df_liquidity.reset_index(drop = True)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "e989070b-821a-41f2-84ea-2c4cd19ba8d1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Users providing liquidity:\n", + "\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", + "
Number of ProtocolsNumber of Users
01402964
1271145
234510
3415
\n", + "
" + ], + "text/plain": [ + " Number of Protocols Number of Users\n", + "0 1 402964\n", + "1 2 71145\n", + "2 3 4510\n", + "3 4 15" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(\"Users providing liquidity:\\n\")\n", + "protocol_count_df_liquidity" + ] + }, { "cell_type": "markdown", "id": "db697ca0-30fe-4d21-a5fc-b01c5db05ad9", @@ -237,14 +601,14 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 29, "id": "2853f77c-143b-4d6a-b584-20a515fa7d09", "metadata": {}, "outputs": [], "source": [ "## Helper funcitons:\n", "# Function to get unique users per protocol\n", - "def get_unique_users(df, value_column):\n", + "def get_unique_users_by_protocol(df: pd.DataFrame) -> defaultdict:\n", " protocol_users = defaultdict(set)\n", " for protocol in df['Protocol'].unique():\n", " users = set(df[df['Protocol'] == protocol]['User'])\n", @@ -252,14 +616,22 @@ " return protocol_users\n", " \n", "# Helper function to plot Venn diagram\n", - "def plot_venn_diagram(user_sets, title):\n", + "def plot_venn_diagram(user_sets: list, title: str, labels: list) -> None:\n", " plt.figure(figsize=(10, 8))\n", " venn3(subsets=(user_sets[0], user_sets[1], user_sets[2]), \n", - " set_labels=('zklend', 'nostra_mainnet', 'nostra_alpha'))\n", + " set_labels=labels)\n", " plt.title(title)\n", " plt.show()" ] }, + { + "cell_type": "markdown", + "id": "539348d0-d35e-4686-9e55-50bc54d6885a", + "metadata": {}, + "source": [ + "### Venn Diagram " + ] + }, { "cell_type": "code", "execution_count": null, @@ -268,17 +640,15 @@ "outputs": [], "source": [ "# Get unique users providing liquidity\n", - "liquidity_df = df_loans[df_loans['Collateral (USD)'] > 0]\n", - "liquidity_protocol_users = get_unique_users(liquidity_df, 'Collateral (USD)')\n", - "\n", + "liquidity_df = loans[loans['Collateral (USD)'] > 0]\n", + "liquidity_protocol_users = get_unique_users_by_protocol(liquidity_df)\n", "\n", "# Prepare sets for Venn diagrams (top 3 protocols by user count)\n", - "top_protocols = ['zklend', 'nostra_mainnet', 'nostra_alpha']\n", - "liquidity_user_sets = [liquidity_protocol_users[protocol] for protocol in top_protocols]\n", - "\n", + "top_3_protocols = top_protocols.keys()[:3].tolist()\n", + "liquidity_user_sets = [liquidity_protocol_users[protocol] for protocol in top_3_protocols]\n", "\n", "# Plot Venn diagrams\n", - "plot_venn_diagram(liquidity_user_sets, 'Users Providing Liquidity Across Top 3 Protocols')\n", + "plot_venn_diagram(liquidity_user_sets, 'Users Providing Liquidity Across Top 3 Protocols', top_3_protocols)\n", "# plot_venn_diagram(debt_user_sets, 'Users Borrowing Across Top 3 Protocols')" ] }, @@ -292,7 +662,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "id": "ccdd4123-9a4e-4def-93a9-d8d21b637962", "metadata": { "scrolled": true @@ -300,7 +670,7 @@ "outputs": [], "source": [ "# Subset the DataFrame for users who have debt\n", - "debt_data = df_loans[df_loans['Debt (USD)'] > 0]\n", + "debt_data = loans[loans['Debt (USD)'] > 0]\n", "\n", "# Initialize a dictionary to store users and their associated protocols for debt\n", "user_protocols_debt = defaultdict(set)\n", @@ -322,8 +692,8 @@ "protocol_count_df_debt = protocol_count_df_debt.sort_values(by='Number of Protocols')\n", "\n", "# Print the result for debt\n", - "# print(\"Users borrowing:\")\n", - "# print(protocol_count_df_debt)" + "print(\"Users borrowing:\")\n", + "protocol_count_df_debt" ] }, { @@ -342,16 +712,16 @@ "outputs": [], "source": [ "# Get unique users having debt\n", - "debt_df = df_loans[df_loans['Debt (USD)'] > 0]\n", - "debt_protocol_users = get_unique_users(debt_df, 'Debt (USD)')\n", + "debt_df = loans[loans['Debt (USD)'] > 0]\n", + "debt_protocol_users = get_unique_users_by_protocol(debt_df)\n", "\n", "\n", "# Prepare sets for Venn diagrams (top 3 protocols by user count)\n", - "top_protocols = ['zklend', 'nostra_mainnet', 'nostra_alpha']\n", - "debt_user_sets = [debt_protocol_users[protocol] for protocol in top_protocols]\n", + "top_3_protocols = top_protocols.keys()[:3]\n", + "debt_user_sets = [debt_protocol_users[protocol] for protocol in top_3_protocols]\n", "\n", "# Plot Venn diagrams\n", - "plot_venn_diagram(debt_user_sets, 'Users Borrowing Across Top 3 Protocols')" + "plot_venn_diagram(debt_user_sets, 'Users Borrowing Across Top 3 Protocols', top_3_protocols)" ] }, { @@ -364,22 +734,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "id": "0c4a2a57-bd8e-44e0-ab0a-c969a311cb2a", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "import seaborn as sns\n", - "\n", "# Function to calculate total capital per token across protocols\n", - "def calculate_capital(df, column_name):\n", + "def calculate_capital(df: pd.DataFrame, column_name: str) -> pd.Series:\n", " capital_per_protocol = df.groupby('Protocol')[column_name].sum()\n", " return capital_per_protocol\n", "\n", "# Function to plot bar chart for token capital across protocols\n", - "def plot_capital(capital, title):\n", + "def plot_capital(capital: pd.Series, title: str) -> None:\n", " plt.figure(figsize=(10, 6))\n", - " sns.barplot(x=capital.index, y=capital.values)\n", + " sns.barplot(x=capital.index, y=np.log(capital.values))\n", " plt.xlabel('Protocol')\n", " plt.ylabel('Total Capital (USD)')\n", " plt.title(title)\n", @@ -388,7 +767,7 @@ "\n", "# Calculate total staked capital per token\n", "staked_capital = calculate_capital(liquidity_df, 'Collateral (USD)')\n", - "plot_capital(staked_capital, 'Total Staked Capital per Token Across Protocols')\n", + "plot_capital(staked_capital, 'Total Staked Capital per Token Across Protocols (Logirathmic Scaling is used)')\n", "\n", "\n" ] @@ -403,14 +782,25 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "id": "c66e6f79-aeb8-41e0-aa01-a17ee535d50f", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Calculate total borrowed capital per token\n", "borrowed_capital = calculate_capital(debt_df, 'Debt (USD)')\n", - "plot_capital(borrowed_capital, 'Total Borrowed Capital Across Protocols')" + "plot_capital(borrowed_capital, 'Total Borrowed Capital Across Protocols (Logirathmic Scaling is used)')" ] }, { @@ -423,16 +813,15 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 18, "id": "74401d69-fff8-4c41-a5ce-6f7e4b1800c5", "metadata": {}, "outputs": [], "source": [ - "import re\n", "# List of tokens\n", - "tokens = [\"ETH\", \"wBTC\", \"USDC\", \"DAI\", \"USDT\", \"wstETH\", \"LORDS\", \"STRK\", \"UNO\", \"ZEND\"]\n", + "tokens = [\"ETH\", \"WBTC\", \"USDC\", \"DAI\", \"USDT\", \"wstETH\", \"LORDS\", \"STRK\"]\n", "\n", - "def parse_token_amounts(column, protocol_column, tokens):\n", + "def parse_token_amounts(column: pd.Series, protocol_column: pd.Series, tokens: list) -> defaultdict:\n", " token_amounts = defaultdict(lambda: defaultdict(float))\n", " for entry, protocol in zip(column, protocol_column):\n", " for token in tokens:\n", @@ -442,16 +831,74 @@ " return token_amounts\n", "\n", "# Extract token amounts for collateral and debt\n", - "collateral_amounts = parse_token_amounts(df_loans['Collateral'], df_loans['Protocol'], tokens)\n", - "debt_amounts = parse_token_amounts(df_loans['Debt'], df_loans['Protocol'], tokens)" + "collateral_amounts = parse_token_amounts(loans['Collateral'], loans['Protocol'], tokens)\n", + "debt_amounts = parse_token_amounts(loans['Debt'], loans['Protocol'], tokens)" ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 19, "id": "7ac76044-ee76-4807-b497-ad1541ec45a2", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Protocol Token Total Collateral (USD)\n", + "0 zklend USDC 6.481915e+06\n", + "1 zklend USDT 3.356178e+06\n", + "2 zklend STRK 1.239352e+07\n", + "3 zklend ETH 4.235030e+03\n", + "4 zklend DAI 7.715796e+04\n", + "5 zklend wstETH 5.272330e+01\n", + "6 nostra_alpha USDC 4.002109e+04\n", + "7 nostra_alpha ETH 3.202590e+01\n", + "8 nostra_alpha USDT 3.019192e+04\n", + "9 nostra_mainnet ETH 1.928400e+04\n", + "10 nostra_mainnet USDC 1.720035e+07\n", + "11 nostra_mainnet DAI 7.468461e+04\n", + "12 nostra_mainnet USDT 1.256802e+07\n", + "13 nostra_mainnet wstETH 5.437920e+01\n", + "14 nostra_mainnet STRK 5.948398e+07\n", + "15 nostra_mainnet LORDS 1.882704e+06\n", + "16 hashstack_v0 USDC 1.130584e+03\n", + "17 hashstack_v0 ETH 6.064000e-01\n", + "18 hashstack_v0 USDT 2.268058e+02\n", + "19 hashstack_v0 DAI 9.689930e+01\n", + "20 hashstack_v1 USDT 2.316824e+04\n", + "21 hashstack_v1 USDC 4.014684e+04\n", + "22 hashstack_v1 DAI 5.764160e+02\n", + "23 hashstack_v1 ETH 1.978970e+01\n", + " Protocol Token Total Debt (USD)\n", + "0 zklend ETH 1.299392e+03\n", + "1 zklend USDC 4.787483e+06\n", + "2 zklend USDT 2.116141e+06\n", + "3 zklend wstETH 2.938450e+01\n", + "4 zklend DAI 6.299988e+04\n", + "5 zklend STRK 1.945519e+06\n", + "6 nostra_alpha USDT 4.961984e+03\n", + "7 nostra_alpha USDC 8.623691e+03\n", + "8 nostra_alpha ETH 3.410900e+00\n", + "9 nostra_alpha DAI 1.949320e+03\n", + "10 nostra_mainnet USDT 6.838741e+06\n", + "11 nostra_mainnet ETH 6.265038e+03\n", + "12 nostra_mainnet USDC 9.499169e+06\n", + "13 nostra_mainnet STRK 6.207267e+06\n", + "14 nostra_mainnet wstETH 3.458160e+01\n", + "15 nostra_mainnet LORDS 4.322130e+04\n", + "16 nostra_mainnet DAI 5.101548e+04\n", + "17 hashstack_v0 ETH 1.989000e-01\n", + "18 hashstack_v0 USDT 1.257607e+02\n", + "19 hashstack_v0 USDC 8.258461e+02\n", + "20 hashstack_v0 DAI 1.601284e+02\n", + "21 hashstack_v1 USDT 3.371473e+04\n", + "22 hashstack_v1 ETH 1.637170e+01\n", + "23 hashstack_v1 USDC 5.081960e+04\n", + "24 hashstack_v1 DAI 6.368208e+02\n" + ] + } + ], "source": [ "# agregating the data\n", "# Convert the aggregated data to DataFrame for better readability\n", @@ -459,17 +906,584 @@ "collateral_df = pd.DataFrame(collateral_list, columns=['Protocol', 'Token', 'Total Collateral (USD)'])\n", "\n", "debt_list = [(protocol, token, amount) for protocol, tokens in debt_amounts.items() for token, amount in tokens.items()]\n", - "debt_df = pd.DataFrame(debt_list, columns=['Protocol', 'Token', 'Total Debt (USD)'])" + "debt_df = pd.DataFrame(debt_list, columns=['Protocol', 'Token', 'Total Debt (USD)'])\n", + "print(collateral_df, debt_df, sep='\\n')" + ] + }, + { + "cell_type": "markdown", + "id": "b88d6fad-fb16-4514-9137-946cd2a5c443", + "metadata": {}, + "source": [ + "#### Coverting to USD denominater" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, + "id": "48b48551-98a3-455f-a9cd-55f8257b5a17", + "metadata": {}, + "outputs": [ + { + "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", + " \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", + "
ProtocolTokenTotal Collateral (USD)
0zklendUSDC6.514385e+06
1zklendUSDT3.374467e+06
2zklendSTRK5.308083e+06
3zklendETH1.293421e+07
4zklendDAI7.713844e+04
5zklendwstETH5.272330e+01
6nostra_alphaUSDC4.022157e+04
7nostra_alphaETH9.781030e+04
8nostra_alphaUSDT3.035645e+04
9nostra_mainnetETH5.889526e+07
10nostra_mainnetUSDC1.728651e+07
11nostra_mainnetDAI7.466571e+04
12nostra_mainnetUSDT1.263651e+07
13nostra_mainnetwstETH5.437920e+01
14nostra_mainnetSTRK2.547670e+07
15nostra_mainnetLORDS9.348570e+04
16hashstack_v0USDC1.136247e+03
17hashstack_v0ETH1.852006e+03
18hashstack_v0USDT2.280418e+02
19hashstack_v0DAI9.687478e+01
20hashstack_v1USDT2.329449e+04
21hashstack_v1USDC4.034794e+04
22hashstack_v1DAI5.762702e+02
23hashstack_v1ETH6.043972e+04
\n", + "
" + ], + "text/plain": [ + " Protocol Token Total Collateral (USD)\n", + "0 zklend USDC 6.514385e+06\n", + "1 zklend USDT 3.374467e+06\n", + "2 zklend STRK 5.308083e+06\n", + "3 zklend ETH 1.293421e+07\n", + "4 zklend DAI 7.713844e+04\n", + "5 zklend wstETH 5.272330e+01\n", + "6 nostra_alpha USDC 4.022157e+04\n", + "7 nostra_alpha ETH 9.781030e+04\n", + "8 nostra_alpha USDT 3.035645e+04\n", + "9 nostra_mainnet ETH 5.889526e+07\n", + "10 nostra_mainnet USDC 1.728651e+07\n", + "11 nostra_mainnet DAI 7.466571e+04\n", + "12 nostra_mainnet USDT 1.263651e+07\n", + "13 nostra_mainnet wstETH 5.437920e+01\n", + "14 nostra_mainnet STRK 2.547670e+07\n", + "15 nostra_mainnet LORDS 9.348570e+04\n", + "16 hashstack_v0 USDC 1.136247e+03\n", + "17 hashstack_v0 ETH 1.852006e+03\n", + "18 hashstack_v0 USDT 2.280418e+02\n", + "19 hashstack_v0 DAI 9.687478e+01\n", + "20 hashstack_v1 USDT 2.329449e+04\n", + "21 hashstack_v1 USDC 4.034794e+04\n", + "22 hashstack_v1 DAI 5.762702e+02\n", + "23 hashstack_v1 ETH 6.043972e+04" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "for token in tokens:\n", + " if token == 'wstETH':\n", + " tokens.remove(token)\n", + " tokens.append('wrapped-steth'.upper())\n", + "#print(token_ids)\n", + "\n", + "# Total Collateral (USD)\n", + "for token in tokens:\n", + " val = collateral_df[collateral_df['Token'] == token].loc[:, 'Total Collateral (USD)'] * prices[token]\n", + " collateral_df.loc[collateral_df['Token'] == token, 'Total Collateral (USD)'] = val\n", + "collateral_df" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "1dde9c83-bafc-4119-9a30-47edf2c816e5", + "metadata": {}, + "outputs": [ + { + "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", + " \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", + "
ProtocolTokenTotal Debt (USD)
0zklendETH3.968472e+06
1zklendUSDC4.811465e+06
2zklendUSDT2.127673e+06
3zklendwstETH2.938450e+01
4zklendDAI6.298394e+04
5zklendSTRK8.332561e+05
6nostra_alphaUSDT4.989024e+03
7nostra_alphaUSDC8.666890e+03
8nostra_alphaETH1.041723e+04
9nostra_alphaDAI1.948826e+03
10nostra_mainnetUSDT6.876009e+06
11nostra_mainnetETH1.913405e+07
12nostra_mainnetUSDC9.546754e+06
13nostra_mainnetSTRK2.658542e+06
14nostra_mainnetwstETH3.458160e+01
15nostra_mainnetLORDS2.146155e+03
16nostra_mainnetDAI5.100257e+04
17hashstack_v0ETH6.074605e+02
18hashstack_v0USDT1.264460e+02
19hashstack_v0USDC8.299830e+02
20hashstack_v0DAI1.600879e+02
21hashstack_v1USDT3.389846e+04
22hashstack_v1ETH5.000081e+04
23hashstack_v1USDC5.107417e+04
24hashstack_v1DAI6.366597e+02
\n", + "
" + ], + "text/plain": [ + " Protocol Token Total Debt (USD)\n", + "0 zklend ETH 3.968472e+06\n", + "1 zklend USDC 4.811465e+06\n", + "2 zklend USDT 2.127673e+06\n", + "3 zklend wstETH 2.938450e+01\n", + "4 zklend DAI 6.298394e+04\n", + "5 zklend STRK 8.332561e+05\n", + "6 nostra_alpha USDT 4.989024e+03\n", + "7 nostra_alpha USDC 8.666890e+03\n", + "8 nostra_alpha ETH 1.041723e+04\n", + "9 nostra_alpha DAI 1.948826e+03\n", + "10 nostra_mainnet USDT 6.876009e+06\n", + "11 nostra_mainnet ETH 1.913405e+07\n", + "12 nostra_mainnet USDC 9.546754e+06\n", + "13 nostra_mainnet STRK 2.658542e+06\n", + "14 nostra_mainnet wstETH 3.458160e+01\n", + "15 nostra_mainnet LORDS 2.146155e+03\n", + "16 nostra_mainnet DAI 5.100257e+04\n", + "17 hashstack_v0 ETH 6.074605e+02\n", + "18 hashstack_v0 USDT 1.264460e+02\n", + "19 hashstack_v0 USDC 8.299830e+02\n", + "20 hashstack_v0 DAI 1.600879e+02\n", + "21 hashstack_v1 USDT 3.389846e+04\n", + "22 hashstack_v1 ETH 5.000081e+04\n", + "23 hashstack_v1 USDC 5.107417e+04\n", + "24 hashstack_v1 DAI 6.366597e+02" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Total Debt (USD)\n", + "for token in tokens:\n", + " val = debt_df[debt_df['Token'] == token].loc[:, 'Total Debt (USD)'] * prices[token]\n", + " debt_df.loc[debt_df['Token'] == token, 'Total Debt (USD)'] = val\n", + "debt_df" + ] + }, + { + "cell_type": "markdown", + "id": "bdc71978-7b1c-421d-837a-96f61e54a051", + "metadata": {}, + "source": [ + "### Collateral data per protocol per token USD Equivalent" + ] + }, + { + "cell_type": "code", + "execution_count": 22, "id": "521fbd91-b7d6-4cfd-99aa-a203e63f3daa", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "Protocol Token \n", + "hashstack_v0 DAI 9.687478e+01\n", + " ETH 1.852006e+03\n", + " USDC 1.136247e+03\n", + " USDT 2.280418e+02\n", + "hashstack_v1 DAI 5.762702e+02\n", + " ETH 6.043972e+04\n", + " USDC 4.034794e+04\n", + " USDT 2.329449e+04\n", + "nostra_alpha ETH 9.781030e+04\n", + " USDC 4.022157e+04\n", + " USDT 3.035645e+04\n", + "nostra_mainnet DAI 7.466571e+04\n", + " ETH 5.889526e+07\n", + " LORDS 9.348570e+04\n", + " STRK 2.547670e+07\n", + " USDC 1.728651e+07\n", + " USDT 1.263651e+07\n", + " wstETH 5.437920e+01\n", + "zklend DAI 7.713844e+04\n", + " ETH 1.293421e+07\n", + " STRK 5.308083e+06\n", + " USDC 6.514385e+06\n", + " USDT 3.374467e+06\n", + " wstETH 5.272330e+01\n", + "Name: Total Collateral (USD), dtype: float64" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "collateral_df.groupby(['Protocol','Token'])['Total Collateral (USD)'].sum()" + "collateral_per_protocol_token = collateral_df.groupby(['Protocol','Token'])['Total Collateral (USD)'].sum()\n", + "collateral_per_protocol_token" + ] + }, + { + "cell_type": "markdown", + "id": "11ddb189-eef7-492a-b0eb-f54f295ab3ff", + "metadata": {}, + "source": [ + "### Debt data per protocol per token USD Equivalent" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "bab1ec7c-8181-45e8-bbd6-f81f49920962", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Protocol Token \n", + "hashstack_v0 DAI 1.600879e+02\n", + " ETH 6.074605e+02\n", + " USDC 8.299830e+02\n", + " USDT 1.264460e+02\n", + "hashstack_v1 DAI 6.366597e+02\n", + " ETH 5.000081e+04\n", + " USDC 5.107417e+04\n", + " USDT 3.389846e+04\n", + "nostra_alpha DAI 1.948826e+03\n", + " ETH 1.041723e+04\n", + " USDC 8.666890e+03\n", + " USDT 4.989024e+03\n", + "nostra_mainnet DAI 5.100257e+04\n", + " ETH 1.913405e+07\n", + " LORDS 2.146155e+03\n", + " STRK 2.658542e+06\n", + " USDC 9.546754e+06\n", + " USDT 6.876009e+06\n", + " wstETH 3.458160e+01\n", + "zklend DAI 6.298394e+04\n", + " ETH 3.968472e+06\n", + " STRK 8.332561e+05\n", + " USDC 4.811465e+06\n", + " USDT 2.127673e+06\n", + " wstETH 2.938450e+01\n", + "Name: Total Debt (USD), dtype: float64" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "debt_per_protocol_token = debt_df.groupby(['Protocol','Token'])['Total Debt (USD)'].sum()\n", + "debt_per_protocol_token" ] }, { @@ -482,17 +1496,90 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 24, "id": "d654007a-8ef0-4c33-ab35-50f65b030cfd", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Visualization\n", - "import matplotlib.pyplot as plt\n", - "import seaborn as sns\n", + "\n", + "scaler = StandardScaler()\n", + "collateral_df['Normalized Collateral (USD)'] = scaler.fit_transform(collateral_df[['Total Collateral (USD)']])\n", + "debt_df['Normalized Debt (USD)'] = scaler.fit_transform(debt_df[['Total Debt (USD)']])\n", "\n", "# Plotting collateral amounts\n", "plt.figure(figsize=(12, 8))\n", + "sns.barplot(data=collateral_df, x='Protocol', y='Normalized Collateral (USD)', hue='Token')\n", + "plt.xlabel('Tokens')\n", + "plt.ylabel('Normalized Collateral (USD)')\n", + "plt.title('Normalized Total Collateral per Token and Protocol')\n", + "plt.xticks(rotation=45)\n", + "plt.legend(title='Protocol')\n", + "plt.show()\n", + "\n", + "# Plotting debt amounts\n", + "plt.figure(figsize=(12, 8))\n", + "sns.barplot(data=debt_df, x='Protocol', y='Normalized Debt (USD)', hue='Token')\n", + "plt.xlabel('Tokens')\n", + "plt.ylabel('Normalized Debt (USD)')\n", + "plt.title('Normalized Total Debt per Token and Protocol')\n", + "plt.xticks(rotation=45)\n", + "plt.legend(title='Protocol')\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "8a03e0a2-e684-4924-a1ef-7028687d1fcc", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Visualization\n", + "# Plotting collateral amounts\n", + "plt.figure(figsize=(12, 8))\n", "sns.barplot(data=collateral_df, x='Protocol', y='Total Collateral (USD)', hue='Token')\n", "plt.xlabel('Tokens')\n", "plt.ylabel('Total Collateral (USD)')\n", @@ -513,12 +1600,42 @@ ] }, { - "cell_type": "code", - "execution_count": null, - "id": "28bd7cf4-a32b-44a6-9111-684bf7d43335", + "cell_type": "markdown", + "id": "e24113f0-360d-452f-9d31-f5dade9a68d4", "metadata": {}, - "outputs": [], - "source": [] + "source": [ + "## Conclusion\n", + "\n", + "In this analysis, we addressed several questions regarding user interactions with DeFi protocols in terms of liquidity provision, borrowing, and capital distribution. Here are the key findings:\n", + "\n", + "### 1. How many users provide liquidity on just 1 protocol? How many users use 2 or more protocols?\n", + " - We found that the majority of users tend to provide liquidity on a **single protocol**, with a smaller subset of users participating in **multiple protocols**. This indicates a preference for consolidating liquidity on one platform, possibly due to familiarity, incentives, or protocol-specific advantages.\n", + "\n", + "### 2. How many users borrow on just 1 protocol? How many users use 2 or more protocols?\n", + " - Similar to liquidity provision, most users **borrow from a single protocol**. However, a minority of users engage with multiple borrowing protocols, likely optimizing for different collateral types, interest rates, or loan conditions.\n", + "\n", + "### 3. Visualizing capital distribution across protocols if a user has 10k USD deposited in the pools.\n", + " - We assumed that each user has deposited **10,000 USD** worth of capital and calculated how this capital is distributed across the protocols. The majority of users allocate most of their liquidity to a **single protocol**. This trend suggests that users tend to stake a significant portion of their capital in the protocol they trust most, with smaller amounts distributed across other platforms.\n", + "\n", + "### 4. Capital distribution on a per-token basis.\n", + " - The analysis shows significant variation in capital distribution across different tokens and protocols. \n", + " - **hashstack_v0**: Most of the capital is held in **USDC** (1130.58 USD) and **USDT** (226.81 USD), with smaller amounts in **DAI**, **ETH**, and **wBTC**.\n", + " - **hashstack_v1**: The largest amounts are in **USDC** (40,146.84 USD) and **USDT** (23,168.24 USD), followed by **DAI**, **ETH**, and **wBTC**.\n", + " - **nostra_alpha**: Significant collateral is in **USDC** (40,021.09 USD) and **USDT** (30,191.92 USD), with a moderate amount in **ETH**.\n", + " - **nostra_mainnet**: A very large portion is allocated to **STRK** (59,483,980 USD) and **LORDS** (1,882,704 USD), with considerable amounts in **DAI** (74,684.61 USD), **USDC** (17,200,350 USD), and **USDT** (12,568,020 USD).\n", + " - **zklend**: The largest holdings are in **STRK** (12,393,520 USD) and **USDC** (6,481,915 USD), with significant amounts in **DAI**, **ETH**, **USDT**, and **wBTC**.\n", + "\n", + " - **Stablecoins** like **USDC** and **USDT** dominate capital distribution across several protocols, while protocols such as **nostra_mainnet** and **zklend** have substantial holdings in **STRK** and **LORDS**. The diversity in token preferences reflects protocol-specific strategies and user preferences, with stablecoins being the preferred choice for liquidity in most protocols.\n", + "\n", + "\n", + "### Additional Insights:\n", + " - **Venn diagrams** illustrated the overlap between users who provide liquidity or borrow from multiple protocols. The diagrams highlight that while most users are active on just one protocol, there is a meaningful overlap of users across two or more platforms.\n", + " - **Token-based visualization** further showcased how liquidity and borrowing vary significantly based on token type, offering insights into protocol token preferences.\n", + "\n", + "---\n", + "\n", + "This analysis provides a clear understanding of how users interact with multiple DeFi protocols, how they distribute their capital, and which tokens and protocols are preferred. Further exploration could involve time-based analysis, exploring user behavior trends over time, or investigating protocol-specific incentives that drive user engagement across platforms.\n" + ] } ], "metadata": { @@ -537,7 +1654,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.7" + "version": "3.12.7" } }, "nbformat": 4, diff --git a/apps/legacy_app/poetry.lock b/apps/legacy_app/poetry.lock index 2f393bbb..1825e2be 100644 --- a/apps/legacy_app/poetry.lock +++ b/apps/legacy_app/poetry.lock @@ -171,6 +171,28 @@ files = [ {file = "annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89"}, ] +[[package]] +name = "anyio" +version = "4.6.2.post1" +description = "High level compatibility layer for multiple asynchronous event loop implementations" +optional = false +python-versions = ">=3.9" +files = [ + {file = "anyio-4.6.2.post1-py3-none-any.whl", hash = "sha256:6d170c36fba3bdd840c73d3868c1e777e33676a69c3a72cf0a0d5d6d8009b61d"}, + {file = "anyio-4.6.2.post1.tar.gz", hash = "sha256:4c8bc31ccdb51c7f7bd251f51c609e038d63e34219b44aa86e47576389880b4c"}, +] + +[package.dependencies] +exceptiongroup = {version = ">=1.0.2", markers = "python_version < \"3.11\""} +idna = ">=2.8" +sniffio = ">=1.1" +typing-extensions = {version = ">=4.1", markers = "python_version < \"3.11\""} + +[package.extras] +doc = ["Sphinx (>=7.4,<8.0)", "packaging", "sphinx-autodoc-typehints (>=1.2.0)", "sphinx-rtd-theme"] +test = ["anyio[trio]", "coverage[toml] (>=7)", "exceptiongroup (>=1.2.0)", "hypothesis (>=4.0)", "psutil (>=5.9)", "pytest (>=7.0)", "pytest-mock (>=3.6.1)", "trustme", "truststore (>=0.9.1)", "uvloop (>=0.21.0b1)"] +trio = ["trio (>=0.26.1)"] + [[package]] name = "appdirs" version = "1.4.4" @@ -182,6 +204,93 @@ files = [ {file = "appdirs-1.4.4.tar.gz", hash = "sha256:7d5d0167b2b1ba821647616af46a749d1c653740dd0d2415100fe26e27afdf41"}, ] +[[package]] +name = "appnope" +version = "0.1.4" +description = "Disable App Nap on macOS >= 10.9" +optional = false +python-versions = ">=3.6" +files = [ + {file = "appnope-0.1.4-py2.py3-none-any.whl", hash = "sha256:502575ee11cd7a28c0205f379b525beefebab9d161b7c964670864014ed7213c"}, + {file = "appnope-0.1.4.tar.gz", hash = "sha256:1de3860566df9caf38f01f86f65e0e13e379af54f9e4bee1e66b48f2efffd1ee"}, +] + +[[package]] +name = "argon2-cffi" +version = "23.1.0" +description = "Argon2 for Python" +optional = false +python-versions = ">=3.7" +files = [ + {file = "argon2_cffi-23.1.0-py3-none-any.whl", hash = "sha256:c670642b78ba29641818ab2e68bd4e6a78ba53b7eff7b4c3815ae16abf91c7ea"}, + {file = "argon2_cffi-23.1.0.tar.gz", hash = "sha256:879c3e79a2729ce768ebb7d36d4609e3a78a4ca2ec3a9f12286ca057e3d0db08"}, +] + +[package.dependencies] +argon2-cffi-bindings = "*" + +[package.extras] +dev = ["argon2-cffi[tests,typing]", "tox (>4)"] +docs = ["furo", "myst-parser", "sphinx", "sphinx-copybutton", "sphinx-notfound-page"] +tests = ["hypothesis", "pytest"] +typing = ["mypy"] + +[[package]] +name = "argon2-cffi-bindings" +version = "21.2.0" +description = "Low-level CFFI bindings for Argon2" +optional = false +python-versions = ">=3.6" +files = [ + {file = "argon2-cffi-bindings-21.2.0.tar.gz", hash = "sha256:bb89ceffa6c791807d1305ceb77dbfacc5aa499891d2c55661c6459651fc39e3"}, + {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:ccb949252cb2ab3a08c02024acb77cfb179492d5701c7cbdbfd776124d4d2367"}, + {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9524464572e12979364b7d600abf96181d3541da11e23ddf565a32e70bd4dc0d"}, + {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b746dba803a79238e925d9046a63aa26bf86ab2a2fe74ce6b009a1c3f5c8f2ae"}, + {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:58ed19212051f49a523abb1dbe954337dc82d947fb6e5a0da60f7c8471a8476c"}, + {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:bd46088725ef7f58b5a1ef7ca06647ebaf0eb4baff7d1d0d177c6cc8744abd86"}, + {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-musllinux_1_1_i686.whl", hash = "sha256:8cd69c07dd875537a824deec19f978e0f2078fdda07fd5c42ac29668dda5f40f"}, + {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:f1152ac548bd5b8bcecfb0b0371f082037e47128653df2e8ba6e914d384f3c3e"}, + {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-win32.whl", hash = "sha256:603ca0aba86b1349b147cab91ae970c63118a0f30444d4bc80355937c950c082"}, + {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-win_amd64.whl", hash = "sha256:b2ef1c30440dbbcba7a5dc3e319408b59676e2e039e2ae11a8775ecf482b192f"}, + {file = "argon2_cffi_bindings-21.2.0-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:e415e3f62c8d124ee16018e491a009937f8cf7ebf5eb430ffc5de21b900dad93"}, + {file = "argon2_cffi_bindings-21.2.0-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:3e385d1c39c520c08b53d63300c3ecc28622f076f4c2b0e6d7e796e9f6502194"}, + {file = "argon2_cffi_bindings-21.2.0-pp37-pypy37_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2c3e3cc67fdb7d82c4718f19b4e7a87123caf8a93fde7e23cf66ac0337d3cb3f"}, + {file = "argon2_cffi_bindings-21.2.0-pp37-pypy37_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6a22ad9800121b71099d0fb0a65323810a15f2e292f2ba450810a7316e128ee5"}, + {file = "argon2_cffi_bindings-21.2.0-pp37-pypy37_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f9f8b450ed0547e3d473fdc8612083fd08dd2120d6ac8f73828df9b7d45bb351"}, + {file = "argon2_cffi_bindings-21.2.0-pp37-pypy37_pp73-win_amd64.whl", hash = "sha256:93f9bf70084f97245ba10ee36575f0c3f1e7d7724d67d8e5b08e61787c320ed7"}, + {file = "argon2_cffi_bindings-21.2.0-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:3b9ef65804859d335dc6b31582cad2c5166f0c3e7975f324d9ffaa34ee7e6583"}, + {file = "argon2_cffi_bindings-21.2.0-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d4966ef5848d820776f5f562a7d45fdd70c2f330c961d0d745b784034bd9f48d"}, + {file = "argon2_cffi_bindings-21.2.0-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:20ef543a89dee4db46a1a6e206cd015360e5a75822f76df533845c3cbaf72670"}, + {file = "argon2_cffi_bindings-21.2.0-pp38-pypy38_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ed2937d286e2ad0cc79a7087d3c272832865f779430e0cc2b4f3718d3159b0cb"}, + {file = "argon2_cffi_bindings-21.2.0-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:5e00316dabdaea0b2dd82d141cc66889ced0cdcbfa599e8b471cf22c620c329a"}, +] + +[package.dependencies] +cffi = ">=1.0.1" + +[package.extras] +dev = ["cogapp", "pre-commit", "pytest", "wheel"] +tests = ["pytest"] + +[[package]] +name = "arrow" +version = "1.3.0" +description = "Better dates & times for Python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "arrow-1.3.0-py3-none-any.whl", hash = "sha256:c728b120ebc00eb84e01882a6f5e7927a53960aa990ce7dd2b10f39005a67f80"}, + {file = "arrow-1.3.0.tar.gz", hash = "sha256:d4540617648cb5f895730f1ad8c82a65f2dad0166f57b75f3ca54759c4d67a85"}, +] + +[package.dependencies] +python-dateutil = ">=2.7.0" +types-python-dateutil = ">=2.8.10" + +[package.extras] +doc = ["doc8", "sphinx (>=7.0.0)", "sphinx-autobuild", "sphinx-autodoc-typehints", "sphinx_rtd_theme (>=1.3.0)"] +test = ["dateparser (==1.*)", "pre-commit", "pytest", "pytest-cov", "pytest-mock", "pytz (==2021.1)", "simplejson (==3.*)"] + [[package]] name = "asgiref" version = "3.8.1" @@ -199,6 +308,38 @@ typing-extensions = {version = ">=4", markers = "python_version < \"3.11\""} [package.extras] tests = ["mypy (>=0.800)", "pytest", "pytest-asyncio"] +[[package]] +name = "asttokens" +version = "2.4.1" +description = "Annotate AST trees with source code positions" +optional = false +python-versions = "*" +files = [ + {file = "asttokens-2.4.1-py2.py3-none-any.whl", hash = "sha256:051ed49c3dcae8913ea7cd08e46a606dba30b79993209636c4875bc1d637bc24"}, + {file = "asttokens-2.4.1.tar.gz", hash = "sha256:b03869718ba9a6eb027e134bfdf69f38a236d681c83c160d510768af11254ba0"}, +] + +[package.dependencies] +six = ">=1.12.0" + +[package.extras] +astroid = ["astroid (>=1,<2)", "astroid (>=2,<4)"] +test = ["astroid (>=1,<2)", "astroid (>=2,<4)", "pytest"] + +[[package]] +name = "async-lru" +version = "2.0.4" +description = "Simple LRU cache for asyncio" +optional = false +python-versions = ">=3.8" +files = [ + {file = "async-lru-2.0.4.tar.gz", hash = "sha256:b8a59a5df60805ff63220b2a0c5b5393da5521b113cd5465a44eb037d81a5627"}, + {file = "async_lru-2.0.4-py3-none-any.whl", hash = "sha256:ff02944ce3c288c5be660c42dbcca0742b32c3b279d6dceda655190240b99224"}, +] + +[package.dependencies] +typing-extensions = {version = ">=4.0.0", markers = "python_version < \"3.11\""} + [[package]] name = "async-timeout" version = "4.0.3" @@ -229,11 +370,25 @@ docs = ["cogapp", "furo", "myst-parser", "sphinx", "sphinx-notfound-page", "sphi tests = ["cloudpickle", "hypothesis", "mypy (>=1.11.1)", "pympler", "pytest (>=4.3.0)", "pytest-mypy-plugins", "pytest-xdist[psutil]"] tests-mypy = ["mypy (>=1.11.1)", "pytest-mypy-plugins"] +[[package]] +name = "babel" +version = "2.16.0" +description = "Internationalization utilities" +optional = false +python-versions = ">=3.8" +files = [ + {file = "babel-2.16.0-py3-none-any.whl", hash = "sha256:368b5b98b37c06b7daf6696391c3240c938b37767d4584413e8438c5c435fa8b"}, + {file = "babel-2.16.0.tar.gz", hash = "sha256:d1f3554ca26605fe173f3de0c65f750f5a42f924499bf134de6423582298e316"}, +] + +[package.extras] +dev = ["freezegun (>=1.0,<2.0)", "pytest (>=6.0)", "pytest-cov"] + [[package]] name = "beautifulsoup4" version = "4.12.3" description = "Screen-scraping library" -optional = true +optional = false python-versions = ">=3.6.0" files = [ {file = "beautifulsoup4-4.12.3-py3-none-any.whl", hash = "sha256:b80878c9f40111313e55da8ba20bdba06d8fa3969fc68304167741bbf9e082ed"}, @@ -296,6 +451,23 @@ d = ["aiohttp (>=3.10)"] jupyter = ["ipython (>=7.8.0)", "tokenize-rt (>=3.2.0)"] uvloop = ["uvloop (>=0.15.2)"] +[[package]] +name = "bleach" +version = "6.2.0" +description = "An easy safelist-based HTML-sanitizing tool." +optional = false +python-versions = ">=3.9" +files = [ + {file = "bleach-6.2.0-py3-none-any.whl", hash = "sha256:117d9c6097a7c3d22fd578fcd8d35ff1e125df6736f554da4e432fdd63f31e5e"}, + {file = "bleach-6.2.0.tar.gz", hash = "sha256:123e894118b8a599fd80d3ec1a6d4cc7ce4e5882b1317a7e1ba69b56e95f991f"}, +] + +[package.dependencies] +webencodings = "*" + +[package.extras] +css = ["tinycss2 (>=1.1.0,<1.5)"] + [[package]] name = "blinker" version = "1.8.2" @@ -329,6 +501,85 @@ files = [ {file = "certifi-2024.8.30.tar.gz", hash = "sha256:bec941d2aa8195e248a60b31ff9f0558284cf01a52591ceda73ea9afffd69fd9"}, ] +[[package]] +name = "cffi" +version = "1.17.1" +description = "Foreign Function Interface for Python calling C code." +optional = false +python-versions = ">=3.8" +files = [ + {file = "cffi-1.17.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:df8b1c11f177bc2313ec4b2d46baec87a5f3e71fc8b45dab2ee7cae86d9aba14"}, + {file = "cffi-1.17.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8f2cdc858323644ab277e9bb925ad72ae0e67f69e804f4898c070998d50b1a67"}, + {file = "cffi-1.17.1-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:edae79245293e15384b51f88b00613ba9f7198016a5948b5dddf4917d4d26382"}, + {file = "cffi-1.17.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:45398b671ac6d70e67da8e4224a065cec6a93541bb7aebe1b198a61b58c7b702"}, + {file = "cffi-1.17.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ad9413ccdeda48c5afdae7e4fa2192157e991ff761e7ab8fdd8926f40b160cc3"}, + {file = "cffi-1.17.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5da5719280082ac6bd9aa7becb3938dc9f9cbd57fac7d2871717b1feb0902ab6"}, + {file = "cffi-1.17.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2bb1a08b8008b281856e5971307cc386a8e9c5b625ac297e853d36da6efe9c17"}, + {file = "cffi-1.17.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:045d61c734659cc045141be4bae381a41d89b741f795af1dd018bfb532fd0df8"}, + {file = "cffi-1.17.1-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:6883e737d7d9e4899a8a695e00ec36bd4e5e4f18fabe0aca0efe0a4b44cdb13e"}, + {file = "cffi-1.17.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:6b8b4a92e1c65048ff98cfe1f735ef8f1ceb72e3d5f0c25fdb12087a23da22be"}, + {file = "cffi-1.17.1-cp310-cp310-win32.whl", hash = "sha256:c9c3d058ebabb74db66e431095118094d06abf53284d9c81f27300d0e0d8bc7c"}, + {file = "cffi-1.17.1-cp310-cp310-win_amd64.whl", hash = "sha256:0f048dcf80db46f0098ccac01132761580d28e28bc0f78ae0d58048063317e15"}, + {file = "cffi-1.17.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:a45e3c6913c5b87b3ff120dcdc03f6131fa0065027d0ed7ee6190736a74cd401"}, + {file = "cffi-1.17.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:30c5e0cb5ae493c04c8b42916e52ca38079f1b235c2f8ae5f4527b963c401caf"}, + {file = "cffi-1.17.1-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f75c7ab1f9e4aca5414ed4d8e5c0e303a34f4421f8a0d47a4d019ceff0ab6af4"}, + {file = "cffi-1.17.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a1ed2dd2972641495a3ec98445e09766f077aee98a1c896dcb4ad0d303628e41"}, + {file = "cffi-1.17.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:46bf43160c1a35f7ec506d254e5c890f3c03648a4dbac12d624e4490a7046cd1"}, + {file = "cffi-1.17.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a24ed04c8ffd54b0729c07cee15a81d964e6fee0e3d4d342a27b020d22959dc6"}, + {file = "cffi-1.17.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:610faea79c43e44c71e1ec53a554553fa22321b65fae24889706c0a84d4ad86d"}, + {file = "cffi-1.17.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:a9b15d491f3ad5d692e11f6b71f7857e7835eb677955c00cc0aefcd0669adaf6"}, + {file = "cffi-1.17.1-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:de2ea4b5833625383e464549fec1bc395c1bdeeb5f25c4a3a82b5a8c756ec22f"}, + {file = "cffi-1.17.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:fc48c783f9c87e60831201f2cce7f3b2e4846bf4d8728eabe54d60700b318a0b"}, + {file = "cffi-1.17.1-cp311-cp311-win32.whl", hash = "sha256:85a950a4ac9c359340d5963966e3e0a94a676bd6245a4b55bc43949eee26a655"}, + {file = "cffi-1.17.1-cp311-cp311-win_amd64.whl", hash = "sha256:caaf0640ef5f5517f49bc275eca1406b0ffa6aa184892812030f04c2abf589a0"}, + {file = "cffi-1.17.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:805b4371bf7197c329fcb3ead37e710d1bca9da5d583f5073b799d5c5bd1eee4"}, + {file = "cffi-1.17.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:733e99bc2df47476e3848417c5a4540522f234dfd4ef3ab7fafdf555b082ec0c"}, + {file = "cffi-1.17.1-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1257bdabf294dceb59f5e70c64a3e2f462c30c7ad68092d01bbbfb1c16b1ba36"}, + {file = "cffi-1.17.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:da95af8214998d77a98cc14e3a3bd00aa191526343078b530ceb0bd710fb48a5"}, + {file = "cffi-1.17.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d63afe322132c194cf832bfec0dc69a99fb9bb6bbd550f161a49e9e855cc78ff"}, + {file = "cffi-1.17.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f79fc4fc25f1c8698ff97788206bb3c2598949bfe0fef03d299eb1b5356ada99"}, + {file = "cffi-1.17.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b62ce867176a75d03a665bad002af8e6d54644fad99a3c70905c543130e39d93"}, + {file = "cffi-1.17.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:386c8bf53c502fff58903061338ce4f4950cbdcb23e2902d86c0f722b786bbe3"}, + {file = "cffi-1.17.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:4ceb10419a9adf4460ea14cfd6bc43d08701f0835e979bf821052f1805850fe8"}, + {file = "cffi-1.17.1-cp312-cp312-win32.whl", hash = "sha256:a08d7e755f8ed21095a310a693525137cfe756ce62d066e53f502a83dc550f65"}, + {file = "cffi-1.17.1-cp312-cp312-win_amd64.whl", hash = "sha256:51392eae71afec0d0c8fb1a53b204dbb3bcabcb3c9b807eedf3e1e6ccf2de903"}, + {file = "cffi-1.17.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f3a2b4222ce6b60e2e8b337bb9596923045681d71e5a082783484d845390938e"}, + {file = "cffi-1.17.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0984a4925a435b1da406122d4d7968dd861c1385afe3b45ba82b750f229811e2"}, + {file = "cffi-1.17.1-cp313-cp313-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d01b12eeeb4427d3110de311e1774046ad344f5b1a7403101878976ecd7a10f3"}, + {file = "cffi-1.17.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:706510fe141c86a69c8ddc029c7910003a17353970cff3b904ff0686a5927683"}, + {file = "cffi-1.17.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:de55b766c7aa2e2a3092c51e0483d700341182f08e67c63630d5b6f200bb28e5"}, + {file = "cffi-1.17.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c59d6e989d07460165cc5ad3c61f9fd8f1b4796eacbd81cee78957842b834af4"}, + {file = "cffi-1.17.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dd398dbc6773384a17fe0d3e7eeb8d1a21c2200473ee6806bb5e6a8e62bb73dd"}, + {file = "cffi-1.17.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:3edc8d958eb099c634dace3c7e16560ae474aa3803a5df240542b305d14e14ed"}, + {file = "cffi-1.17.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:72e72408cad3d5419375fc87d289076ee319835bdfa2caad331e377589aebba9"}, + {file = "cffi-1.17.1-cp313-cp313-win32.whl", hash = "sha256:e03eab0a8677fa80d646b5ddece1cbeaf556c313dcfac435ba11f107ba117b5d"}, + {file = "cffi-1.17.1-cp313-cp313-win_amd64.whl", hash = "sha256:f6a16c31041f09ead72d69f583767292f750d24913dadacf5756b966aacb3f1a"}, + {file = "cffi-1.17.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:636062ea65bd0195bc012fea9321aca499c0504409f413dc88af450b57ffd03b"}, + {file = "cffi-1.17.1-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c7eac2ef9b63c79431bc4b25f1cd649d7f061a28808cbc6c47b534bd789ef964"}, + {file = "cffi-1.17.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e221cf152cff04059d011ee126477f0d9588303eb57e88923578ace7baad17f9"}, + {file = "cffi-1.17.1-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:31000ec67d4221a71bd3f67df918b1f88f676f1c3b535a7eb473255fdc0b83fc"}, + {file = "cffi-1.17.1-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6f17be4345073b0a7b8ea599688f692ac3ef23ce28e5df79c04de519dbc4912c"}, + {file = "cffi-1.17.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0e2b1fac190ae3ebfe37b979cc1ce69c81f4e4fe5746bb401dca63a9062cdaf1"}, + {file = "cffi-1.17.1-cp38-cp38-win32.whl", hash = "sha256:7596d6620d3fa590f677e9ee430df2958d2d6d6de2feeae5b20e82c00b76fbf8"}, + {file = "cffi-1.17.1-cp38-cp38-win_amd64.whl", hash = "sha256:78122be759c3f8a014ce010908ae03364d00a1f81ab5c7f4a7a5120607ea56e1"}, + {file = "cffi-1.17.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:b2ab587605f4ba0bf81dc0cb08a41bd1c0a5906bd59243d56bad7668a6fc6c16"}, + {file = "cffi-1.17.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:28b16024becceed8c6dfbc75629e27788d8a3f9030691a1dbf9821a128b22c36"}, + {file = "cffi-1.17.1-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1d599671f396c4723d016dbddb72fe8e0397082b0a77a4fab8028923bec050e8"}, + {file = "cffi-1.17.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ca74b8dbe6e8e8263c0ffd60277de77dcee6c837a3d0881d8c1ead7268c9e576"}, + {file = "cffi-1.17.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f7f5baafcc48261359e14bcd6d9bff6d4b28d9103847c9e136694cb0501aef87"}, + {file = "cffi-1.17.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:98e3969bcff97cae1b2def8ba499ea3d6f31ddfdb7635374834cf89a1a08ecf0"}, + {file = "cffi-1.17.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cdf5ce3acdfd1661132f2a9c19cac174758dc2352bfe37d98aa7512c6b7178b3"}, + {file = "cffi-1.17.1-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:9755e4345d1ec879e3849e62222a18c7174d65a6a92d5b346b1863912168b595"}, + {file = "cffi-1.17.1-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:f1e22e8c4419538cb197e4dd60acc919d7696e5ef98ee4da4e01d3f8cfa4cc5a"}, + {file = "cffi-1.17.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:c03e868a0b3bc35839ba98e74211ed2b05d2119be4e8a0f224fba9384f1fe02e"}, + {file = "cffi-1.17.1-cp39-cp39-win32.whl", hash = "sha256:e31ae45bc2e29f6b2abd0de1cc3b9d5205aa847cafaecb8af1476a609a2f6eb7"}, + {file = "cffi-1.17.1-cp39-cp39-win_amd64.whl", hash = "sha256:d016c76bdd850f3c626af19b0542c9677ba156e4ee4fccfdd7848803533ef662"}, + {file = "cffi-1.17.1.tar.gz", hash = "sha256:1c39c6016c32bc48dd54561950ebd6836e1670f2ae46128f67cf49e789c52824"}, +] + +[package.dependencies] +pycparser = "*" + [[package]] name = "cfgv" version = "3.4.0" @@ -479,11 +730,28 @@ files = [ {file = "colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44"}, ] +[[package]] +name = "comm" +version = "0.2.2" +description = "Jupyter Python Comm implementation, for usage in ipykernel, xeus-python etc." +optional = false +python-versions = ">=3.8" +files = [ + {file = "comm-0.2.2-py3-none-any.whl", hash = "sha256:e6fb86cb70ff661ee8c9c14e7d36d6de3b4066f1441be4063df9c5009f0a64d3"}, + {file = "comm-0.2.2.tar.gz", hash = "sha256:3fd7a84065306e07bea1773df6eb8282de51ba82f77c72f9c85716ab11fe980e"}, +] + +[package.dependencies] +traitlets = ">=4" + +[package.extras] +test = ["pytest"] + [[package]] name = "contourpy" version = "1.3.0" description = "Python library for calculating contours of 2D quadrilateral grids" -optional = true +optional = false python-versions = ">=3.9" files = [ {file = "contourpy-1.3.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:880ea32e5c774634f9fcd46504bf9f080a41ad855f4fef54f5380f5133d343c7"}, @@ -752,7 +1020,7 @@ build = ["cmake (>=3.22.4)"] name = "cycler" version = "0.12.1" description = "Composable style cycles" -optional = true +optional = false python-versions = ">=3.8" files = [ {file = "cycler-0.12.1-py3-none-any.whl", hash = "sha256:85cef7cff222d8644161529808465972e51340599459b8ac3ccbac5a854e0d30"}, @@ -763,6 +1031,41 @@ files = [ docs = ["ipython", "matplotlib", "numpydoc", "sphinx"] tests = ["pytest", "pytest-cov", "pytest-xdist"] +[[package]] +name = "debugpy" +version = "1.8.7" +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"}, +] + [[package]] name = "decorator" version = "5.1.1" @@ -774,6 +1077,17 @@ files = [ {file = "decorator-5.1.1.tar.gz", hash = "sha256:637996211036b6385ef91435e4fae22989472f9d571faba8927ba8253acbc330"}, ] +[[package]] +name = "defusedxml" +version = "0.7.1" +description = "XML bomb protection for Python stdlib modules" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" +files = [ + {file = "defusedxml-0.7.1-py2.py3-none-any.whl", hash = "sha256:a352e7e428770286cc899e2542b6cdaedb2b4953ff269a210103ec58f6198a61"}, + {file = "defusedxml-0.7.1.tar.gz", hash = "sha256:1bb3032db185915b62d7c6209c5a8792be6a32ab2fedacc84e01b52c51aa3e69"}, +] + [[package]] name = "dill" version = "0.3.9" @@ -832,6 +1146,34 @@ files = [ [package.extras] test = ["pytest (>=6)"] +[[package]] +name = "executing" +version = "2.1.0" +description = "Get the currently executing AST node of a frame, and other information" +optional = false +python-versions = ">=3.8" +files = [ + {file = "executing-2.1.0-py2.py3-none-any.whl", hash = "sha256:8d63781349375b5ebccc3142f4b30350c0cd9c79f921cde38be2be4637e98eaf"}, + {file = "executing-2.1.0.tar.gz", hash = "sha256:8ea27ddd260da8150fa5a708269c4a10e76161e2496ec3e587da9e3c0fe4b9ab"}, +] + +[package.extras] +tests = ["asttokens (>=2.1.0)", "coverage", "coverage-enable-subprocess", "ipython", "littleutils", "pytest", "rich"] + +[[package]] +name = "fastjsonschema" +version = "2.20.0" +description = "Fastest Python implementation of JSON schema" +optional = false +python-versions = "*" +files = [ + {file = "fastjsonschema-2.20.0-py3-none-any.whl", hash = "sha256:5875f0b0fa7a0043a91e93a9b8f793bcbbba9691e7fd83dca95c28ba26d21f0a"}, + {file = "fastjsonschema-2.20.0.tar.gz", hash = "sha256:3d48fc5300ee96f5d116f10fe6f28d938e6008f59a6a025c2649475b87f76a23"}, +] + +[package.extras] +devel = ["colorama", "json-spec", "jsonschema", "pylint", "pytest", "pytest-benchmark", "pytest-cache", "validictory"] + [[package]] name = "fastparquet" version = "2024.5.0" @@ -904,7 +1246,7 @@ typing = ["typing-extensions (>=4.12.2)"] name = "fonttools" version = "4.54.1" description = "Tools to manipulate font files" -optional = true +optional = false python-versions = ">=3.8" files = [ {file = "fonttools-4.54.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:7ed7ee041ff7b34cc62f07545e55e1468808691dddfd315d51dd82a6b37ddef2"}, @@ -971,6 +1313,17 @@ ufo = ["fs (>=2.2.0,<3)"] unicode = ["unicodedata2 (>=15.1.0)"] woff = ["brotli (>=1.0.1)", "brotlicffi (>=0.8.0)", "zopfli (>=0.1.4)"] +[[package]] +name = "fqdn" +version = "1.5.1" +description = "Validates fully-qualified domain names against RFC 1123, so that they are acceptable to modern bowsers" +optional = false +python-versions = ">=2.7, !=3.0, !=3.1, !=3.2, !=3.3, !=3.4, <4" +files = [ + {file = "fqdn-1.5.1-py3-none-any.whl", hash = "sha256:3a179af3761e4df6eb2e026ff9e1a3033d3587bf980a0b1b2e1e5d08d7358014"}, + {file = "fqdn-1.5.1.tar.gz", hash = "sha256:105ed3677e767fb5ca086a0c1f4bb66ebc3c100be518f0e0d755d9eae164d89f"}, +] + [[package]] name = "frozendict" version = "2.4.6" @@ -1395,6 +1748,103 @@ protobuf = ">=3.20.2,<4.21.1 || >4.21.1,<4.21.2 || >4.21.2,<4.21.3 || >4.21.3,<4 [package.extras] grpc = ["grpcio (>=1.44.0,<2.0.0.dev0)"] +[[package]] +name = "greenlet" +version = "3.1.1" +description = "Lightweight in-process concurrent programming" +optional = false +python-versions = ">=3.7" +files = [ + {file = "greenlet-3.1.1-cp310-cp310-macosx_11_0_universal2.whl", hash = "sha256:0bbae94a29c9e5c7e4a2b7f0aae5c17e8e90acbfd3bf6270eeba60c39fce3563"}, + {file = "greenlet-3.1.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0fde093fb93f35ca72a556cf72c92ea3ebfda3d79fc35bb19fbe685853869a83"}, + {file = "greenlet-3.1.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:36b89d13c49216cadb828db8dfa6ce86bbbc476a82d3a6c397f0efae0525bdd0"}, + {file = "greenlet-3.1.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:94b6150a85e1b33b40b1464a3f9988dcc5251d6ed06842abff82e42632fac120"}, + {file = "greenlet-3.1.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:93147c513fac16385d1036b7e5b102c7fbbdb163d556b791f0f11eada7ba65dc"}, + {file = "greenlet-3.1.1-cp310-cp310-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:da7a9bff22ce038e19bf62c4dd1ec8391062878710ded0a845bcf47cc0200617"}, + {file = "greenlet-3.1.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:b2795058c23988728eec1f36a4e5e4ebad22f8320c85f3587b539b9ac84128d7"}, + {file = "greenlet-3.1.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:ed10eac5830befbdd0c32f83e8aa6288361597550ba669b04c48f0f9a2c843c6"}, + {file = "greenlet-3.1.1-cp310-cp310-win_amd64.whl", hash = "sha256:77c386de38a60d1dfb8e55b8c1101d68c79dfdd25c7095d51fec2dd800892b80"}, + {file = "greenlet-3.1.1-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:e4d333e558953648ca09d64f13e6d8f0523fa705f51cae3f03b5983489958c70"}, + {file = "greenlet-3.1.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:09fc016b73c94e98e29af67ab7b9a879c307c6731a2c9da0db5a7d9b7edd1159"}, + {file = "greenlet-3.1.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d5e975ca70269d66d17dd995dafc06f1b06e8cb1ec1e9ed54c1d1e4a7c4cf26e"}, + {file = "greenlet-3.1.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3b2813dc3de8c1ee3f924e4d4227999285fd335d1bcc0d2be6dc3f1f6a318ec1"}, + {file = "greenlet-3.1.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e347b3bfcf985a05e8c0b7d462ba6f15b1ee1c909e2dcad795e49e91b152c383"}, + {file = "greenlet-3.1.1-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9e8f8c9cb53cdac7ba9793c276acd90168f416b9ce36799b9b885790f8ad6c0a"}, + {file = "greenlet-3.1.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:62ee94988d6b4722ce0028644418d93a52429e977d742ca2ccbe1c4f4a792511"}, + {file = "greenlet-3.1.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:1776fd7f989fc6b8d8c8cb8da1f6b82c5814957264d1f6cf818d475ec2bf6395"}, + {file = "greenlet-3.1.1-cp311-cp311-win_amd64.whl", hash = "sha256:48ca08c771c268a768087b408658e216133aecd835c0ded47ce955381105ba39"}, + {file = "greenlet-3.1.1-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:4afe7ea89de619adc868e087b4d2359282058479d7cfb94970adf4b55284574d"}, + {file = "greenlet-3.1.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f406b22b7c9a9b4f8aa9d2ab13d6ae0ac3e85c9a809bd590ad53fed2bf70dc79"}, + {file = "greenlet-3.1.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c3a701fe5a9695b238503ce5bbe8218e03c3bcccf7e204e455e7462d770268aa"}, + {file = "greenlet-3.1.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2846930c65b47d70b9d178e89c7e1a69c95c1f68ea5aa0a58646b7a96df12441"}, + {file = "greenlet-3.1.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:99cfaa2110534e2cf3ba31a7abcac9d328d1d9f1b95beede58294a60348fba36"}, + {file = "greenlet-3.1.1-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1443279c19fca463fc33e65ef2a935a5b09bb90f978beab37729e1c3c6c25fe9"}, + {file = "greenlet-3.1.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:b7cede291382a78f7bb5f04a529cb18e068dd29e0fb27376074b6d0317bf4dd0"}, + {file = "greenlet-3.1.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:23f20bb60ae298d7d8656c6ec6db134bca379ecefadb0b19ce6f19d1f232a942"}, + {file = "greenlet-3.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:7124e16b4c55d417577c2077be379514321916d5790fa287c9ed6f23bd2ffd01"}, + {file = "greenlet-3.1.1-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:05175c27cb459dcfc05d026c4232f9de8913ed006d42713cb8a5137bd49375f1"}, + {file = "greenlet-3.1.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:935e943ec47c4afab8965954bf49bfa639c05d4ccf9ef6e924188f762145c0ff"}, + {file = "greenlet-3.1.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:667a9706c970cb552ede35aee17339a18e8f2a87a51fba2ed39ceeeb1004798a"}, + {file = "greenlet-3.1.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b8a678974d1f3aa55f6cc34dc480169d58f2e6d8958895d68845fa4ab566509e"}, + {file = "greenlet-3.1.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:efc0f674aa41b92da8c49e0346318c6075d734994c3c4e4430b1c3f853e498e4"}, + {file = "greenlet-3.1.1-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0153404a4bb921f0ff1abeb5ce8a5131da56b953eda6e14b88dc6bbc04d2049e"}, + {file = "greenlet-3.1.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:275f72decf9932639c1c6dd1013a1bc266438eb32710016a1c742df5da6e60a1"}, + {file = "greenlet-3.1.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:c4aab7f6381f38a4b42f269057aee279ab0fc7bf2e929e3d4abfae97b682a12c"}, + {file = "greenlet-3.1.1-cp313-cp313-win_amd64.whl", hash = "sha256:b42703b1cf69f2aa1df7d1030b9d77d3e584a70755674d60e710f0af570f3761"}, + {file = "greenlet-3.1.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f1695e76146579f8c06c1509c7ce4dfe0706f49c6831a817ac04eebb2fd02011"}, + {file = "greenlet-3.1.1-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7876452af029456b3f3549b696bb36a06db7c90747740c5302f74a9e9fa14b13"}, + {file = "greenlet-3.1.1-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4ead44c85f8ab905852d3de8d86f6f8baf77109f9da589cb4fa142bd3b57b475"}, + {file = "greenlet-3.1.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8320f64b777d00dd7ccdade271eaf0cad6636343293a25074cc5566160e4de7b"}, + {file = "greenlet-3.1.1-cp313-cp313t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6510bf84a6b643dabba74d3049ead221257603a253d0a9873f55f6a59a65f822"}, + {file = "greenlet-3.1.1-cp313-cp313t-musllinux_1_1_aarch64.whl", hash = "sha256:04b013dc07c96f83134b1e99888e7a79979f1a247e2a9f59697fa14b5862ed01"}, + {file = "greenlet-3.1.1-cp313-cp313t-musllinux_1_1_x86_64.whl", hash = "sha256:411f015496fec93c1c8cd4e5238da364e1da7a124bcb293f085bf2860c32c6f6"}, + {file = "greenlet-3.1.1-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:47da355d8687fd65240c364c90a31569a133b7b60de111c255ef5b606f2ae291"}, + {file = "greenlet-3.1.1-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:98884ecf2ffb7d7fe6bd517e8eb99d31ff7855a840fa6d0d63cd07c037f6a981"}, + {file = "greenlet-3.1.1-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f1d4aeb8891338e60d1ab6127af1fe45def5259def8094b9c7e34690c8858803"}, + {file = "greenlet-3.1.1-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:db32b5348615a04b82240cc67983cb315309e88d444a288934ee6ceaebcad6cc"}, + {file = "greenlet-3.1.1-cp37-cp37m-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:dcc62f31eae24de7f8dce72134c8651c58000d3b1868e01392baea7c32c247de"}, + {file = "greenlet-3.1.1-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:1d3755bcb2e02de341c55b4fca7a745a24a9e7212ac953f6b3a48d117d7257aa"}, + {file = "greenlet-3.1.1-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:b8da394b34370874b4572676f36acabac172602abf054cbc4ac910219f3340af"}, + {file = "greenlet-3.1.1-cp37-cp37m-win32.whl", hash = "sha256:a0dfc6c143b519113354e780a50381508139b07d2177cb6ad6a08278ec655798"}, + {file = "greenlet-3.1.1-cp37-cp37m-win_amd64.whl", hash = "sha256:54558ea205654b50c438029505def3834e80f0869a70fb15b871c29b4575ddef"}, + {file = "greenlet-3.1.1-cp38-cp38-macosx_11_0_universal2.whl", hash = "sha256:346bed03fe47414091be4ad44786d1bd8bef0c3fcad6ed3dee074a032ab408a9"}, + {file = "greenlet-3.1.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dfc59d69fc48664bc693842bd57acfdd490acafda1ab52c7836e3fc75c90a111"}, + {file = "greenlet-3.1.1-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d21e10da6ec19b457b82636209cbe2331ff4306b54d06fa04b7c138ba18c8a81"}, + {file = "greenlet-3.1.1-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:37b9de5a96111fc15418819ab4c4432e4f3c2ede61e660b1e33971eba26ef9ba"}, + {file = "greenlet-3.1.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6ef9ea3f137e5711f0dbe5f9263e8c009b7069d8a1acea822bd5e9dae0ae49c8"}, + {file = "greenlet-3.1.1-cp38-cp38-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:85f3ff71e2e60bd4b4932a043fbbe0f499e263c628390b285cb599154a3b03b1"}, + {file = "greenlet-3.1.1-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:95ffcf719966dd7c453f908e208e14cde192e09fde6c7186c8f1896ef778d8cd"}, + {file = "greenlet-3.1.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:03a088b9de532cbfe2ba2034b2b85e82df37874681e8c470d6fb2f8c04d7e4b7"}, + {file = "greenlet-3.1.1-cp38-cp38-win32.whl", hash = "sha256:8b8b36671f10ba80e159378df9c4f15c14098c4fd73a36b9ad715f057272fbef"}, + {file = "greenlet-3.1.1-cp38-cp38-win_amd64.whl", hash = "sha256:7017b2be767b9d43cc31416aba48aab0d2309ee31b4dbf10a1d38fb7972bdf9d"}, + {file = "greenlet-3.1.1-cp39-cp39-macosx_11_0_universal2.whl", hash = "sha256:396979749bd95f018296af156201d6211240e7a23090f50a8d5d18c370084dc3"}, + {file = "greenlet-3.1.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ca9d0ff5ad43e785350894d97e13633a66e2b50000e8a183a50a88d834752d42"}, + {file = "greenlet-3.1.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f6ff3b14f2df4c41660a7dec01045a045653998784bf8cfcb5a525bdffffbc8f"}, + {file = "greenlet-3.1.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:94ebba31df2aa506d7b14866fed00ac141a867e63143fe5bca82a8e503b36437"}, + {file = "greenlet-3.1.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:73aaad12ac0ff500f62cebed98d8789198ea0e6f233421059fa68a5aa7220145"}, + {file = "greenlet-3.1.1-cp39-cp39-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:63e4844797b975b9af3a3fb8f7866ff08775f5426925e1e0bbcfe7932059a12c"}, + {file = "greenlet-3.1.1-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:7939aa3ca7d2a1593596e7ac6d59391ff30281ef280d8632fa03d81f7c5f955e"}, + {file = "greenlet-3.1.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:d0028e725ee18175c6e422797c407874da24381ce0690d6b9396c204c7f7276e"}, + {file = "greenlet-3.1.1-cp39-cp39-win32.whl", hash = "sha256:5e06afd14cbaf9e00899fae69b24a32f2196c19de08fcb9f4779dd4f004e5e7c"}, + {file = "greenlet-3.1.1-cp39-cp39-win_amd64.whl", hash = "sha256:3319aa75e0e0639bc15ff54ca327e8dc7a6fe404003496e3c6925cd3142e0e22"}, + {file = "greenlet-3.1.1.tar.gz", hash = "sha256:4ce3ac6cdb6adf7946475d7ef31777c26d94bccc377e070a7986bd2d5c515467"}, +] + +[package.extras] +docs = ["Sphinx", "furo"] +test = ["objgraph", "psutil"] + +[[package]] +name = "h11" +version = "0.14.0" +description = "A pure-Python, bring-your-own-I/O implementation of HTTP/1.1" +optional = false +python-versions = ">=3.7" +files = [ + {file = "h11-0.14.0-py3-none-any.whl", hash = "sha256:e3fe4ac4b851c468cc8363d500db52c2ead036020723024a109d37346efaa761"}, + {file = "h11-0.14.0.tar.gz", hash = "sha256:8f19fbbe99e72420ff35c00b27a34cb9937e902a8b810e2c88300c6f0a3b699d"}, +] + [[package]] name = "html5lib" version = "1.1" @@ -1416,6 +1866,52 @@ chardet = ["chardet (>=2.2)"] genshi = ["genshi"] lxml = ["lxml"] +[[package]] +name = "httpcore" +version = "1.0.6" +description = "A minimal low-level HTTP client." +optional = false +python-versions = ">=3.8" +files = [ + {file = "httpcore-1.0.6-py3-none-any.whl", hash = "sha256:27b59625743b85577a8c0e10e55b50b5368a4f2cfe8cc7bcfa9cf00829c2682f"}, + {file = "httpcore-1.0.6.tar.gz", hash = "sha256:73f6dbd6eb8c21bbf7ef8efad555481853f5f6acdeaff1edb0694289269ee17f"}, +] + +[package.dependencies] +certifi = "*" +h11 = ">=0.13,<0.15" + +[package.extras] +asyncio = ["anyio (>=4.0,<5.0)"] +http2 = ["h2 (>=3,<5)"] +socks = ["socksio (==1.*)"] +trio = ["trio (>=0.22.0,<1.0)"] + +[[package]] +name = "httpx" +version = "0.27.2" +description = "The next generation HTTP client." +optional = false +python-versions = ">=3.8" +files = [ + {file = "httpx-0.27.2-py3-none-any.whl", hash = "sha256:7bb2708e112d8fdd7829cd4243970f0c223274051cb35ee80c03301ee29a3df0"}, + {file = "httpx-0.27.2.tar.gz", hash = "sha256:f7c2be1d2f3c3c3160d441802406b206c2b76f5947b11115e6df10c6c65e66c2"}, +] + +[package.dependencies] +anyio = "*" +certifi = "*" +httpcore = "==1.*" +idna = "*" +sniffio = "*" + +[package.extras] +brotli = ["brotli", "brotlicffi"] +cli = ["click (==8.*)", "pygments (==2.*)", "rich (>=10,<14)"] +http2 = ["h2 (>=3,<5)"] +socks = ["socksio (==1.*)"] +zstd = ["zstandard (>=0.18.0)"] + [[package]] name = "identify" version = "2.6.1" @@ -1455,6 +1951,112 @@ files = [ {file = "iniconfig-2.0.0.tar.gz", hash = "sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3"}, ] +[[package]] +name = "ipykernel" +version = "6.29.5" +description = "IPython Kernel for Jupyter" +optional = false +python-versions = ">=3.8" +files = [ + {file = "ipykernel-6.29.5-py3-none-any.whl", hash = "sha256:afdb66ba5aa354b09b91379bac28ae4afebbb30e8b39510c9690afb7a10421b5"}, + {file = "ipykernel-6.29.5.tar.gz", hash = "sha256:f093a22c4a40f8828f8e330a9c297cb93dcab13bd9678ded6de8e5cf81c56215"}, +] + +[package.dependencies] +appnope = {version = "*", markers = "platform_system == \"Darwin\""} +comm = ">=0.1.1" +debugpy = ">=1.6.5" +ipython = ">=7.23.1" +jupyter-client = ">=6.1.12" +jupyter-core = ">=4.12,<5.0.dev0 || >=5.1.dev0" +matplotlib-inline = ">=0.1" +nest-asyncio = "*" +packaging = "*" +psutil = "*" +pyzmq = ">=24" +tornado = ">=6.1" +traitlets = ">=5.4.0" + +[package.extras] +cov = ["coverage[toml]", "curio", "matplotlib", "pytest-cov", "trio"] +docs = ["myst-parser", "pydata-sphinx-theme", "sphinx", "sphinx-autodoc-typehints", "sphinxcontrib-github-alt", "sphinxcontrib-spelling", "trio"] +pyqt5 = ["pyqt5"] +pyside6 = ["pyside6"] +test = ["flaky", "ipyparallel", "pre-commit", "pytest (>=7.0)", "pytest-asyncio (>=0.23.5)", "pytest-cov", "pytest-timeout"] + +[[package]] +name = "ipython" +version = "8.29.0" +description = "IPython: Productive Interactive Computing" +optional = false +python-versions = ">=3.10" +files = [ + {file = "ipython-8.29.0-py3-none-any.whl", hash = "sha256:0188a1bd83267192123ccea7f4a8ed0a78910535dbaa3f37671dca76ebd429c8"}, + {file = "ipython-8.29.0.tar.gz", hash = "sha256:40b60e15b22591450eef73e40a027cf77bd652e757523eebc5bd7c7c498290eb"}, +] + +[package.dependencies] +colorama = {version = "*", markers = "sys_platform == \"win32\""} +decorator = "*" +exceptiongroup = {version = "*", markers = "python_version < \"3.11\""} +jedi = ">=0.16" +matplotlib-inline = "*" +pexpect = {version = ">4.3", markers = "sys_platform != \"win32\" and sys_platform != \"emscripten\""} +prompt-toolkit = ">=3.0.41,<3.1.0" +pygments = ">=2.4.0" +stack-data = "*" +traitlets = ">=5.13.0" +typing-extensions = {version = ">=4.6", markers = "python_version < \"3.12\""} + +[package.extras] +all = ["ipython[black,doc,kernel,matplotlib,nbconvert,nbformat,notebook,parallel,qtconsole]", "ipython[test,test-extra]"] +black = ["black"] +doc = ["docrepr", "exceptiongroup", "intersphinx-registry", "ipykernel", "ipython[test]", "matplotlib", "setuptools (>=18.5)", "sphinx (>=1.3)", "sphinx-rtd-theme", "sphinxcontrib-jquery", "tomli", "typing-extensions"] +kernel = ["ipykernel"] +matplotlib = ["matplotlib"] +nbconvert = ["nbconvert"] +nbformat = ["nbformat"] +notebook = ["ipywidgets", "notebook"] +parallel = ["ipyparallel"] +qtconsole = ["qtconsole"] +test = ["packaging", "pickleshare", "pytest", "pytest-asyncio (<0.22)", "testpath"] +test-extra = ["curio", "ipython[test]", "matplotlib (!=3.2.0)", "nbformat", "numpy (>=1.23)", "pandas", "trio"] + +[[package]] +name = "ipywidgets" +version = "8.1.5" +description = "Jupyter interactive widgets" +optional = false +python-versions = ">=3.7" +files = [ + {file = "ipywidgets-8.1.5-py3-none-any.whl", hash = "sha256:3290f526f87ae6e77655555baba4f36681c555b8bdbbff430b70e52c34c86245"}, + {file = "ipywidgets-8.1.5.tar.gz", hash = "sha256:870e43b1a35656a80c18c9503bbf2d16802db1cb487eec6fab27d683381dde17"}, +] + +[package.dependencies] +comm = ">=0.1.3" +ipython = ">=6.1.0" +jupyterlab-widgets = ">=3.0.12,<3.1.0" +traitlets = ">=4.3.1" +widgetsnbextension = ">=4.0.12,<4.1.0" + +[package.extras] +test = ["ipykernel", "jsonschema", "pytest (>=3.6.0)", "pytest-cov", "pytz"] + +[[package]] +name = "isoduration" +version = "20.11.0" +description = "Operations with ISO 8601 durations" +optional = false +python-versions = ">=3.7" +files = [ + {file = "isoduration-20.11.0-py3-none-any.whl", hash = "sha256:b2904c2a4228c3d44f409c8ae8e2370eb21a26f7ac2ec5446df141dde3452042"}, + {file = "isoduration-20.11.0.tar.gz", hash = "sha256:ac2f9015137935279eac671f94f89eb00584f940f5dc49462a0c4ee692ba1bd9"}, +] + +[package.dependencies] +arrow = ">=0.15.0" + [[package]] name = "isort" version = "5.13.2" @@ -1469,6 +2071,25 @@ files = [ [package.extras] colors = ["colorama (>=0.4.6)"] +[[package]] +name = "jedi" +version = "0.19.1" +description = "An autocompletion tool for Python that can be used for text editors." +optional = false +python-versions = ">=3.6" +files = [ + {file = "jedi-0.19.1-py2.py3-none-any.whl", hash = "sha256:e983c654fe5c02867aef4cdfce5a2fbb4a50adc0af145f70504238f18ef5e7e0"}, + {file = "jedi-0.19.1.tar.gz", hash = "sha256:cf0496f3651bc65d7174ac1b7d043eff454892c708a87d1b683e57b569927ffd"}, +] + +[package.dependencies] +parso = ">=0.8.3,<0.9.0" + +[package.extras] +docs = ["Jinja2 (==2.11.3)", "MarkupSafe (==1.1.1)", "Pygments (==2.8.1)", "alabaster (==0.7.12)", "babel (==2.9.1)", "chardet (==4.0.0)", "commonmark (==0.8.1)", "docutils (==0.17.1)", "future (==0.18.2)", "idna (==2.10)", "imagesize (==1.2.0)", "mock (==1.0.1)", "packaging (==20.9)", "pyparsing (==2.4.7)", "pytz (==2021.1)", "readthedocs-sphinx-ext (==2.1.4)", "recommonmark (==0.5.0)", "requests (==2.25.1)", "six (==1.15.0)", "snowballstemmer (==2.1.0)", "sphinx (==1.8.5)", "sphinx-rtd-theme (==0.4.3)", "sphinxcontrib-serializinghtml (==1.1.4)", "sphinxcontrib-websupport (==1.2.4)", "urllib3 (==1.26.4)"] +qa = ["flake8 (==5.0.4)", "mypy (==0.971)", "types-setuptools (==67.2.0.1)"] +testing = ["Django", "attrs", "colorama", "docopt", "pytest (<7.0.0)"] + [[package]] name = "jinja2" version = "3.1.4" @@ -1486,6 +2107,39 @@ MarkupSafe = ">=2.0" [package.extras] i18n = ["Babel (>=2.7)"] +[[package]] +name = "joblib" +version = "1.4.2" +description = "Lightweight pipelining with Python functions" +optional = false +python-versions = ">=3.8" +files = [ + {file = "joblib-1.4.2-py3-none-any.whl", hash = "sha256:06d478d5674cbc267e7496a410ee875abd68e4340feff4490bcb7afb88060ae6"}, + {file = "joblib-1.4.2.tar.gz", hash = "sha256:2382c5816b2636fbd20a09e0f4e9dad4736765fdfb7dca582943b9c1366b3f0e"}, +] + +[[package]] +name = "json5" +version = "0.9.25" +description = "A Python implementation of the JSON5 data format." +optional = false +python-versions = ">=3.8" +files = [ + {file = "json5-0.9.25-py3-none-any.whl", hash = "sha256:34ed7d834b1341a86987ed52f3f76cd8ee184394906b6e22a1e0deb9ab294e8f"}, + {file = "json5-0.9.25.tar.gz", hash = "sha256:548e41b9be043f9426776f05df8635a00fe06104ea51ed24b67f908856e151ae"}, +] + +[[package]] +name = "jsonpointer" +version = "3.0.0" +description = "Identify specific nodes in a JSON document (RFC 6901)" +optional = false +python-versions = ">=3.7" +files = [ + {file = "jsonpointer-3.0.0-py2.py3-none-any.whl", hash = "sha256:13e088adc14fca8b6aa8177c044e12701e6ad4b28ff10e65f2267a90109c9942"}, + {file = "jsonpointer-3.0.0.tar.gz", hash = "sha256:2b2d729f2091522d61c3b31f82e11870f60b68f43fbc705cb76bf4b832af59ef"}, +] + [[package]] name = "jsonschema" version = "4.23.0" @@ -1499,9 +2153,17 @@ files = [ [package.dependencies] attrs = ">=22.2.0" +fqdn = {version = "*", optional = true, markers = "extra == \"format-nongpl\""} +idna = {version = "*", optional = true, markers = "extra == \"format-nongpl\""} +isoduration = {version = "*", optional = true, markers = "extra == \"format-nongpl\""} +jsonpointer = {version = ">1.13", optional = true, markers = "extra == \"format-nongpl\""} jsonschema-specifications = ">=2023.03.6" referencing = ">=0.28.4" +rfc3339-validator = {version = "*", optional = true, markers = "extra == \"format-nongpl\""} +rfc3986-validator = {version = ">0.1.0", optional = true, markers = "extra == \"format-nongpl\""} rpds-py = ">=0.7.1" +uri-template = {version = "*", optional = true, markers = "extra == \"format-nongpl\""} +webcolors = {version = ">=24.6.0", optional = true, markers = "extra == \"format-nongpl\""} [package.extras] format = ["fqdn", "idna", "isoduration", "jsonpointer (>1.13)", "rfc3339-validator", "rfc3987", "uri-template", "webcolors (>=1.11)"] @@ -1521,11 +2183,271 @@ files = [ [package.dependencies] referencing = ">=0.31.0" +[[package]] +name = "jupyter" +version = "1.1.1" +description = "Jupyter metapackage. Install all the Jupyter components in one go." +optional = false +python-versions = "*" +files = [ + {file = "jupyter-1.1.1-py2.py3-none-any.whl", hash = "sha256:7a59533c22af65439b24bbe60373a4e95af8f16ac65a6c00820ad378e3f7cc83"}, + {file = "jupyter-1.1.1.tar.gz", hash = "sha256:d55467bceabdea49d7e3624af7e33d59c37fff53ed3a350e1ac957bed731de7a"}, +] + +[package.dependencies] +ipykernel = "*" +ipywidgets = "*" +jupyter-console = "*" +jupyterlab = "*" +nbconvert = "*" +notebook = "*" + +[[package]] +name = "jupyter-client" +version = "8.6.3" +description = "Jupyter protocol implementation and client libraries" +optional = false +python-versions = ">=3.8" +files = [ + {file = "jupyter_client-8.6.3-py3-none-any.whl", hash = "sha256:e8a19cc986cc45905ac3362915f410f3af85424b4c0905e94fa5f2cb08e8f23f"}, + {file = "jupyter_client-8.6.3.tar.gz", hash = "sha256:35b3a0947c4a6e9d589eb97d7d4cd5e90f910ee73101611f01283732bd6d9419"}, +] + +[package.dependencies] +jupyter-core = ">=4.12,<5.0.dev0 || >=5.1.dev0" +python-dateutil = ">=2.8.2" +pyzmq = ">=23.0" +tornado = ">=6.2" +traitlets = ">=5.3" + +[package.extras] +docs = ["ipykernel", "myst-parser", "pydata-sphinx-theme", "sphinx (>=4)", "sphinx-autodoc-typehints", "sphinxcontrib-github-alt", "sphinxcontrib-spelling"] +test = ["coverage", "ipykernel (>=6.14)", "mypy", "paramiko", "pre-commit", "pytest (<8.2.0)", "pytest-cov", "pytest-jupyter[client] (>=0.4.1)", "pytest-timeout"] + +[[package]] +name = "jupyter-console" +version = "6.6.3" +description = "Jupyter terminal console" +optional = false +python-versions = ">=3.7" +files = [ + {file = "jupyter_console-6.6.3-py3-none-any.whl", hash = "sha256:309d33409fcc92ffdad25f0bcdf9a4a9daa61b6f341177570fdac03de5352485"}, + {file = "jupyter_console-6.6.3.tar.gz", hash = "sha256:566a4bf31c87adbfadf22cdf846e3069b59a71ed5da71d6ba4d8aaad14a53539"}, +] + +[package.dependencies] +ipykernel = ">=6.14" +ipython = "*" +jupyter-client = ">=7.0.0" +jupyter-core = ">=4.12,<5.0.dev0 || >=5.1.dev0" +prompt-toolkit = ">=3.0.30" +pygments = "*" +pyzmq = ">=17" +traitlets = ">=5.4" + +[package.extras] +test = ["flaky", "pexpect", "pytest"] + +[[package]] +name = "jupyter-core" +version = "5.7.2" +description = "Jupyter core package. A base package on which Jupyter projects rely." +optional = false +python-versions = ">=3.8" +files = [ + {file = "jupyter_core-5.7.2-py3-none-any.whl", hash = "sha256:4f7315d2f6b4bcf2e3e7cb6e46772eba760ae459cd1f59d29eb57b0a01bd7409"}, + {file = "jupyter_core-5.7.2.tar.gz", hash = "sha256:aa5f8d32bbf6b431ac830496da7392035d6f61b4f54872f15c4bd2a9c3f536d9"}, +] + +[package.dependencies] +platformdirs = ">=2.5" +pywin32 = {version = ">=300", markers = "sys_platform == \"win32\" and platform_python_implementation != \"PyPy\""} +traitlets = ">=5.3" + +[package.extras] +docs = ["myst-parser", "pydata-sphinx-theme", "sphinx-autodoc-typehints", "sphinxcontrib-github-alt", "sphinxcontrib-spelling", "traitlets"] +test = ["ipykernel", "pre-commit", "pytest (<8)", "pytest-cov", "pytest-timeout"] + +[[package]] +name = "jupyter-events" +version = "0.10.0" +description = "Jupyter Event System library" +optional = false +python-versions = ">=3.8" +files = [ + {file = "jupyter_events-0.10.0-py3-none-any.whl", hash = "sha256:4b72130875e59d57716d327ea70d3ebc3af1944d3717e5a498b8a06c6c159960"}, + {file = "jupyter_events-0.10.0.tar.gz", hash = "sha256:670b8229d3cc882ec782144ed22e0d29e1c2d639263f92ca8383e66682845e22"}, +] + +[package.dependencies] +jsonschema = {version = ">=4.18.0", extras = ["format-nongpl"]} +python-json-logger = ">=2.0.4" +pyyaml = ">=5.3" +referencing = "*" +rfc3339-validator = "*" +rfc3986-validator = ">=0.1.1" +traitlets = ">=5.3" + +[package.extras] +cli = ["click", "rich"] +docs = ["jupyterlite-sphinx", "myst-parser", "pydata-sphinx-theme", "sphinxcontrib-spelling"] +test = ["click", "pre-commit", "pytest (>=7.0)", "pytest-asyncio (>=0.19.0)", "pytest-console-scripts", "rich"] + +[[package]] +name = "jupyter-lsp" +version = "2.2.5" +description = "Multi-Language Server WebSocket proxy for Jupyter Notebook/Lab server" +optional = false +python-versions = ">=3.8" +files = [ + {file = "jupyter-lsp-2.2.5.tar.gz", hash = "sha256:793147a05ad446f809fd53ef1cd19a9f5256fd0a2d6b7ce943a982cb4f545001"}, + {file = "jupyter_lsp-2.2.5-py3-none-any.whl", hash = "sha256:45fbddbd505f3fbfb0b6cb2f1bc5e15e83ab7c79cd6e89416b248cb3c00c11da"}, +] + +[package.dependencies] +jupyter-server = ">=1.1.2" + +[[package]] +name = "jupyter-server" +version = "2.14.2" +description = "The backend—i.e. core services, APIs, and REST endpoints—to Jupyter web applications." +optional = false +python-versions = ">=3.8" +files = [ + {file = "jupyter_server-2.14.2-py3-none-any.whl", hash = "sha256:47ff506127c2f7851a17bf4713434208fc490955d0e8632e95014a9a9afbeefd"}, + {file = "jupyter_server-2.14.2.tar.gz", hash = "sha256:66095021aa9638ced276c248b1d81862e4c50f292d575920bbe960de1c56b12b"}, +] + +[package.dependencies] +anyio = ">=3.1.0" +argon2-cffi = ">=21.1" +jinja2 = ">=3.0.3" +jupyter-client = ">=7.4.4" +jupyter-core = ">=4.12,<5.0.dev0 || >=5.1.dev0" +jupyter-events = ">=0.9.0" +jupyter-server-terminals = ">=0.4.4" +nbconvert = ">=6.4.4" +nbformat = ">=5.3.0" +overrides = ">=5.0" +packaging = ">=22.0" +prometheus-client = ">=0.9" +pywinpty = {version = ">=2.0.1", markers = "os_name == \"nt\""} +pyzmq = ">=24" +send2trash = ">=1.8.2" +terminado = ">=0.8.3" +tornado = ">=6.2.0" +traitlets = ">=5.6.0" +websocket-client = ">=1.7" + +[package.extras] +docs = ["ipykernel", "jinja2", "jupyter-client", "myst-parser", "nbformat", "prometheus-client", "pydata-sphinx-theme", "send2trash", "sphinx-autodoc-typehints", "sphinxcontrib-github-alt", "sphinxcontrib-openapi (>=0.8.0)", "sphinxcontrib-spelling", "sphinxemoji", "tornado", "typing-extensions"] +test = ["flaky", "ipykernel", "pre-commit", "pytest (>=7.0,<9)", "pytest-console-scripts", "pytest-jupyter[server] (>=0.7)", "pytest-timeout", "requests"] + +[[package]] +name = "jupyter-server-terminals" +version = "0.5.3" +description = "A Jupyter Server Extension Providing Terminals." +optional = false +python-versions = ">=3.8" +files = [ + {file = "jupyter_server_terminals-0.5.3-py3-none-any.whl", hash = "sha256:41ee0d7dc0ebf2809c668e0fc726dfaf258fcd3e769568996ca731b6194ae9aa"}, + {file = "jupyter_server_terminals-0.5.3.tar.gz", hash = "sha256:5ae0295167220e9ace0edcfdb212afd2b01ee8d179fe6f23c899590e9b8a5269"}, +] + +[package.dependencies] +pywinpty = {version = ">=2.0.3", markers = "os_name == \"nt\""} +terminado = ">=0.8.3" + +[package.extras] +docs = ["jinja2", "jupyter-server", "mistune (<4.0)", "myst-parser", "nbformat", "packaging", "pydata-sphinx-theme", "sphinxcontrib-github-alt", "sphinxcontrib-openapi", "sphinxcontrib-spelling", "sphinxemoji", "tornado"] +test = ["jupyter-server (>=2.0.0)", "pytest (>=7.0)", "pytest-jupyter[server] (>=0.5.3)", "pytest-timeout"] + +[[package]] +name = "jupyterlab" +version = "4.2.5" +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"}, +] + +[package.dependencies] +async-lru = ">=1.0.0" +httpx = ">=0.25.0" +ipykernel = ">=6.5.0" +jinja2 = ">=3.0.3" +jupyter-core = "*" +jupyter-lsp = ">=2.0.0" +jupyter-server = ">=2.4.0,<3" +jupyterlab-server = ">=2.27.1,<3" +notebook-shim = ">=0.2" +packaging = "*" +setuptools = ">=40.1.0" +tomli = {version = ">=1.2.2", markers = "python_version < \"3.11\""} +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)"] +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)"] + +[[package]] +name = "jupyterlab-pygments" +version = "0.3.0" +description = "Pygments theme using JupyterLab CSS variables" +optional = false +python-versions = ">=3.8" +files = [ + {file = "jupyterlab_pygments-0.3.0-py3-none-any.whl", hash = "sha256:841a89020971da1d8693f1a99997aefc5dc424bb1b251fd6322462a1b8842780"}, + {file = "jupyterlab_pygments-0.3.0.tar.gz", hash = "sha256:721aca4d9029252b11cfa9d185e5b5af4d54772bb8072f9b7036f4170054d35d"}, +] + +[[package]] +name = "jupyterlab-server" +version = "2.27.3" +description = "A set of server components for JupyterLab and JupyterLab like applications." +optional = false +python-versions = ">=3.8" +files = [ + {file = "jupyterlab_server-2.27.3-py3-none-any.whl", hash = "sha256:e697488f66c3db49df675158a77b3b017520d772c6e1548c7d9bcc5df7944ee4"}, + {file = "jupyterlab_server-2.27.3.tar.gz", hash = "sha256:eb36caca59e74471988f0ae25c77945610b887f777255aa21f8065def9e51ed4"}, +] + +[package.dependencies] +babel = ">=2.10" +jinja2 = ">=3.0.3" +json5 = ">=0.9.0" +jsonschema = ">=4.18.0" +jupyter-server = ">=1.21,<3" +packaging = ">=21.3" +requests = ">=2.31" + +[package.extras] +docs = ["autodoc-traits", "jinja2 (<3.2.0)", "mistune (<4)", "myst-parser", "pydata-sphinx-theme", "sphinx", "sphinx-copybutton", "sphinxcontrib-openapi (>0.8)"] +openapi = ["openapi-core (>=0.18.0,<0.19.0)", "ruamel-yaml"] +test = ["hatch", "ipykernel", "openapi-core (>=0.18.0,<0.19.0)", "openapi-spec-validator (>=0.6.0,<0.8.0)", "pytest (>=7.0,<8)", "pytest-console-scripts", "pytest-cov", "pytest-jupyter[server] (>=0.6.2)", "pytest-timeout", "requests-mock", "ruamel-yaml", "sphinxcontrib-spelling", "strict-rfc3339", "werkzeug"] + +[[package]] +name = "jupyterlab-widgets" +version = "3.0.13" +description = "Jupyter interactive widgets for JupyterLab" +optional = false +python-versions = ">=3.7" +files = [ + {file = "jupyterlab_widgets-3.0.13-py3-none-any.whl", hash = "sha256:e3cda2c233ce144192f1e29914ad522b2f4c40e77214b0cc97377ca3d323db54"}, + {file = "jupyterlab_widgets-3.0.13.tar.gz", hash = "sha256:a2966d385328c1942b683a8cd96b89b8dd82c8b8f81dda902bb2bc06d46f5bed"}, +] + [[package]] name = "kiwisolver" version = "1.4.7" description = "A fast implementation of the Cassowary constraint solver" -optional = true +optional = false python-versions = ">=3.8" files = [ {file = "kiwisolver-1.4.7-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:8a9c83f75223d5e48b0bc9cb1bf2776cf01563e00ade8775ffe13b0b6e1af3a6"}, @@ -1975,7 +2897,7 @@ tests = ["mock", "pytest"] name = "matplotlib" version = "3.8.0" description = "Python plotting package" -optional = true +optional = false python-versions = ">=3.9" files = [ {file = "matplotlib-3.8.0-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:c4940bad88a932ddc69734274f6fb047207e008389489f2b6f77d9ca485f0e7a"}, @@ -2020,6 +2942,38 @@ pyparsing = ">=2.3.1" python-dateutil = ">=2.7" setuptools_scm = ">=7" +[[package]] +name = "matplotlib-inline" +version = "0.1.7" +description = "Inline Matplotlib backend for Jupyter" +optional = false +python-versions = ">=3.8" +files = [ + {file = "matplotlib_inline-0.1.7-py3-none-any.whl", hash = "sha256:df192d39a4ff8f21b1895d72e6a13f5fcc5099f00fa84384e0ea28c2cc0653ca"}, + {file = "matplotlib_inline-0.1.7.tar.gz", hash = "sha256:8423b23ec666be3d16e16b60bdd8ac4e86e840ebd1dd11a30b9f117f2fa0ab90"}, +] + +[package.dependencies] +traitlets = "*" + +[[package]] +name = "matplotlib-venn" +version = "1.1.1" +description = "Functions for plotting area-proportional two- and three-way Venn diagrams in matplotlib." +optional = false +python-versions = "*" +files = [ + {file = "matplotlib-venn-1.1.1.tar.gz", hash = "sha256:d885bc015f5091a4b8a8138ff20a7ed166c33b5c36dbc0489f95a5cbc76a2ae5"}, +] + +[package.dependencies] +matplotlib = "*" +numpy = "*" +scipy = "*" + +[package.extras] +shapely = ["shapely"] + [[package]] name = "mdurl" version = "0.1.2" @@ -2031,6 +2985,17 @@ files = [ {file = "mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba"}, ] +[[package]] +name = "mistune" +version = "3.0.2" +description = "A sane and fast Markdown parser with useful plugins and renderers" +optional = false +python-versions = ">=3.7" +files = [ + {file = "mistune-3.0.2-py3-none-any.whl", hash = "sha256:71481854c30fdbc938963d3605b72501f5c10a9320ecd412c121c163a1c7d205"}, + {file = "mistune-3.0.2.tar.gz", hash = "sha256:fc7f93ded930c92394ef2cb6f04a8aabab4117a91449e72dcc8dfa646a508be8"}, +] + [[package]] name = "mpmath" version = "1.3.0" @@ -2193,6 +3158,97 @@ pandas = ["pandas (>=0.25.3)"] polars = ["polars (>=0.20.3)"] pyarrow = ["pyarrow (>=11.0.0)"] +[[package]] +name = "nbclient" +version = "0.10.0" +description = "A client library for executing notebooks. Formerly nbconvert's ExecutePreprocessor." +optional = false +python-versions = ">=3.8.0" +files = [ + {file = "nbclient-0.10.0-py3-none-any.whl", hash = "sha256:f13e3529332a1f1f81d82a53210322476a168bb7090a0289c795fe9cc11c9d3f"}, + {file = "nbclient-0.10.0.tar.gz", hash = "sha256:4b3f1b7dba531e498449c4db4f53da339c91d449dc11e9af3a43b4eb5c5abb09"}, +] + +[package.dependencies] +jupyter-client = ">=6.1.12" +jupyter-core = ">=4.12,<5.0.dev0 || >=5.1.dev0" +nbformat = ">=5.1" +traitlets = ">=5.4" + +[package.extras] +dev = ["pre-commit"] +docs = ["autodoc-traits", "mock", "moto", "myst-parser", "nbclient[test]", "sphinx (>=1.7)", "sphinx-book-theme", "sphinxcontrib-spelling"] +test = ["flaky", "ipykernel (>=6.19.3)", "ipython", "ipywidgets", "nbconvert (>=7.0.0)", "pytest (>=7.0,<8)", "pytest-asyncio", "pytest-cov (>=4.0)", "testpath", "xmltodict"] + +[[package]] +name = "nbconvert" +version = "7.16.4" +description = "Converting Jupyter Notebooks (.ipynb files) to other formats. Output formats include asciidoc, html, latex, markdown, pdf, py, rst, script. nbconvert can be used both as a Python library (`import nbconvert`) or as a command line tool (invoked as `jupyter nbconvert ...`)." +optional = false +python-versions = ">=3.8" +files = [ + {file = "nbconvert-7.16.4-py3-none-any.whl", hash = "sha256:05873c620fe520b6322bf8a5ad562692343fe3452abda5765c7a34b7d1aa3eb3"}, + {file = "nbconvert-7.16.4.tar.gz", hash = "sha256:86ca91ba266b0a448dc96fa6c5b9d98affabde2867b363258703536807f9f7f4"}, +] + +[package.dependencies] +beautifulsoup4 = "*" +bleach = "!=5.0.0" +defusedxml = "*" +jinja2 = ">=3.0" +jupyter-core = ">=4.7" +jupyterlab-pygments = "*" +markupsafe = ">=2.0" +mistune = ">=2.0.3,<4" +nbclient = ">=0.5.0" +nbformat = ">=5.7" +packaging = "*" +pandocfilters = ">=1.4.1" +pygments = ">=2.4.1" +tinycss2 = "*" +traitlets = ">=5.1" + +[package.extras] +all = ["flaky", "ipykernel", "ipython", "ipywidgets (>=7.5)", "myst-parser", "nbsphinx (>=0.2.12)", "playwright", "pydata-sphinx-theme", "pyqtwebengine (>=5.15)", "pytest (>=7)", "sphinx (==5.0.2)", "sphinxcontrib-spelling", "tornado (>=6.1)"] +docs = ["ipykernel", "ipython", "myst-parser", "nbsphinx (>=0.2.12)", "pydata-sphinx-theme", "sphinx (==5.0.2)", "sphinxcontrib-spelling"] +qtpdf = ["pyqtwebengine (>=5.15)"] +qtpng = ["pyqtwebengine (>=5.15)"] +serve = ["tornado (>=6.1)"] +test = ["flaky", "ipykernel", "ipywidgets (>=7.5)", "pytest (>=7)"] +webpdf = ["playwright"] + +[[package]] +name = "nbformat" +version = "5.10.4" +description = "The Jupyter Notebook format" +optional = false +python-versions = ">=3.8" +files = [ + {file = "nbformat-5.10.4-py3-none-any.whl", hash = "sha256:3b48d6c8fbca4b299bf3982ea7db1af21580e4fec269ad087b9e81588891200b"}, + {file = "nbformat-5.10.4.tar.gz", hash = "sha256:322168b14f937a5d11362988ecac2a4952d3d8e3a2cbeb2319584631226d5b3a"}, +] + +[package.dependencies] +fastjsonschema = ">=2.15" +jsonschema = ">=2.6" +jupyter-core = ">=4.12,<5.0.dev0 || >=5.1.dev0" +traitlets = ">=5.1" + +[package.extras] +docs = ["myst-parser", "pydata-sphinx-theme", "sphinx", "sphinxcontrib-github-alt", "sphinxcontrib-spelling"] +test = ["pep440", "pre-commit", "pytest", "testpath"] + +[[package]] +name = "nest-asyncio" +version = "1.6.0" +description = "Patch asyncio to allow nested event loops" +optional = false +python-versions = ">=3.5" +files = [ + {file = "nest_asyncio-1.6.0-py3-none-any.whl", hash = "sha256:87af6efd6b5e897c81050477ef65c62e2b2f35d51703cae01aff2905b1852e1c"}, + {file = "nest_asyncio-1.6.0.tar.gz", hash = "sha256:6f172d5449aca15afd6c646851f4e31e02c598d553a667e38cafa997cfec55fe"}, +] + [[package]] name = "nodeenv" version = "1.9.1" @@ -2204,6 +3260,46 @@ files = [ {file = "nodeenv-1.9.1.tar.gz", hash = "sha256:6ec12890a2dab7946721edbfbcd91f3319c6ccc9aec47be7c7e6b7011ee6645f"}, ] +[[package]] +name = "notebook" +version = "7.2.2" +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"}, +] + +[package.dependencies] +jupyter-server = ">=2.4.0,<3" +jupyterlab = ">=4.2.0,<4.3" +jupyterlab-server = ">=2.27.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"] + +[[package]] +name = "notebook-shim" +version = "0.2.4" +description = "A shim layer for notebook traits and config" +optional = false +python-versions = ">=3.7" +files = [ + {file = "notebook_shim-0.2.4-py3-none-any.whl", hash = "sha256:411a5be4e9dc882a074ccbcae671eda64cceb068767e9a3419096986560e1cef"}, + {file = "notebook_shim-0.2.4.tar.gz", hash = "sha256:b4b2cfa1b65d98307ca24361f5b30fe785b53c3fd07b7a47e89acb5e6ac638cb"}, +] + +[package.dependencies] +jupyter-server = ">=1.8,<3" + +[package.extras] +test = ["pytest", "pytest-console-scripts", "pytest-jupyter", "pytest-tornasync"] + [[package]] name = "numpy" version = "1.26.4" @@ -2265,6 +3361,17 @@ rsa = ["cryptography (>=3.0.0)"] signals = ["blinker (>=1.4.0)"] signedtoken = ["cryptography (>=3.0.0)", "pyjwt (>=2.0.0,<3)"] +[[package]] +name = "overrides" +version = "7.7.0" +description = "A decorator to automatically detect mismatch when overriding a method." +optional = false +python-versions = ">=3.6" +files = [ + {file = "overrides-7.7.0-py3-none-any.whl", hash = "sha256:c7ed9d062f78b8e4c1a7b70bd8796b35ead4d9f510227ef9c5dc7626c60d7e49"}, + {file = "overrides-7.7.0.tar.gz", hash = "sha256:55158fa3d93b98cc75299b1e67078ad9003ca27945c76162c1c0766d6f91820a"}, +] + [[package]] name = "packaging" version = "24.1" @@ -2362,6 +3469,32 @@ sql-other = ["SQLAlchemy (>=2.0.0)", "adbc-driver-postgresql (>=0.8.0)", "adbc-d test = ["hypothesis (>=6.46.1)", "pytest (>=7.3.2)", "pytest-xdist (>=2.2.0)"] xml = ["lxml (>=4.9.2)"] +[[package]] +name = "pandocfilters" +version = "1.5.1" +description = "Utilities for writing pandoc filters in python" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +files = [ + {file = "pandocfilters-1.5.1-py2.py3-none-any.whl", hash = "sha256:93be382804a9cdb0a7267585f157e5d1731bbe5545a85b268d6f5fe6232de2bc"}, + {file = "pandocfilters-1.5.1.tar.gz", hash = "sha256:002b4a555ee4ebc03f8b66307e287fa492e4a77b4ea14d3f934328297bb4939e"}, +] + +[[package]] +name = "parso" +version = "0.8.4" +description = "A Python Parser" +optional = false +python-versions = ">=3.6" +files = [ + {file = "parso-0.8.4-py2.py3-none-any.whl", hash = "sha256:a418670a20291dacd2dddc80c377c5c3791378ee1e8d12bffc35420643d43f18"}, + {file = "parso-0.8.4.tar.gz", hash = "sha256:eb3a7b58240fb99099a345571deecc0f9540ea5f4dd2fe14c2a99d6b281ab92d"}, +] + +[package.extras] +qa = ["flake8 (==5.0.4)", "mypy (==0.971)", "types-setuptools (==67.2.0.1)"] +testing = ["docopt", "pytest"] + [[package]] name = "pathspec" version = "0.12.1" @@ -2383,6 +3516,20 @@ files = [ {file = "peewee-3.17.7.tar.gz", hash = "sha256:6aefc700bd530fc6ac23fa19c9c5b47041751d92985b799169c8e318e97eabaa"}, ] +[[package]] +name = "pexpect" +version = "4.9.0" +description = "Pexpect allows easy control of interactive console applications." +optional = false +python-versions = "*" +files = [ + {file = "pexpect-4.9.0-py2.py3-none-any.whl", hash = "sha256:7236d1e080e4936be2dc3e326cec0af72acf9212a7e1d060210e70a47e253523"}, + {file = "pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f"}, +] + +[package.dependencies] +ptyprocess = ">=0.5" + [[package]] name = "pillow" version = "10.4.0" @@ -2619,6 +3766,34 @@ nodeenv = ">=0.11.1" pyyaml = ">=5.1" virtualenv = ">=20.10.0" +[[package]] +name = "prometheus-client" +version = "0.21.0" +description = "Python client for the Prometheus monitoring system." +optional = false +python-versions = ">=3.8" +files = [ + {file = "prometheus_client-0.21.0-py3-none-any.whl", hash = "sha256:4fa6b4dd0ac16d58bb587c04b1caae65b8c5043e85f778f42f5f632f6af2e166"}, + {file = "prometheus_client-0.21.0.tar.gz", hash = "sha256:96c83c606b71ff2b0a433c98889d275f51ffec6c5e267de37c7a2b5c9aa9233e"}, +] + +[package.extras] +twisted = ["twisted"] + +[[package]] +name = "prompt-toolkit" +version = "3.0.48" +description = "Library for building powerful interactive command lines in Python" +optional = false +python-versions = ">=3.7.0" +files = [ + {file = "prompt_toolkit-3.0.48-py3-none-any.whl", hash = "sha256:f49a827f90062e411f1ce1f854f2aedb3c23353244f8108b89283587397ac10e"}, + {file = "prompt_toolkit-3.0.48.tar.gz", hash = "sha256:d6623ab0477a80df74e646bdbc93621143f5caf104206aa29294d53de1a03d90"}, +] + +[package.dependencies] +wcwidth = "*" + [[package]] name = "propcache" version = "0.2.0" @@ -2763,6 +3938,36 @@ files = [ {file = "protobuf-5.28.3.tar.gz", hash = "sha256:64badbc49180a5e401f373f9ce7ab1d18b63f7dd4a9cdc43c92b9f0b481cef7b"}, ] +[[package]] +name = "psutil" +version = "6.1.0" +description = "Cross-platform lib for process and system monitoring in Python." +optional = false +python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7" +files = [ + {file = "psutil-6.1.0-cp27-cp27m-macosx_10_9_x86_64.whl", hash = "sha256:ff34df86226c0227c52f38b919213157588a678d049688eded74c76c8ba4a5d0"}, + {file = "psutil-6.1.0-cp27-cp27m-manylinux2010_i686.whl", hash = "sha256:c0e0c00aa18ca2d3b2b991643b799a15fc8f0563d2ebb6040f64ce8dc027b942"}, + {file = "psutil-6.1.0-cp27-cp27m-manylinux2010_x86_64.whl", hash = "sha256:000d1d1ebd634b4efb383f4034437384e44a6d455260aaee2eca1e9c1b55f047"}, + {file = "psutil-6.1.0-cp27-cp27mu-manylinux2010_i686.whl", hash = "sha256:5cd2bcdc75b452ba2e10f0e8ecc0b57b827dd5d7aaffbc6821b2a9a242823a76"}, + {file = "psutil-6.1.0-cp27-cp27mu-manylinux2010_x86_64.whl", hash = "sha256:045f00a43c737f960d273a83973b2511430d61f283a44c96bf13a6e829ba8fdc"}, + {file = "psutil-6.1.0-cp27-none-win32.whl", hash = "sha256:9118f27452b70bb1d9ab3198c1f626c2499384935aaf55388211ad982611407e"}, + {file = "psutil-6.1.0-cp27-none-win_amd64.whl", hash = "sha256:a8506f6119cff7015678e2bce904a4da21025cc70ad283a53b099e7620061d85"}, + {file = "psutil-6.1.0-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:6e2dcd475ce8b80522e51d923d10c7871e45f20918e027ab682f94f1c6351688"}, + {file = "psutil-6.1.0-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:0895b8414afafc526712c498bd9de2b063deaac4021a3b3c34566283464aff8e"}, + {file = "psutil-6.1.0-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9dcbfce5d89f1d1f2546a2090f4fcf87c7f669d1d90aacb7d7582addece9fb38"}, + {file = "psutil-6.1.0-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:498c6979f9c6637ebc3a73b3f87f9eb1ec24e1ce53a7c5173b8508981614a90b"}, + {file = "psutil-6.1.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d905186d647b16755a800e7263d43df08b790d709d575105d419f8b6ef65423a"}, + {file = "psutil-6.1.0-cp36-cp36m-win32.whl", hash = "sha256:6d3fbbc8d23fcdcb500d2c9f94e07b1342df8ed71b948a2649b5cb060a7c94ca"}, + {file = "psutil-6.1.0-cp36-cp36m-win_amd64.whl", hash = "sha256:1209036fbd0421afde505a4879dee3b2fd7b1e14fee81c0069807adcbbcca747"}, + {file = "psutil-6.1.0-cp37-abi3-win32.whl", hash = "sha256:1ad45a1f5d0b608253b11508f80940985d1d0c8f6111b5cb637533a0e6ddc13e"}, + {file = "psutil-6.1.0-cp37-abi3-win_amd64.whl", hash = "sha256:a8fb3752b491d246034fa4d279ff076501588ce8cbcdbb62c32fd7a377d996be"}, + {file = "psutil-6.1.0.tar.gz", hash = "sha256:353815f59a7f64cdaca1c0307ee13558a0512f6db064e92fe833784f08539c7a"}, +] + +[package.extras] +dev = ["black", "check-manifest", "coverage", "packaging", "pylint", "pyperf", "pypinfo", "pytest-cov", "requests", "rstcheck", "ruff", "sphinx", "sphinx_rtd_theme", "toml-sort", "twine", "virtualenv", "wheel"] +test = ["pytest", "pytest-xdist", "setuptools"] + [[package]] name = "psycopg2-binary" version = "2.9.10" @@ -2839,6 +4044,31 @@ files = [ {file = "psycopg2_binary-2.9.10-cp39-cp39-win_amd64.whl", hash = "sha256:30e34c4e97964805f715206c7b789d54a78b70f3ff19fbe590104b71c45600e5"}, ] +[[package]] +name = "ptyprocess" +version = "0.7.0" +description = "Run a subprocess in a pseudo terminal" +optional = false +python-versions = "*" +files = [ + {file = "ptyprocess-0.7.0-py2.py3-none-any.whl", hash = "sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35"}, + {file = "ptyprocess-0.7.0.tar.gz", hash = "sha256:5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220"}, +] + +[[package]] +name = "pure-eval" +version = "0.2.3" +description = "Safely evaluate AST nodes without side effects" +optional = false +python-versions = "*" +files = [ + {file = "pure_eval-0.2.3-py3-none-any.whl", hash = "sha256:1db8e35b67b3d218d818ae653e27f06c3aa420901fa7b081ca98cbedc874e0d0"}, + {file = "pure_eval-0.2.3.tar.gz", hash = "sha256:5f4e983f40564c576c7c8635ae88db5956bb2229d7e9237d03b3c0b0190eaf42"}, +] + +[package.extras] +tests = ["pytest"] + [[package]] name = "pyarrow" version = "18.0.0" @@ -2918,6 +4148,17 @@ files = [ [package.dependencies] pyasn1 = ">=0.4.6,<0.7.0" +[[package]] +name = "pycparser" +version = "2.22" +description = "C parser in Python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "pycparser-2.22-py3-none-any.whl", hash = "sha256:c3702b6d3dd8c7abc1afa565d7e63d53a1d0bd86cdc24edd75470f4de499cfcc"}, + {file = "pycparser-2.22.tar.gz", hash = "sha256:491c8be9c040f5390f5bf44a5b07752bd07f56edf992381b05c701439eec10f6"}, +] + [[package]] name = "pycryptodome" version = "3.21.0" @@ -3117,7 +4358,7 @@ windows-terminal = ["colorama (>=0.4.6)"] name = "pyparsing" version = "3.2.0" description = "pyparsing module - Classes and methods to define and execute parsing grammars" -optional = true +optional = false python-versions = ">=3.9" files = [ {file = "pyparsing-3.2.0-py3-none-any.whl", hash = "sha256:93d9577b88da0bbea8cc8334ee8b918ed014968fd2ec383e868fb8afb1ccef84"}, @@ -3177,6 +4418,17 @@ files = [ [package.extras] cli = ["click (>=5.0)"] +[[package]] +name = "python-json-logger" +version = "2.0.7" +description = "A python library adding a json log formatter" +optional = false +python-versions = ">=3.6" +files = [ + {file = "python-json-logger-2.0.7.tar.gz", hash = "sha256:23e7ec02d34237c5aa1e29a070193a4ea87583bb4e7f8fd06d3de8264c4b2e1c"}, + {file = "python_json_logger-2.0.7-py3-none-any.whl", hash = "sha256:f380b826a991ebbe3de4d897aeec42760035ac760345e57b812938dc8b35e2bd"}, +] + [[package]] name = "pytz" version = "2024.2" @@ -3211,6 +4463,21 @@ files = [ {file = "pywin32-306-cp39-cp39-win_amd64.whl", hash = "sha256:39b61c15272833b5c329a2989999dcae836b1eed650252ab1b7bfbe1d59f30f4"}, ] +[[package]] +name = "pywinpty" +version = "2.0.14" +description = "Pseudo terminal support for Windows from Python." +optional = false +python-versions = ">=3.8" +files = [ + {file = "pywinpty-2.0.14-cp310-none-win_amd64.whl", hash = "sha256:0b149c2918c7974f575ba79f5a4aad58bd859a52fa9eb1296cc22aa412aa411f"}, + {file = "pywinpty-2.0.14-cp311-none-win_amd64.whl", hash = "sha256:cf2a43ac7065b3e0dc8510f8c1f13a75fb8fde805efa3b8cff7599a1ef497bc7"}, + {file = "pywinpty-2.0.14-cp312-none-win_amd64.whl", hash = "sha256:55dad362ef3e9408ade68fd173e4f9032b3ce08f68cfe7eacb2c263ea1179737"}, + {file = "pywinpty-2.0.14-cp313-none-win_amd64.whl", hash = "sha256:074fb988a56ec79ca90ed03a896d40707131897cefb8f76f926e3834227f2819"}, + {file = "pywinpty-2.0.14-cp39-none-win_amd64.whl", hash = "sha256:5725fd56f73c0531ec218663bd8c8ff5acc43c78962fab28564871b5fce053fd"}, + {file = "pywinpty-2.0.14.tar.gz", hash = "sha256:18bd9529e4a5daf2d9719aa17788ba6013e594ae94c5a0c27e83df3278b0660e"}, +] + [[package]] name = "pyyaml" version = "6.0.2" @@ -3273,6 +4540,127 @@ files = [ {file = "pyyaml-6.0.2.tar.gz", hash = "sha256:d584d9ec91ad65861cc08d42e834324ef890a082e591037abe114850ff7bbc3e"}, ] +[[package]] +name = "pyzmq" +version = "26.2.0" +description = "Python bindings for 0MQ" +optional = false +python-versions = ">=3.7" +files = [ + {file = "pyzmq-26.2.0-cp310-cp310-macosx_10_15_universal2.whl", hash = "sha256:ddf33d97d2f52d89f6e6e7ae66ee35a4d9ca6f36eda89c24591b0c40205a3629"}, + {file = "pyzmq-26.2.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:dacd995031a01d16eec825bf30802fceb2c3791ef24bcce48fa98ce40918c27b"}, + {file = "pyzmq-26.2.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:89289a5ee32ef6c439086184529ae060c741334b8970a6855ec0b6ad3ff28764"}, + {file = "pyzmq-26.2.0-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5506f06d7dc6ecf1efacb4a013b1f05071bb24b76350832c96449f4a2d95091c"}, + {file = "pyzmq-26.2.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8ea039387c10202ce304af74def5021e9adc6297067f3441d348d2b633e8166a"}, + {file = "pyzmq-26.2.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:a2224fa4a4c2ee872886ed00a571f5e967c85e078e8e8c2530a2fb01b3309b88"}, + {file = "pyzmq-26.2.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:28ad5233e9c3b52d76196c696e362508959741e1a005fb8fa03b51aea156088f"}, + {file = "pyzmq-26.2.0-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:1c17211bc037c7d88e85ed8b7d8f7e52db6dc8eca5590d162717c654550f7282"}, + {file = "pyzmq-26.2.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:b8f86dd868d41bea9a5f873ee13bf5551c94cf6bc51baebc6f85075971fe6eea"}, + {file = "pyzmq-26.2.0-cp310-cp310-win32.whl", hash = "sha256:46a446c212e58456b23af260f3d9fb785054f3e3653dbf7279d8f2b5546b21c2"}, + {file = "pyzmq-26.2.0-cp310-cp310-win_amd64.whl", hash = "sha256:49d34ab71db5a9c292a7644ce74190b1dd5a3475612eefb1f8be1d6961441971"}, + {file = "pyzmq-26.2.0-cp310-cp310-win_arm64.whl", hash = "sha256:bfa832bfa540e5b5c27dcf5de5d82ebc431b82c453a43d141afb1e5d2de025fa"}, + {file = "pyzmq-26.2.0-cp311-cp311-macosx_10_15_universal2.whl", hash = "sha256:8f7e66c7113c684c2b3f1c83cdd3376103ee0ce4c49ff80a648643e57fb22218"}, + {file = "pyzmq-26.2.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:3a495b30fc91db2db25120df5847d9833af237546fd59170701acd816ccc01c4"}, + {file = "pyzmq-26.2.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:77eb0968da535cba0470a5165468b2cac7772cfb569977cff92e240f57e31bef"}, + {file = "pyzmq-26.2.0-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6ace4f71f1900a548f48407fc9be59c6ba9d9aaf658c2eea6cf2779e72f9f317"}, + {file = "pyzmq-26.2.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:92a78853d7280bffb93df0a4a6a2498cba10ee793cc8076ef797ef2f74d107cf"}, + {file = "pyzmq-26.2.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:689c5d781014956a4a6de61d74ba97b23547e431e9e7d64f27d4922ba96e9d6e"}, + {file = "pyzmq-26.2.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:0aca98bc423eb7d153214b2df397c6421ba6373d3397b26c057af3c904452e37"}, + {file = "pyzmq-26.2.0-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:1f3496d76b89d9429a656293744ceca4d2ac2a10ae59b84c1da9b5165f429ad3"}, + {file = "pyzmq-26.2.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:5c2b3bfd4b9689919db068ac6c9911f3fcb231c39f7dd30e3138be94896d18e6"}, + {file = "pyzmq-26.2.0-cp311-cp311-win32.whl", hash = "sha256:eac5174677da084abf378739dbf4ad245661635f1600edd1221f150b165343f4"}, + {file = "pyzmq-26.2.0-cp311-cp311-win_amd64.whl", hash = "sha256:5a509df7d0a83a4b178d0f937ef14286659225ef4e8812e05580776c70e155d5"}, + {file = "pyzmq-26.2.0-cp311-cp311-win_arm64.whl", hash = "sha256:c0e6091b157d48cbe37bd67233318dbb53e1e6327d6fc3bb284afd585d141003"}, + {file = "pyzmq-26.2.0-cp312-cp312-macosx_10_15_universal2.whl", hash = "sha256:ded0fc7d90fe93ae0b18059930086c51e640cdd3baebdc783a695c77f123dcd9"}, + {file = "pyzmq-26.2.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:17bf5a931c7f6618023cdacc7081f3f266aecb68ca692adac015c383a134ca52"}, + {file = "pyzmq-26.2.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:55cf66647e49d4621a7e20c8d13511ef1fe1efbbccf670811864452487007e08"}, + {file = "pyzmq-26.2.0-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4661c88db4a9e0f958c8abc2b97472e23061f0bc737f6f6179d7a27024e1faa5"}, + {file = "pyzmq-26.2.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ea7f69de383cb47522c9c208aec6dd17697db7875a4674c4af3f8cfdac0bdeae"}, + {file = "pyzmq-26.2.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:7f98f6dfa8b8ccaf39163ce872bddacca38f6a67289116c8937a02e30bbe9711"}, + {file = "pyzmq-26.2.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:e3e0210287329272539eea617830a6a28161fbbd8a3271bf4150ae3e58c5d0e6"}, + {file = "pyzmq-26.2.0-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:6b274e0762c33c7471f1a7471d1a2085b1a35eba5cdc48d2ae319f28b6fc4de3"}, + {file = "pyzmq-26.2.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:29c6a4635eef69d68a00321e12a7d2559fe2dfccfa8efae3ffb8e91cd0b36a8b"}, + {file = "pyzmq-26.2.0-cp312-cp312-win32.whl", hash = "sha256:989d842dc06dc59feea09e58c74ca3e1678c812a4a8a2a419046d711031f69c7"}, + {file = "pyzmq-26.2.0-cp312-cp312-win_amd64.whl", hash = "sha256:2a50625acdc7801bc6f74698c5c583a491c61d73c6b7ea4dee3901bb99adb27a"}, + {file = "pyzmq-26.2.0-cp312-cp312-win_arm64.whl", hash = "sha256:4d29ab8592b6ad12ebbf92ac2ed2bedcfd1cec192d8e559e2e099f648570e19b"}, + {file = "pyzmq-26.2.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:9dd8cd1aeb00775f527ec60022004d030ddc51d783d056e3e23e74e623e33726"}, + {file = "pyzmq-26.2.0-cp313-cp313-macosx_10_15_universal2.whl", hash = "sha256:28c812d9757fe8acecc910c9ac9dafd2ce968c00f9e619db09e9f8f54c3a68a3"}, + {file = "pyzmq-26.2.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4d80b1dd99c1942f74ed608ddb38b181b87476c6a966a88a950c7dee118fdf50"}, + {file = "pyzmq-26.2.0-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8c997098cc65e3208eca09303630e84d42718620e83b733d0fd69543a9cab9cb"}, + {file = "pyzmq-26.2.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7ad1bc8d1b7a18497dda9600b12dc193c577beb391beae5cd2349184db40f187"}, + {file = "pyzmq-26.2.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:bea2acdd8ea4275e1278350ced63da0b166421928276c7c8e3f9729d7402a57b"}, + {file = "pyzmq-26.2.0-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:23f4aad749d13698f3f7b64aad34f5fc02d6f20f05999eebc96b89b01262fb18"}, + {file = "pyzmq-26.2.0-cp313-cp313-musllinux_1_1_i686.whl", hash = "sha256:a4f96f0d88accc3dbe4a9025f785ba830f968e21e3e2c6321ccdfc9aef755115"}, + {file = "pyzmq-26.2.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:ced65e5a985398827cc9276b93ef6dfabe0273c23de8c7931339d7e141c2818e"}, + {file = "pyzmq-26.2.0-cp313-cp313-win32.whl", hash = "sha256:31507f7b47cc1ead1f6e86927f8ebb196a0bab043f6345ce070f412a59bf87b5"}, + {file = "pyzmq-26.2.0-cp313-cp313-win_amd64.whl", hash = "sha256:70fc7fcf0410d16ebdda9b26cbd8bf8d803d220a7f3522e060a69a9c87bf7bad"}, + {file = "pyzmq-26.2.0-cp313-cp313-win_arm64.whl", hash = "sha256:c3789bd5768ab5618ebf09cef6ec2b35fed88709b104351748a63045f0ff9797"}, + {file = "pyzmq-26.2.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:034da5fc55d9f8da09015d368f519478a52675e558c989bfcb5cf6d4e16a7d2a"}, + {file = "pyzmq-26.2.0-cp313-cp313t-macosx_10_15_universal2.whl", hash = "sha256:c92d73464b886931308ccc45b2744e5968cbaade0b1d6aeb40d8ab537765f5bc"}, + {file = "pyzmq-26.2.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:794a4562dcb374f7dbbfb3f51d28fb40123b5a2abadee7b4091f93054909add5"}, + {file = "pyzmq-26.2.0-cp313-cp313t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:aee22939bb6075e7afededabad1a56a905da0b3c4e3e0c45e75810ebe3a52672"}, + {file = "pyzmq-26.2.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2ae90ff9dad33a1cfe947d2c40cb9cb5e600d759ac4f0fd22616ce6540f72797"}, + {file = "pyzmq-26.2.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:43a47408ac52647dfabbc66a25b05b6a61700b5165807e3fbd40063fcaf46386"}, + {file = "pyzmq-26.2.0-cp313-cp313t-musllinux_1_1_aarch64.whl", hash = "sha256:25bf2374a2a8433633c65ccb9553350d5e17e60c8eb4de4d92cc6bd60f01d306"}, + {file = "pyzmq-26.2.0-cp313-cp313t-musllinux_1_1_i686.whl", hash = "sha256:007137c9ac9ad5ea21e6ad97d3489af654381324d5d3ba614c323f60dab8fae6"}, + {file = "pyzmq-26.2.0-cp313-cp313t-musllinux_1_1_x86_64.whl", hash = "sha256:470d4a4f6d48fb34e92d768b4e8a5cc3780db0d69107abf1cd7ff734b9766eb0"}, + {file = "pyzmq-26.2.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:3b55a4229ce5da9497dd0452b914556ae58e96a4381bb6f59f1305dfd7e53fc8"}, + {file = "pyzmq-26.2.0-cp37-cp37m-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:9cb3a6460cdea8fe8194a76de8895707e61ded10ad0be97188cc8463ffa7e3a8"}, + {file = "pyzmq-26.2.0-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:8ab5cad923cc95c87bffee098a27856c859bd5d0af31bd346035aa816b081fe1"}, + {file = "pyzmq-26.2.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9ed69074a610fad1c2fda66180e7b2edd4d31c53f2d1872bc2d1211563904cd9"}, + {file = "pyzmq-26.2.0-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:cccba051221b916a4f5e538997c45d7d136a5646442b1231b916d0164067ea27"}, + {file = "pyzmq-26.2.0-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:0eaa83fc4c1e271c24eaf8fb083cbccef8fde77ec8cd45f3c35a9a123e6da097"}, + {file = "pyzmq-26.2.0-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:9edda2df81daa129b25a39b86cb57dfdfe16f7ec15b42b19bfac503360d27a93"}, + {file = "pyzmq-26.2.0-cp37-cp37m-win32.whl", hash = "sha256:ea0eb6af8a17fa272f7b98d7bebfab7836a0d62738e16ba380f440fceca2d951"}, + {file = "pyzmq-26.2.0-cp37-cp37m-win_amd64.whl", hash = "sha256:4ff9dc6bc1664bb9eec25cd17506ef6672d506115095411e237d571e92a58231"}, + {file = "pyzmq-26.2.0-cp38-cp38-macosx_10_15_universal2.whl", hash = "sha256:2eb7735ee73ca1b0d71e0e67c3739c689067f055c764f73aac4cc8ecf958ee3f"}, + {file = "pyzmq-26.2.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:1a534f43bc738181aa7cbbaf48e3eca62c76453a40a746ab95d4b27b1111a7d2"}, + {file = "pyzmq-26.2.0-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:aedd5dd8692635813368e558a05266b995d3d020b23e49581ddd5bbe197a8ab6"}, + {file = "pyzmq-26.2.0-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:8be4700cd8bb02cc454f630dcdf7cfa99de96788b80c51b60fe2fe1dac480289"}, + {file = "pyzmq-26.2.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1fcc03fa4997c447dce58264e93b5aa2d57714fbe0f06c07b7785ae131512732"}, + {file = "pyzmq-26.2.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:402b190912935d3db15b03e8f7485812db350d271b284ded2b80d2e5704be780"}, + {file = "pyzmq-26.2.0-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:8685fa9c25ff00f550c1fec650430c4b71e4e48e8d852f7ddcf2e48308038640"}, + {file = "pyzmq-26.2.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:76589c020680778f06b7e0b193f4b6dd66d470234a16e1df90329f5e14a171cd"}, + {file = "pyzmq-26.2.0-cp38-cp38-win32.whl", hash = "sha256:8423c1877d72c041f2c263b1ec6e34360448decfb323fa8b94e85883043ef988"}, + {file = "pyzmq-26.2.0-cp38-cp38-win_amd64.whl", hash = "sha256:76589f2cd6b77b5bdea4fca5992dc1c23389d68b18ccc26a53680ba2dc80ff2f"}, + {file = "pyzmq-26.2.0-cp39-cp39-macosx_10_15_universal2.whl", hash = "sha256:b1d464cb8d72bfc1a3adc53305a63a8e0cac6bc8c5a07e8ca190ab8d3faa43c2"}, + {file = "pyzmq-26.2.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:4da04c48873a6abdd71811c5e163bd656ee1b957971db7f35140a2d573f6949c"}, + {file = "pyzmq-26.2.0-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:d049df610ac811dcffdc147153b414147428567fbbc8be43bb8885f04db39d98"}, + {file = "pyzmq-26.2.0-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:05590cdbc6b902101d0e65d6a4780af14dc22914cc6ab995d99b85af45362cc9"}, + {file = "pyzmq-26.2.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c811cfcd6a9bf680236c40c6f617187515269ab2912f3d7e8c0174898e2519db"}, + {file = "pyzmq-26.2.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:6835dd60355593de10350394242b5757fbbd88b25287314316f266e24c61d073"}, + {file = "pyzmq-26.2.0-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:bc6bee759a6bddea5db78d7dcd609397449cb2d2d6587f48f3ca613b19410cfc"}, + {file = "pyzmq-26.2.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:c530e1eecd036ecc83c3407f77bb86feb79916d4a33d11394b8234f3bd35b940"}, + {file = "pyzmq-26.2.0-cp39-cp39-win32.whl", hash = "sha256:367b4f689786fca726ef7a6c5ba606958b145b9340a5e4808132cc65759abd44"}, + {file = "pyzmq-26.2.0-cp39-cp39-win_amd64.whl", hash = "sha256:e6fa2e3e683f34aea77de8112f6483803c96a44fd726d7358b9888ae5bb394ec"}, + {file = "pyzmq-26.2.0-cp39-cp39-win_arm64.whl", hash = "sha256:7445be39143a8aa4faec43b076e06944b8f9d0701b669df4af200531b21e40bb"}, + {file = "pyzmq-26.2.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:706e794564bec25819d21a41c31d4df2d48e1cc4b061e8d345d7fb4dd3e94072"}, + {file = "pyzmq-26.2.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8b435f2753621cd36e7c1762156815e21c985c72b19135dac43a7f4f31d28dd1"}, + {file = "pyzmq-26.2.0-pp310-pypy310_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:160c7e0a5eb178011e72892f99f918c04a131f36056d10d9c1afb223fc952c2d"}, + {file = "pyzmq-26.2.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2c4a71d5d6e7b28a47a394c0471b7e77a0661e2d651e7ae91e0cab0a587859ca"}, + {file = "pyzmq-26.2.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:90412f2db8c02a3864cbfc67db0e3dcdbda336acf1c469526d3e869394fe001c"}, + {file = "pyzmq-26.2.0-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:2ea4ad4e6a12e454de05f2949d4beddb52460f3de7c8b9d5c46fbb7d7222e02c"}, + {file = "pyzmq-26.2.0-pp37-pypy37_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:fc4f7a173a5609631bb0c42c23d12c49df3966f89f496a51d3eb0ec81f4519d6"}, + {file = "pyzmq-26.2.0-pp37-pypy37_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:878206a45202247781472a2d99df12a176fef806ca175799e1c6ad263510d57c"}, + {file = "pyzmq-26.2.0-pp37-pypy37_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:17c412bad2eb9468e876f556eb4ee910e62d721d2c7a53c7fa31e643d35352e6"}, + {file = "pyzmq-26.2.0-pp37-pypy37_pp73-win_amd64.whl", hash = "sha256:0d987a3ae5a71c6226b203cfd298720e0086c7fe7c74f35fa8edddfbd6597eed"}, + {file = "pyzmq-26.2.0-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:39887ac397ff35b7b775db7201095fc6310a35fdbae85bac4523f7eb3b840e20"}, + {file = "pyzmq-26.2.0-pp38-pypy38_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:fdb5b3e311d4d4b0eb8b3e8b4d1b0a512713ad7e6a68791d0923d1aec433d919"}, + {file = "pyzmq-26.2.0-pp38-pypy38_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:226af7dcb51fdb0109f0016449b357e182ea0ceb6b47dfb5999d569e5db161d5"}, + {file = "pyzmq-26.2.0-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0bed0e799e6120b9c32756203fb9dfe8ca2fb8467fed830c34c877e25638c3fc"}, + {file = "pyzmq-26.2.0-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:29c7947c594e105cb9e6c466bace8532dc1ca02d498684128b339799f5248277"}, + {file = "pyzmq-26.2.0-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:cdeabcff45d1c219636ee2e54d852262e5c2e085d6cb476d938aee8d921356b3"}, + {file = "pyzmq-26.2.0-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:35cffef589bcdc587d06f9149f8d5e9e8859920a071df5a2671de2213bef592a"}, + {file = "pyzmq-26.2.0-pp39-pypy39_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:18c8dc3b7468d8b4bdf60ce9d7141897da103c7a4690157b32b60acb45e333e6"}, + {file = "pyzmq-26.2.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7133d0a1677aec369d67dd78520d3fa96dd7f3dcec99d66c1762870e5ea1a50a"}, + {file = "pyzmq-26.2.0-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:6a96179a24b14fa6428cbfc08641c779a53f8fcec43644030328f44034c7f1f4"}, + {file = "pyzmq-26.2.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:4f78c88905461a9203eac9faac157a2a0dbba84a0fd09fd29315db27be40af9f"}, + {file = "pyzmq-26.2.0.tar.gz", hash = "sha256:070672c258581c8e4f640b5159297580a9974b026043bd4ab0470be9ed324f1f"}, +] + +[package.dependencies] +cffi = {version = "*", markers = "implementation_name == \"pypy\""} + [[package]] name = "referencing" version = "0.35.1" @@ -3327,6 +4715,31 @@ requests = ">=2.0.0" [package.extras] rsa = ["oauthlib[signedtoken] (>=3.0.0)"] +[[package]] +name = "rfc3339-validator" +version = "0.1.4" +description = "A pure python RFC3339 validator" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" +files = [ + {file = "rfc3339_validator-0.1.4-py2.py3-none-any.whl", hash = "sha256:24f6ec1eda14ef823da9e36ec7113124b39c04d50a4d3d3a3c2859577e7791fa"}, + {file = "rfc3339_validator-0.1.4.tar.gz", hash = "sha256:138a2abdf93304ad60530167e51d2dfb9549521a836871b88d7f4695d0022f6b"}, +] + +[package.dependencies] +six = "*" + +[[package]] +name = "rfc3986-validator" +version = "0.1.1" +description = "Pure python rfc3986 validator" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" +files = [ + {file = "rfc3986_validator-0.1.1-py2.py3-none-any.whl", hash = "sha256:2f235c432ef459970b4306369336b9d5dbdda31b510ca1e327636e01f528bfa9"}, + {file = "rfc3986_validator-0.1.1.tar.gz", hash = "sha256:3d44bde7921b3b9ec3ae4e3adca370438eccebc676456449b145d533b240d055"}, +] + [[package]] name = "rich" version = "13.9.3" @@ -3472,11 +4885,148 @@ files = [ [package.dependencies] pyasn1 = ">=0.1.3" +[[package]] +name = "scikit-learn" +version = "1.5.2" +description = "A set of python modules for machine learning and data mining" +optional = false +python-versions = ">=3.9" +files = [ + {file = "scikit_learn-1.5.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:299406827fb9a4f862626d0fe6c122f5f87f8910b86fe5daa4c32dcd742139b6"}, + {file = "scikit_learn-1.5.2-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:2d4cad1119c77930b235579ad0dc25e65c917e756fe80cab96aa3b9428bd3fb0"}, + {file = "scikit_learn-1.5.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8c412ccc2ad9bf3755915e3908e677b367ebc8d010acbb3f182814524f2e5540"}, + {file = "scikit_learn-1.5.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3a686885a4b3818d9e62904d91b57fa757fc2bed3e465c8b177be652f4dd37c8"}, + {file = "scikit_learn-1.5.2-cp310-cp310-win_amd64.whl", hash = "sha256:c15b1ca23d7c5f33cc2cb0a0d6aaacf893792271cddff0edbd6a40e8319bc113"}, + {file = "scikit_learn-1.5.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:03b6158efa3faaf1feea3faa884c840ebd61b6484167c711548fce208ea09445"}, + {file = "scikit_learn-1.5.2-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:1ff45e26928d3b4eb767a8f14a9a6efbf1cbff7c05d1fb0f95f211a89fd4f5de"}, + {file = "scikit_learn-1.5.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f763897fe92d0e903aa4847b0aec0e68cadfff77e8a0687cabd946c89d17e675"}, + {file = "scikit_learn-1.5.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f8b0ccd4a902836493e026c03256e8b206656f91fbcc4fde28c57a5b752561f1"}, + {file = "scikit_learn-1.5.2-cp311-cp311-win_amd64.whl", hash = "sha256:6c16d84a0d45e4894832b3c4d0bf73050939e21b99b01b6fd59cbb0cf39163b6"}, + {file = "scikit_learn-1.5.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:f932a02c3f4956dfb981391ab24bda1dbd90fe3d628e4b42caef3e041c67707a"}, + {file = "scikit_learn-1.5.2-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:3b923d119d65b7bd555c73be5423bf06c0105678ce7e1f558cb4b40b0a5502b1"}, + {file = "scikit_learn-1.5.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f60021ec1574e56632be2a36b946f8143bf4e5e6af4a06d85281adc22938e0dd"}, + {file = "scikit_learn-1.5.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:394397841449853c2290a32050382edaec3da89e35b3e03d6cc966aebc6a8ae6"}, + {file = "scikit_learn-1.5.2-cp312-cp312-win_amd64.whl", hash = "sha256:57cc1786cfd6bd118220a92ede80270132aa353647684efa385a74244a41e3b1"}, + {file = "scikit_learn-1.5.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e9a702e2de732bbb20d3bad29ebd77fc05a6b427dc49964300340e4c9328b3f5"}, + {file = "scikit_learn-1.5.2-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:b0768ad641981f5d3a198430a1d31c3e044ed2e8a6f22166b4d546a5116d7908"}, + {file = "scikit_learn-1.5.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:178ddd0a5cb0044464fc1bfc4cca5b1833bfc7bb022d70b05db8530da4bb3dd3"}, + {file = "scikit_learn-1.5.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f7284ade780084d94505632241bf78c44ab3b6f1e8ccab3d2af58e0e950f9c12"}, + {file = "scikit_learn-1.5.2-cp313-cp313-win_amd64.whl", hash = "sha256:b7b0f9a0b1040830d38c39b91b3a44e1b643f4b36e36567b80b7c6bd2202a27f"}, + {file = "scikit_learn-1.5.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:757c7d514ddb00ae249832fe87100d9c73c6ea91423802872d9e74970a0e40b9"}, + {file = "scikit_learn-1.5.2-cp39-cp39-macosx_12_0_arm64.whl", hash = "sha256:52788f48b5d8bca5c0736c175fa6bdaab2ef00a8f536cda698db61bd89c551c1"}, + {file = "scikit_learn-1.5.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:643964678f4b5fbdc95cbf8aec638acc7aa70f5f79ee2cdad1eec3df4ba6ead8"}, + {file = "scikit_learn-1.5.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ca64b3089a6d9b9363cd3546f8978229dcbb737aceb2c12144ee3f70f95684b7"}, + {file = "scikit_learn-1.5.2-cp39-cp39-win_amd64.whl", hash = "sha256:3bed4909ba187aca80580fe2ef370d9180dcf18e621a27c4cf2ef10d279a7efe"}, + {file = "scikit_learn-1.5.2.tar.gz", hash = "sha256:b4237ed7b3fdd0a4882792e68ef2545d5baa50aca3bb45aa7df468138ad8f94d"}, +] + +[package.dependencies] +joblib = ">=1.2.0" +numpy = ">=1.19.5" +scipy = ">=1.6.0" +threadpoolctl = ">=3.1.0" + +[package.extras] +benchmark = ["matplotlib (>=3.3.4)", "memory_profiler (>=0.57.0)", "pandas (>=1.1.5)"] +build = ["cython (>=3.0.10)", "meson-python (>=0.16.0)", "numpy (>=1.19.5)", "scipy (>=1.6.0)"] +docs = ["Pillow (>=7.1.2)", "matplotlib (>=3.3.4)", "memory_profiler (>=0.57.0)", "numpydoc (>=1.2.0)", "pandas (>=1.1.5)", "plotly (>=5.14.0)", "polars (>=0.20.30)", "pooch (>=1.6.0)", "pydata-sphinx-theme (>=0.15.3)", "scikit-image (>=0.17.2)", "seaborn (>=0.9.0)", "sphinx (>=7.3.7)", "sphinx-copybutton (>=0.5.2)", "sphinx-design (>=0.5.0)", "sphinx-design (>=0.6.0)", "sphinx-gallery (>=0.16.0)", "sphinx-prompt (>=1.4.0)", "sphinx-remove-toctrees (>=1.0.0.post1)", "sphinxcontrib-sass (>=0.3.4)", "sphinxext-opengraph (>=0.9.1)"] +examples = ["matplotlib (>=3.3.4)", "pandas (>=1.1.5)", "plotly (>=5.14.0)", "pooch (>=1.6.0)", "scikit-image (>=0.17.2)", "seaborn (>=0.9.0)"] +install = ["joblib (>=1.2.0)", "numpy (>=1.19.5)", "scipy (>=1.6.0)", "threadpoolctl (>=3.1.0)"] +maintenance = ["conda-lock (==2.5.6)"] +tests = ["black (>=24.3.0)", "matplotlib (>=3.3.4)", "mypy (>=1.9)", "numpydoc (>=1.2.0)", "pandas (>=1.1.5)", "polars (>=0.20.30)", "pooch (>=1.6.0)", "pyamg (>=4.0.0)", "pyarrow (>=12.0.0)", "pytest (>=7.1.2)", "pytest-cov (>=2.9.0)", "ruff (>=0.2.1)", "scikit-image (>=0.17.2)"] + +[[package]] +name = "scipy" +version = "1.14.1" +description = "Fundamental algorithms for scientific computing in Python" +optional = false +python-versions = ">=3.10" +files = [ + {file = "scipy-1.14.1-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:b28d2ca4add7ac16ae8bb6632a3c86e4b9e4d52d3e34267f6e1b0c1f8d87e389"}, + {file = "scipy-1.14.1-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:d0d2821003174de06b69e58cef2316a6622b60ee613121199cb2852a873f8cf3"}, + {file = "scipy-1.14.1-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:8bddf15838ba768bb5f5083c1ea012d64c9a444e16192762bd858f1e126196d0"}, + {file = "scipy-1.14.1-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:97c5dddd5932bd2a1a31c927ba5e1463a53b87ca96b5c9bdf5dfd6096e27efc3"}, + {file = "scipy-1.14.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2ff0a7e01e422c15739ecd64432743cf7aae2b03f3084288f399affcefe5222d"}, + {file = "scipy-1.14.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8e32dced201274bf96899e6491d9ba3e9a5f6b336708656466ad0522d8528f69"}, + {file = "scipy-1.14.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:8426251ad1e4ad903a4514712d2fa8fdd5382c978010d1c6f5f37ef286a713ad"}, + {file = "scipy-1.14.1-cp310-cp310-win_amd64.whl", hash = "sha256:a49f6ed96f83966f576b33a44257d869756df6cf1ef4934f59dd58b25e0327e5"}, + {file = "scipy-1.14.1-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:2da0469a4ef0ecd3693761acbdc20f2fdeafb69e6819cc081308cc978153c675"}, + {file = "scipy-1.14.1-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:c0ee987efa6737242745f347835da2cc5bb9f1b42996a4d97d5c7ff7928cb6f2"}, + {file = "scipy-1.14.1-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:3a1b111fac6baec1c1d92f27e76511c9e7218f1695d61b59e05e0fe04dc59617"}, + {file = "scipy-1.14.1-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:8475230e55549ab3f207bff11ebfc91c805dc3463ef62eda3ccf593254524ce8"}, + {file = "scipy-1.14.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:278266012eb69f4a720827bdd2dc54b2271c97d84255b2faaa8f161a158c3b37"}, + {file = "scipy-1.14.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fef8c87f8abfb884dac04e97824b61299880c43f4ce675dd2cbeadd3c9b466d2"}, + {file = "scipy-1.14.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:b05d43735bb2f07d689f56f7b474788a13ed8adc484a85aa65c0fd931cf9ccd2"}, + {file = "scipy-1.14.1-cp311-cp311-win_amd64.whl", hash = "sha256:716e389b694c4bb564b4fc0c51bc84d381735e0d39d3f26ec1af2556ec6aad94"}, + {file = "scipy-1.14.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:631f07b3734d34aced009aaf6fedfd0eb3498a97e581c3b1e5f14a04164a456d"}, + {file = "scipy-1.14.1-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:af29a935803cc707ab2ed7791c44288a682f9c8107bc00f0eccc4f92c08d6e07"}, + {file = "scipy-1.14.1-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:2843f2d527d9eebec9a43e6b406fb7266f3af25a751aa91d62ff416f54170bc5"}, + {file = "scipy-1.14.1-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:eb58ca0abd96911932f688528977858681a59d61a7ce908ffd355957f7025cfc"}, + {file = "scipy-1.14.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:30ac8812c1d2aab7131a79ba62933a2a76f582d5dbbc695192453dae67ad6310"}, + {file = "scipy-1.14.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8f9ea80f2e65bdaa0b7627fb00cbeb2daf163caa015e59b7516395fe3bd1e066"}, + {file = "scipy-1.14.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:edaf02b82cd7639db00dbff629995ef185c8df4c3ffa71a5562a595765a06ce1"}, + {file = "scipy-1.14.1-cp312-cp312-win_amd64.whl", hash = "sha256:2ff38e22128e6c03ff73b6bb0f85f897d2362f8c052e3b8ad00532198fbdae3f"}, + {file = "scipy-1.14.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:1729560c906963fc8389f6aac023739ff3983e727b1a4d87696b7bf108316a79"}, + {file = "scipy-1.14.1-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:4079b90df244709e675cdc8b93bfd8a395d59af40b72e339c2287c91860deb8e"}, + {file = "scipy-1.14.1-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:e0cf28db0f24a38b2a0ca33a85a54852586e43cf6fd876365c86e0657cfe7d73"}, + {file = "scipy-1.14.1-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:0c2f95de3b04e26f5f3ad5bb05e74ba7f68b837133a4492414b3afd79dfe540e"}, + {file = "scipy-1.14.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b99722ea48b7ea25e8e015e8341ae74624f72e5f21fc2abd45f3a93266de4c5d"}, + {file = "scipy-1.14.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5149e3fd2d686e42144a093b206aef01932a0059c2a33ddfa67f5f035bdfe13e"}, + {file = "scipy-1.14.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e4f5a7c49323533f9103d4dacf4e4f07078f360743dec7f7596949149efeec06"}, + {file = "scipy-1.14.1-cp313-cp313-win_amd64.whl", hash = "sha256:baff393942b550823bfce952bb62270ee17504d02a1801d7fd0719534dfb9c84"}, + {file = "scipy-1.14.1.tar.gz", hash = "sha256:5a275584e726026a5699459aa72f828a610821006228e841b94275c4a7c08417"}, +] + +[package.dependencies] +numpy = ">=1.23.5,<2.3" + +[package.extras] +dev = ["cython-lint (>=0.12.2)", "doit (>=0.36.0)", "mypy (==1.10.0)", "pycodestyle", "pydevtool", "rich-click", "ruff (>=0.0.292)", "types-psutil", "typing_extensions"] +doc = ["jupyterlite-pyodide-kernel", "jupyterlite-sphinx (>=0.13.1)", "jupytext", "matplotlib (>=3.5)", "myst-nb", "numpydoc", "pooch", "pydata-sphinx-theme (>=0.15.2)", "sphinx (>=5.0.0,<=7.3.7)", "sphinx-design (>=0.4.0)"] +test = ["Cython", "array-api-strict (>=2.0)", "asv", "gmpy2", "hypothesis (>=6.30)", "meson", "mpmath", "ninja", "pooch", "pytest", "pytest-cov", "pytest-timeout", "pytest-xdist", "scikit-umfpack", "threadpoolctl"] + +[[package]] +name = "seaborn" +version = "0.13.2" +description = "Statistical data visualization" +optional = false +python-versions = ">=3.8" +files = [ + {file = "seaborn-0.13.2-py3-none-any.whl", hash = "sha256:636f8336facf092165e27924f223d3c62ca560b1f2bb5dff7ab7fad265361987"}, + {file = "seaborn-0.13.2.tar.gz", hash = "sha256:93e60a40988f4d65e9f4885df477e2fdaff6b73a9ded434c1ab356dd57eefff7"}, +] + +[package.dependencies] +matplotlib = ">=3.4,<3.6.1 || >3.6.1" +numpy = ">=1.20,<1.24.0 || >1.24.0" +pandas = ">=1.2" + +[package.extras] +dev = ["flake8", "flit", "mypy", "pandas-stubs", "pre-commit", "pytest", "pytest-cov", "pytest-xdist"] +docs = ["ipykernel", "nbconvert", "numpydoc", "pydata_sphinx_theme (==0.10.0rc2)", "pyyaml", "sphinx (<6.0.0)", "sphinx-copybutton", "sphinx-design", "sphinx-issues"] +stats = ["scipy (>=1.7)", "statsmodels (>=0.12)"] + +[[package]] +name = "send2trash" +version = "1.8.3" +description = "Send file to trash natively under Mac OS X, Windows and Linux" +optional = false +python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7" +files = [ + {file = "Send2Trash-1.8.3-py3-none-any.whl", hash = "sha256:0c31227e0bd08961c7665474a3d1ef7193929fedda4233843689baa056be46c9"}, + {file = "Send2Trash-1.8.3.tar.gz", hash = "sha256:b18e7a3966d99871aefeb00cfbcfdced55ce4871194810fc71f4aa484b953abf"}, +] + +[package.extras] +nativelib = ["pyobjc-framework-Cocoa", "pywin32"] +objc = ["pyobjc-framework-Cocoa"] +win32 = ["pywin32"] + [[package]] name = "setuptools" version = "75.2.0" description = "Easily download, build, install, upgrade, and uninstall Python packages" -optional = true +optional = false python-versions = ">=3.8" files = [ {file = "setuptools-75.2.0-py3-none-any.whl", hash = "sha256:a7fcb66f68b4d9e8e66b42f9876150a3371558f98fa32222ffaa5bced76406f8"}, @@ -3496,7 +5046,7 @@ type = ["importlib-metadata (>=7.0.2)", "jaraco.develop (>=7.21)", "mypy (==1.11 name = "setuptools-scm" version = "8.1.0" description = "the blessed package to manage your versions by scm tags" -optional = true +optional = false python-versions = ">=3.8" files = [ {file = "setuptools_scm-8.1.0-py3-none-any.whl", hash = "sha256:897a3226a6fd4a6eb2f068745e49733261a21f70b1bb28fce0339feb978d9af3"}, @@ -3535,17 +5085,142 @@ files = [ {file = "smmap-5.0.1.tar.gz", hash = "sha256:dceeb6c0028fdb6734471eb07c0cd2aae706ccaecab45965ee83f11c8d3b1f62"}, ] +[[package]] +name = "sniffio" +version = "1.3.1" +description = "Sniff out which async library your code is running under" +optional = false +python-versions = ">=3.7" +files = [ + {file = "sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2"}, + {file = "sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc"}, +] + [[package]] name = "soupsieve" version = "2.6" description = "A modern CSS selector implementation for Beautiful Soup." -optional = true +optional = false python-versions = ">=3.8" files = [ {file = "soupsieve-2.6-py3-none-any.whl", hash = "sha256:e72c4ff06e4fb6e4b5a9f0f55fe6e81514581fca1515028625d0f299c602ccc9"}, {file = "soupsieve-2.6.tar.gz", hash = "sha256:e2e68417777af359ec65daac1057404a3c8a5455bb8abc36f1a9866ab1a51abb"}, ] +[[package]] +name = "sqlalchemy" +version = "2.0.36" +description = "Database Abstraction Library" +optional = false +python-versions = ">=3.7" +files = [ + {file = "SQLAlchemy-2.0.36-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:59b8f3adb3971929a3e660337f5dacc5942c2cdb760afcabb2614ffbda9f9f72"}, + {file = "SQLAlchemy-2.0.36-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:37350015056a553e442ff672c2d20e6f4b6d0b2495691fa239d8aa18bb3bc908"}, + {file = "SQLAlchemy-2.0.36-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8318f4776c85abc3f40ab185e388bee7a6ea99e7fa3a30686580b209eaa35c08"}, + {file = "SQLAlchemy-2.0.36-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c245b1fbade9c35e5bd3b64270ab49ce990369018289ecfde3f9c318411aaa07"}, + {file = "SQLAlchemy-2.0.36-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:69f93723edbca7342624d09f6704e7126b152eaed3cdbb634cb657a54332a3c5"}, + {file = "SQLAlchemy-2.0.36-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:f9511d8dd4a6e9271d07d150fb2f81874a3c8c95e11ff9af3a2dfc35fe42ee44"}, + {file = "SQLAlchemy-2.0.36-cp310-cp310-win32.whl", hash = "sha256:c3f3631693003d8e585d4200730616b78fafd5a01ef8b698f6967da5c605b3fa"}, + {file = "SQLAlchemy-2.0.36-cp310-cp310-win_amd64.whl", hash = "sha256:a86bfab2ef46d63300c0f06936bd6e6c0105faa11d509083ba8f2f9d237fb5b5"}, + {file = "SQLAlchemy-2.0.36-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:fd3a55deef00f689ce931d4d1b23fa9f04c880a48ee97af488fd215cf24e2a6c"}, + {file = "SQLAlchemy-2.0.36-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4f5e9cd989b45b73bd359f693b935364f7e1f79486e29015813c338450aa5a71"}, + {file = "SQLAlchemy-2.0.36-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d0ddd9db6e59c44875211bc4c7953a9f6638b937b0a88ae6d09eb46cced54eff"}, + {file = "SQLAlchemy-2.0.36-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2519f3a5d0517fc159afab1015e54bb81b4406c278749779be57a569d8d1bb0d"}, + {file = "SQLAlchemy-2.0.36-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:59b1ee96617135f6e1d6f275bbe988f419c5178016f3d41d3c0abb0c819f75bb"}, + {file = "SQLAlchemy-2.0.36-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:39769a115f730d683b0eb7b694db9789267bcd027326cccc3125e862eb03bfd8"}, + {file = "SQLAlchemy-2.0.36-cp311-cp311-win32.whl", hash = "sha256:66bffbad8d6271bb1cc2f9a4ea4f86f80fe5e2e3e501a5ae2a3dc6a76e604e6f"}, + {file = "SQLAlchemy-2.0.36-cp311-cp311-win_amd64.whl", hash = "sha256:23623166bfefe1487d81b698c423f8678e80df8b54614c2bf4b4cfcd7c711959"}, + {file = "SQLAlchemy-2.0.36-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:f7b64e6ec3f02c35647be6b4851008b26cff592a95ecb13b6788a54ef80bbdd4"}, + {file = "SQLAlchemy-2.0.36-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:46331b00096a6db1fdc052d55b101dbbfc99155a548e20a0e4a8e5e4d1362855"}, + {file = "SQLAlchemy-2.0.36-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fdf3386a801ea5aba17c6410dd1dc8d39cf454ca2565541b5ac42a84e1e28f53"}, + {file = "SQLAlchemy-2.0.36-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ac9dfa18ff2a67b09b372d5db8743c27966abf0e5344c555d86cc7199f7ad83a"}, + {file = "SQLAlchemy-2.0.36-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:90812a8933df713fdf748b355527e3af257a11e415b613dd794512461eb8a686"}, + {file = "SQLAlchemy-2.0.36-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1bc330d9d29c7f06f003ab10e1eaced295e87940405afe1b110f2eb93a233588"}, + {file = "SQLAlchemy-2.0.36-cp312-cp312-win32.whl", hash = "sha256:79d2e78abc26d871875b419e1fd3c0bca31a1cb0043277d0d850014599626c2e"}, + {file = "SQLAlchemy-2.0.36-cp312-cp312-win_amd64.whl", hash = "sha256:b544ad1935a8541d177cb402948b94e871067656b3a0b9e91dbec136b06a2ff5"}, + {file = "SQLAlchemy-2.0.36-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:b5cc79df7f4bc3d11e4b542596c03826063092611e481fcf1c9dfee3c94355ef"}, + {file = "SQLAlchemy-2.0.36-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:3c01117dd36800f2ecaa238c65365b7b16497adc1522bf84906e5710ee9ba0e8"}, + {file = "SQLAlchemy-2.0.36-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9bc633f4ee4b4c46e7adcb3a9b5ec083bf1d9a97c1d3854b92749d935de40b9b"}, + {file = "SQLAlchemy-2.0.36-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9e46ed38affdfc95d2c958de328d037d87801cfcbea6d421000859e9789e61c2"}, + {file = "SQLAlchemy-2.0.36-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:b2985c0b06e989c043f1dc09d4fe89e1616aadd35392aea2844f0458a989eacf"}, + {file = "SQLAlchemy-2.0.36-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4a121d62ebe7d26fec9155f83f8be5189ef1405f5973ea4874a26fab9f1e262c"}, + {file = "SQLAlchemy-2.0.36-cp313-cp313-win32.whl", hash = "sha256:0572f4bd6f94752167adfd7c1bed84f4b240ee6203a95e05d1e208d488d0d436"}, + {file = "SQLAlchemy-2.0.36-cp313-cp313-win_amd64.whl", hash = "sha256:8c78ac40bde930c60e0f78b3cd184c580f89456dd87fc08f9e3ee3ce8765ce88"}, + {file = "SQLAlchemy-2.0.36-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:be9812b766cad94a25bc63bec11f88c4ad3629a0cec1cd5d4ba48dc23860486b"}, + {file = "SQLAlchemy-2.0.36-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:50aae840ebbd6cdd41af1c14590e5741665e5272d2fee999306673a1bb1fdb4d"}, + {file = "SQLAlchemy-2.0.36-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4557e1f11c5f653ebfdd924f3f9d5ebfc718283b0b9beebaa5dd6b77ec290971"}, + {file = "SQLAlchemy-2.0.36-cp37-cp37m-musllinux_1_2_aarch64.whl", hash = "sha256:07b441f7d03b9a66299ce7ccf3ef2900abc81c0db434f42a5694a37bd73870f2"}, + {file = "SQLAlchemy-2.0.36-cp37-cp37m-musllinux_1_2_x86_64.whl", hash = "sha256:28120ef39c92c2dd60f2721af9328479516844c6b550b077ca450c7d7dc68575"}, + {file = "SQLAlchemy-2.0.36-cp37-cp37m-win32.whl", hash = "sha256:b81ee3d84803fd42d0b154cb6892ae57ea6b7c55d8359a02379965706c7efe6c"}, + {file = "SQLAlchemy-2.0.36-cp37-cp37m-win_amd64.whl", hash = "sha256:f942a799516184c855e1a32fbc7b29d7e571b52612647866d4ec1c3242578fcb"}, + {file = "SQLAlchemy-2.0.36-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:3d6718667da04294d7df1670d70eeddd414f313738d20a6f1d1f379e3139a545"}, + {file = "SQLAlchemy-2.0.36-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:72c28b84b174ce8af8504ca28ae9347d317f9dba3999e5981a3cd441f3712e24"}, + {file = "SQLAlchemy-2.0.36-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b11d0cfdd2b095e7b0686cf5fabeb9c67fae5b06d265d8180715b8cfa86522e3"}, + {file = "SQLAlchemy-2.0.36-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e32092c47011d113dc01ab3e1d3ce9f006a47223b18422c5c0d150af13a00687"}, + {file = "SQLAlchemy-2.0.36-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:6a440293d802d3011028e14e4226da1434b373cbaf4a4bbb63f845761a708346"}, + {file = "SQLAlchemy-2.0.36-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:c54a1e53a0c308a8e8a7dffb59097bff7facda27c70c286f005327f21b2bd6b1"}, + {file = "SQLAlchemy-2.0.36-cp38-cp38-win32.whl", hash = "sha256:1e0d612a17581b6616ff03c8e3d5eff7452f34655c901f75d62bd86449d9750e"}, + {file = "SQLAlchemy-2.0.36-cp38-cp38-win_amd64.whl", hash = "sha256:8958b10490125124463095bbdadda5aa22ec799f91958e410438ad6c97a7b793"}, + {file = "SQLAlchemy-2.0.36-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:dc022184d3e5cacc9579e41805a681187650e170eb2fd70e28b86192a479dcaa"}, + {file = "SQLAlchemy-2.0.36-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:b817d41d692bf286abc181f8af476c4fbef3fd05e798777492618378448ee689"}, + {file = "SQLAlchemy-2.0.36-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a4e46a888b54be23d03a89be510f24a7652fe6ff660787b96cd0e57a4ebcb46d"}, + {file = "SQLAlchemy-2.0.36-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c4ae3005ed83f5967f961fd091f2f8c5329161f69ce8480aa8168b2d7fe37f06"}, + {file = "SQLAlchemy-2.0.36-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:03e08af7a5f9386a43919eda9de33ffda16b44eb11f3b313e6822243770e9763"}, + {file = "SQLAlchemy-2.0.36-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:3dbb986bad3ed5ceaf090200eba750b5245150bd97d3e67343a3cfed06feecf7"}, + {file = "SQLAlchemy-2.0.36-cp39-cp39-win32.whl", hash = "sha256:9fe53b404f24789b5ea9003fc25b9a3988feddebd7e7b369c8fac27ad6f52f28"}, + {file = "SQLAlchemy-2.0.36-cp39-cp39-win_amd64.whl", hash = "sha256:af148a33ff0349f53512a049c6406923e4e02bf2f26c5fb285f143faf4f0e46a"}, + {file = "SQLAlchemy-2.0.36-py3-none-any.whl", hash = "sha256:fddbe92b4760c6f5d48162aef14824add991aeda8ddadb3c31d56eb15ca69f8e"}, + {file = "sqlalchemy-2.0.36.tar.gz", hash = "sha256:7f2767680b6d2398aea7082e45a774b2b0767b5c8d8ffb9c8b683088ea9b29c5"}, +] + +[package.dependencies] +greenlet = {version = "!=0.4.17", markers = "python_version < \"3.13\" and (platform_machine == \"aarch64\" or platform_machine == \"ppc64le\" or platform_machine == \"x86_64\" or platform_machine == \"amd64\" or platform_machine == \"AMD64\" or platform_machine == \"win32\" or platform_machine == \"WIN32\")"} +typing-extensions = ">=4.6.0" + +[package.extras] +aiomysql = ["aiomysql (>=0.2.0)", "greenlet (!=0.4.17)"] +aioodbc = ["aioodbc", "greenlet (!=0.4.17)"] +aiosqlite = ["aiosqlite", "greenlet (!=0.4.17)", "typing_extensions (!=3.10.0.1)"] +asyncio = ["greenlet (!=0.4.17)"] +asyncmy = ["asyncmy (>=0.2.3,!=0.2.4,!=0.2.6)", "greenlet (!=0.4.17)"] +mariadb-connector = ["mariadb (>=1.0.1,!=1.1.2,!=1.1.5,!=1.1.10)"] +mssql = ["pyodbc"] +mssql-pymssql = ["pymssql"] +mssql-pyodbc = ["pyodbc"] +mypy = ["mypy (>=0.910)"] +mysql = ["mysqlclient (>=1.4.0)"] +mysql-connector = ["mysql-connector-python"] +oracle = ["cx_oracle (>=8)"] +oracle-oracledb = ["oracledb (>=1.0.1)"] +postgresql = ["psycopg2 (>=2.7)"] +postgresql-asyncpg = ["asyncpg", "greenlet (!=0.4.17)"] +postgresql-pg8000 = ["pg8000 (>=1.29.1)"] +postgresql-psycopg = ["psycopg (>=3.0.7)"] +postgresql-psycopg2binary = ["psycopg2-binary"] +postgresql-psycopg2cffi = ["psycopg2cffi"] +postgresql-psycopgbinary = ["psycopg[binary] (>=3.0.7)"] +pymysql = ["pymysql"] +sqlcipher = ["sqlcipher3_binary"] + +[[package]] +name = "stack-data" +version = "0.6.3" +description = "Extract data from python stack frames and tracebacks for informative displays" +optional = false +python-versions = "*" +files = [ + {file = "stack_data-0.6.3-py3-none-any.whl", hash = "sha256:d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695"}, + {file = "stack_data-0.6.3.tar.gz", hash = "sha256:836a778de4fec4dcd1dcd89ed8abff8a221f58308462e1c4aa2a3cf30148f0b9"}, +] + +[package.dependencies] +asttokens = ">=2.1.0" +executing = ">=1.2.0" +pure-eval = "*" + +[package.extras] +tests = ["cython", "littleutils", "pygments", "pytest", "typeguard"] + [[package]] name = "starknet-py" version = "0.22.0" @@ -3635,6 +5310,56 @@ files = [ doc = ["reno", "sphinx"] test = ["pytest", "tornado (>=4.5)", "typeguard"] +[[package]] +name = "terminado" +version = "0.18.1" +description = "Tornado websocket backend for the Xterm.js Javascript terminal emulator library." +optional = false +python-versions = ">=3.8" +files = [ + {file = "terminado-0.18.1-py3-none-any.whl", hash = "sha256:a4468e1b37bb318f8a86514f65814e1afc977cf29b3992a4500d9dd305dcceb0"}, + {file = "terminado-0.18.1.tar.gz", hash = "sha256:de09f2c4b85de4765f7714688fff57d3e75bad1f909b589fde880460c753fd2e"}, +] + +[package.dependencies] +ptyprocess = {version = "*", markers = "os_name != \"nt\""} +pywinpty = {version = ">=1.1.0", markers = "os_name == \"nt\""} +tornado = ">=6.1.0" + +[package.extras] +docs = ["myst-parser", "pydata-sphinx-theme", "sphinx"] +test = ["pre-commit", "pytest (>=7.0)", "pytest-timeout"] +typing = ["mypy (>=1.6,<2.0)", "traitlets (>=5.11.1)"] + +[[package]] +name = "threadpoolctl" +version = "3.5.0" +description = "threadpoolctl" +optional = false +python-versions = ">=3.8" +files = [ + {file = "threadpoolctl-3.5.0-py3-none-any.whl", hash = "sha256:56c1e26c150397e58c4926da8eeee87533b1e32bef131bd4bf6a2f45f3185467"}, + {file = "threadpoolctl-3.5.0.tar.gz", hash = "sha256:082433502dd922bf738de0d8bcc4fdcbf0979ff44c42bd40f5af8a282f6fa107"}, +] + +[[package]] +name = "tinycss2" +version = "1.4.0" +description = "A tiny CSS parser" +optional = false +python-versions = ">=3.8" +files = [ + {file = "tinycss2-1.4.0-py3-none-any.whl", hash = "sha256:3a49cf47b7675da0b15d0c6e1df8df4ebd96e9394bb905a5775adb0d884c5289"}, + {file = "tinycss2-1.4.0.tar.gz", hash = "sha256:10c0972f6fc0fbee87c3edb76549357415e94548c1ae10ebccdea16fb404a9b7"}, +] + +[package.dependencies] +webencodings = ">=0.4" + +[package.extras] +doc = ["sphinx", "sphinx_rtd_theme"] +test = ["pytest", "ruff"] + [[package]] name = "toml" version = "0.10.2" @@ -3697,6 +5422,32 @@ notebook = ["ipywidgets (>=6)"] slack = ["slack-sdk"] telegram = ["requests"] +[[package]] +name = "traitlets" +version = "5.14.3" +description = "Traitlets Python configuration system" +optional = false +python-versions = ">=3.8" +files = [ + {file = "traitlets-5.14.3-py3-none-any.whl", hash = "sha256:b74e89e397b1ed28cc831db7aea759ba6640cb3de13090ca145426688ff1ac4f"}, + {file = "traitlets-5.14.3.tar.gz", hash = "sha256:9ed0579d3502c94b4b3732ac120375cda96f923114522847de4b3bb98b96b6b7"}, +] + +[package.extras] +docs = ["myst-parser", "pydata-sphinx-theme", "sphinx"] +test = ["argcomplete (>=3.0.3)", "mypy (>=1.7.0)", "pre-commit", "pytest (>=7.0,<8.2)", "pytest-mock", "pytest-mypy-testing"] + +[[package]] +name = "types-python-dateutil" +version = "2.9.0.20241003" +description = "Typing stubs for python-dateutil" +optional = false +python-versions = ">=3.8" +files = [ + {file = "types-python-dateutil-2.9.0.20241003.tar.gz", hash = "sha256:58cb85449b2a56d6684e41aeefb4c4280631246a0da1a719bdbe6f3fb0317446"}, + {file = "types_python_dateutil-2.9.0.20241003-py3-none-any.whl", hash = "sha256:250e1d8e80e7bbc3a6c99b907762711d1a1cdd00e978ad39cb5940f6f0a87f3d"}, +] + [[package]] name = "typing-extensions" version = "4.12.2" @@ -3734,6 +5485,20 @@ files = [ {file = "tzdata-2024.2.tar.gz", hash = "sha256:7d85cc416e9382e69095b7bdf4afd9e3880418a2413feec7069d533d6b4e31cc"}, ] +[[package]] +name = "uri-template" +version = "1.3.0" +description = "RFC 6570 URI Template Processor" +optional = false +python-versions = ">=3.7" +files = [ + {file = "uri-template-1.3.0.tar.gz", hash = "sha256:0e00f8eb65e18c7de20d595a14336e9f337ead580c70934141624b6d1ffdacc7"}, + {file = "uri_template-1.3.0-py3-none-any.whl", hash = "sha256:a44a133ea12d44a0c0f06d7d42a52d71282e77e2f937d8abd5655b8d56fc1363"}, +] + +[package.extras] +dev = ["flake8", "flake8-annotations", "flake8-bandit", "flake8-bugbear", "flake8-commas", "flake8-comprehensions", "flake8-continuation", "flake8-datetimez", "flake8-docstrings", "flake8-import-order", "flake8-literal", "flake8-modern-annotations", "flake8-noqa", "flake8-pyproject", "flake8-requirements", "flake8-typechecking-import", "flake8-use-fstring", "mypy", "pep8-naming", "types-PyYAML"] + [[package]] name = "urllib3" version = "2.2.3" @@ -3813,17 +5578,70 @@ files = [ [package.extras] watchmedo = ["PyYAML (>=3.10)"] +[[package]] +name = "wcwidth" +version = "0.2.13" +description = "Measures the displayed width of unicode strings in a terminal" +optional = false +python-versions = "*" +files = [ + {file = "wcwidth-0.2.13-py2.py3-none-any.whl", hash = "sha256:3da69048e4540d84af32131829ff948f1e022c1c6bdb8d6102117aac784f6859"}, + {file = "wcwidth-0.2.13.tar.gz", hash = "sha256:72ea0c06399eb286d978fdedb6923a9eb47e1c486ce63e9b4e64fc18303972b5"}, +] + +[[package]] +name = "webcolors" +version = "24.8.0" +description = "A library for working with the color formats defined by HTML and CSS." +optional = false +python-versions = ">=3.8" +files = [ + {file = "webcolors-24.8.0-py3-none-any.whl", hash = "sha256:fc4c3b59358ada164552084a8ebee637c221e4059267d0f8325b3b560f6c7f0a"}, + {file = "webcolors-24.8.0.tar.gz", hash = "sha256:08b07af286a01bcd30d583a7acadf629583d1f79bfef27dd2c2c5c263817277d"}, +] + +[package.extras] +docs = ["furo", "sphinx", "sphinx-copybutton", "sphinx-inline-tabs", "sphinx-notfound-page", "sphinxext-opengraph"] +tests = ["coverage[toml]"] + [[package]] name = "webencodings" version = "0.5.1" description = "Character encoding aliases for legacy web content" -optional = true +optional = false python-versions = "*" files = [ {file = "webencodings-0.5.1-py2.py3-none-any.whl", hash = "sha256:a0af1213f3c2226497a97e2b3aa01a7e4bee4f403f95be16fc9acd2947514a78"}, {file = "webencodings-0.5.1.tar.gz", hash = "sha256:b36a1c245f2d304965eb4e0a82848379241dc04b865afcc4aab16748587e1923"}, ] +[[package]] +name = "websocket-client" +version = "1.8.0" +description = "WebSocket client for Python with low level API options" +optional = false +python-versions = ">=3.8" +files = [ + {file = "websocket_client-1.8.0-py3-none-any.whl", hash = "sha256:17b44cc997f5c498e809b22cdf2d9c7a9e71c02c8cc2b6c56e7c2d1239bfa526"}, + {file = "websocket_client-1.8.0.tar.gz", hash = "sha256:3239df9f44da632f96012472805d40a23281a991027ce11d2f45a6f24ac4c3da"}, +] + +[package.extras] +docs = ["Sphinx (>=6.0)", "myst-parser (>=2.0.0)", "sphinx-rtd-theme (>=1.1.0)"] +optional = ["python-socks", "wsaccel"] +test = ["websockets"] + +[[package]] +name = "widgetsnbextension" +version = "4.0.13" +description = "Jupyter interactive widgets for Jupyter Notebook" +optional = false +python-versions = ">=3.7" +files = [ + {file = "widgetsnbextension-4.0.13-py3-none-any.whl", hash = "sha256:74b2692e8500525cc38c2b877236ba51d34541e6385eeed5aec15a70f88a6c71"}, + {file = "widgetsnbextension-4.0.13.tar.gz", hash = "sha256:ffcb67bc9febd10234a362795f643927f4e0c05d9342c727b65d2384f8feacb6"}, +] + [[package]] name = "yarl" version = "1.16.0" @@ -3954,4 +5772,4 @@ liquidation = ["matplotlib", "tqdm", "yfinance"] [metadata] lock-version = "2.0" python-versions = ">=3.10,<3.13" -content-hash = "68d4ea92dc7bb8038417efaa4be20e2a641e6db8ee40f935b0e68d3eccbb5585" +content-hash = "ee28fd4a5fae6000c414309e0cc5e22fb94639406da60daa581d30caf3d31ed0" diff --git a/apps/legacy_app/pyproject.toml b/apps/legacy_app/pyproject.toml index fb37c6df..0944f6ec 100644 --- a/apps/legacy_app/pyproject.toml +++ b/apps/legacy_app/pyproject.toml @@ -25,6 +25,11 @@ pydantic = "^2.9.2" pytest = "^8.3.3" python-dotenv = "^1.0.1" +jupyter = "^1.1.1" +matplotlib-venn = "^1.1.1" +sqlalchemy = "^2.0.36" +seaborn = "^0.13.2" +scikit-learn = "^1.5.2" [tool.poetry.group.dev.dependencies] black = "^24.8.0" isort = "^5.13.2"