diff --git a/.github/workflows/run.yml b/.github/workflows/run.yml index 50d3748..8c1dc43 100644 --- a/.github/workflows/run.yml +++ b/.github/workflows/run.yml @@ -23,13 +23,11 @@ jobs: - name: Install dependencies run: | - pip install . - pip install jupyter nbconvert python-dotenv + pip install ".[dev]" - name: Run notebook run: jupyter nbconvert --to notebook --execute --inplace bitcoin.ipynb - - name: Get current time uses: josStorer/get-current-time@v2 id: current-time diff --git a/.gitignore b/.gitignore index 3e998a4..07b69ec 100644 --- a/.gitignore +++ b/.gitignore @@ -53,6 +53,7 @@ coverage.xml .hypothesis/ .pytest_cache/ cover/ +*.lcov # Translations *.mo diff --git a/bitcoin.ipynb b/bitcoin.ipynb index 936cb43..6b37458 100644 --- a/bitcoin.ipynb +++ b/bitcoin.ipynb @@ -11,16 +11,25 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 60, "metadata": { "execution": { - "iopub.execute_input": "2024-07-20T05:06:23.795228Z", - "iopub.status.busy": "2024-07-20T05:06:23.795001Z", - "iopub.status.idle": "2024-07-20T05:06:23.809128Z", - "shell.execute_reply": "2024-07-20T05:06:23.808502Z" + "iopub.execute_input": "2024-07-19T05:06:34.777299Z", + "iopub.status.busy": "2024-07-19T05:06:34.777094Z", + "iopub.status.idle": "2024-07-19T05:06:34.791418Z", + "shell.execute_reply": "2024-07-19T05:06:34.790757Z" } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The autoreload extension is already loaded. To reload it, use:\n", + " %reload_ext autoreload\n" + ] + } + ], "source": [ "%load_ext autoreload\n", "%autoreload 2" @@ -28,23 +37,23 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 61, "metadata": { "execution": { - "iopub.execute_input": "2024-07-20T05:06:23.811801Z", - "iopub.status.busy": "2024-07-20T05:06:23.811430Z", - "iopub.status.idle": "2024-07-20T05:06:25.057375Z", - "shell.execute_reply": "2024-07-20T05:06:25.056683Z" + "iopub.execute_input": "2024-07-19T05:06:34.794123Z", + "iopub.status.busy": "2024-07-19T05:06:34.793734Z", + "iopub.status.idle": "2024-07-19T05:06:35.844353Z", + "shell.execute_reply": "2024-07-19T05:06:35.843558Z" } }, "outputs": [ { "data": { "text/plain": [ - "False" + "True" ] }, - "execution_count": 2, + "execution_count": 61, "metadata": {}, "output_type": "execute_result" } @@ -85,13 +94,13 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 62, "metadata": { "execution": { - "iopub.execute_input": "2024-07-20T05:06:25.091252Z", - "iopub.status.busy": "2024-07-20T05:06:25.090595Z", - "iopub.status.idle": "2024-07-20T05:06:31.584028Z", - "shell.execute_reply": "2024-07-20T05:06:31.583292Z" + "iopub.execute_input": "2024-07-19T05:06:35.879447Z", + "iopub.status.busy": "2024-07-19T05:06:35.879081Z", + "iopub.status.idle": "2024-07-19T05:06:43.637541Z", + "shell.execute_reply": "2024-07-19T05:06:43.636913Z" } }, "outputs": [], @@ -104,13 +113,13 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 63, "metadata": { "execution": { - "iopub.execute_input": "2024-07-20T05:06:31.586816Z", - "iopub.status.busy": "2024-07-20T05:06:31.586577Z", - "iopub.status.idle": "2024-07-20T05:06:31.599868Z", - "shell.execute_reply": "2024-07-20T05:06:31.599311Z" + "iopub.execute_input": "2024-07-19T05:06:43.640438Z", + "iopub.status.busy": "2024-07-19T05:06:43.640054Z", + "iopub.status.idle": "2024-07-19T05:06:43.653328Z", + "shell.execute_reply": "2024-07-19T05:06:43.652760Z" } }, "outputs": [ @@ -118,7 +127,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Next halving (block 1050000) is predicted on 2028-03-26 16:16:28+00:00\n" + "Next halving (block 1050000) is predicted on 2028-03-26 14:42:01+00:00\n" ] } ], @@ -130,13 +139,13 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 64, "metadata": { "execution": { - "iopub.execute_input": "2024-07-20T05:06:31.602223Z", - "iopub.status.busy": "2024-07-20T05:06:31.601837Z", - "iopub.status.idle": "2024-07-20T05:06:31.619618Z", - "shell.execute_reply": "2024-07-20T05:06:31.619015Z" + "iopub.execute_input": "2024-07-19T05:06:43.655758Z", + "iopub.status.busy": "2024-07-19T05:06:43.655414Z", + "iopub.status.idle": "2024-07-19T05:06:43.674392Z", + "shell.execute_reply": "2024-07-19T05:06:43.673754Z" } }, "outputs": [ @@ -213,7 +222,7 @@ " 5\n", " 1050000\n", " 1.5625\n", - " 2028-03-26 16:16:28+00:00\n", + " 2028-03-26 14:42:01+00:00\n", " NaN\n", " 6\n", " \n", @@ -260,14 +269,14 @@ "2 420000 12.5 2016-07-09 00:00:00+00:00 1402.0 3\n", "3 630000 6.25 2020-05-11 00:00:00+00:00 1440.0 4\n", "4 840000 3.125 2024-04-20 12:09:27+00:00 1436.0 5\n", - "5 1050000 1.5625 2028-03-26 16:16:28+00:00 NaN 6\n", + "5 1050000 1.5625 2028-03-26 14:42:01+00:00 NaN 6\n", "6 1260000 0.78125 NaT NaN 7\n", "7 1470000 0.390625 NaT NaN 8\n", "8 1680000 0.195312 NaT NaN 9\n", "9 1890000 0.097656 NaT NaN 10" ] }, - "execution_count": 5, + "execution_count": 64, "metadata": {}, "output_type": "execute_result" } @@ -278,13 +287,448 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 65, + "metadata": {}, + "outputs": [], + "source": [ + "btc.halvings[\"cycle_length_2\"] = btc.halvings[\"Date\"].diff().dt.days" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [], + "source": [ + "import datetime as dt" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
blockrewardDatecycle_lengthcycle_idcycle_length_2
00502009-01-03 00:00:00+00:001425.01NaN
121000025.02012-11-28 00:00:00+00:001319.021425.0
242000012.52016-07-09 00:00:00+00:001402.031319.0
36300006.252020-05-11 00:00:00+00:001440.041402.0
48400003.1252024-04-20 12:09:27+00:001436.051440.0
510500001.56252028-03-26 14:42:01+00:00NaN61436.0
612600000.78125NaTNaN7NaN
714700000.390625NaTNaN8NaN
816800000.195312NaTNaN9NaN
918900000.097656NaTNaN10NaN
1021000000.048828NaTNaN11NaN
1123100000.024414NaTNaN12NaN
1225200000.012207NaTNaN13NaN
1327300000.006104NaTNaN14NaN
1429400000.003052NaTNaN15NaN
1531500000.001526NaTNaN16NaN
1633600000.000763NaTNaN17NaN
1735700000.000381NaTNaN18NaN
1837800000.000191NaTNaN19NaN
1939900000.000095NaTNaN20NaN
2042000000.000048NaTNaN21NaN
2144100000.000024NaTNaN22NaN
2246200000.000012NaTNaN23NaN
2348300000.000006NaTNaN24NaN
2450400000.000003NaTNaN25NaN
2552500000.000001NaTNaN26NaN
2654600000.000001NaTNaN27NaN
2756700000.0NaTNaN28NaN
2858800000.0NaTNaN29NaN
2960900000.0NaTNaN30NaN
3063000000.0NaTNaN31NaN
3165100000.0NaTNaN32NaN
3267200000.0NaTNaN33NaN
\n", + "
" + ], + "text/plain": [ + " block reward Date cycle_length cycle_id \\\n", + "0 0 50 2009-01-03 00:00:00+00:00 1425.0 1 \n", + "1 210000 25.0 2012-11-28 00:00:00+00:00 1319.0 2 \n", + "2 420000 12.5 2016-07-09 00:00:00+00:00 1402.0 3 \n", + "3 630000 6.25 2020-05-11 00:00:00+00:00 1440.0 4 \n", + "4 840000 3.125 2024-04-20 12:09:27+00:00 1436.0 5 \n", + "5 1050000 1.5625 2028-03-26 14:42:01+00:00 NaN 6 \n", + "6 1260000 0.78125 NaT NaN 7 \n", + "7 1470000 0.390625 NaT NaN 8 \n", + "8 1680000 0.195312 NaT NaN 9 \n", + "9 1890000 0.097656 NaT NaN 10 \n", + "10 2100000 0.048828 NaT NaN 11 \n", + "11 2310000 0.024414 NaT NaN 12 \n", + "12 2520000 0.012207 NaT NaN 13 \n", + "13 2730000 0.006104 NaT NaN 14 \n", + "14 2940000 0.003052 NaT NaN 15 \n", + "15 3150000 0.001526 NaT NaN 16 \n", + "16 3360000 0.000763 NaT NaN 17 \n", + "17 3570000 0.000381 NaT NaN 18 \n", + "18 3780000 0.000191 NaT NaN 19 \n", + "19 3990000 0.000095 NaT NaN 20 \n", + "20 4200000 0.000048 NaT NaN 21 \n", + "21 4410000 0.000024 NaT NaN 22 \n", + "22 4620000 0.000012 NaT NaN 23 \n", + "23 4830000 0.000006 NaT NaN 24 \n", + "24 5040000 0.000003 NaT NaN 25 \n", + "25 5250000 0.000001 NaT NaN 26 \n", + "26 5460000 0.000001 NaT NaN 27 \n", + "27 5670000 0.0 NaT NaN 28 \n", + "28 5880000 0.0 NaT NaN 29 \n", + "29 6090000 0.0 NaT NaN 30 \n", + "30 6300000 0.0 NaT NaN 31 \n", + "31 6510000 0.0 NaT NaN 32 \n", + "32 6720000 0.0 NaT NaN 33 \n", + "\n", + " cycle_length_2 \n", + "0 NaN \n", + "1 1425.0 \n", + "2 1319.0 \n", + "3 1402.0 \n", + "4 1440.0 \n", + "5 1436.0 \n", + "6 NaN \n", + "7 NaN \n", + "8 NaN \n", + "9 NaN \n", + "10 NaN \n", + "11 NaN \n", + "12 NaN \n", + "13 NaN \n", + "14 NaN \n", + "15 NaN \n", + "16 NaN \n", + "17 NaN \n", + "18 NaN \n", + "19 NaN \n", + "20 NaN \n", + "21 NaN \n", + "22 NaN \n", + "23 NaN \n", + "24 NaN \n", + "25 NaN \n", + "26 NaN \n", + "27 NaN \n", + "28 NaN \n", + "29 NaN \n", + "30 NaN \n", + "31 NaN \n", + "32 NaN " + ] + }, + "execution_count": 67, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "btc.halvings" + ] + }, + { + "cell_type": "code", + "execution_count": 68, "metadata": { "execution": { - "iopub.execute_input": "2024-07-20T05:06:31.621912Z", - "iopub.status.busy": "2024-07-20T05:06:31.621537Z", - "iopub.status.idle": "2024-07-20T05:06:31.642616Z", - "shell.execute_reply": "2024-07-20T05:06:31.641982Z" + "iopub.execute_input": "2024-07-19T05:06:43.676960Z", + "iopub.status.busy": "2024-07-19T05:06:43.676561Z", + "iopub.status.idle": "2024-07-19T05:06:43.699795Z", + "shell.execute_reply": "2024-07-19T05:06:43.699096Z" } }, "outputs": [ @@ -455,14 +899,14 @@ " \n", " 5117\n", " 2024-07-20 00:00:00+00:00\n", - " 66635.09000\n", + " 67473.83000\n", " 840000.0\n", " 3.125\n", " 1436.0\n", " 5.0\n", " 2024-04-20 12:09:27+00:00\n", " 73118.09000\n", - " -0.088665\n", + " -0.077194\n", " 0.062674\n", " \n", " \n", @@ -482,7 +926,7 @@ "5114 2024-07-17 00:00:00+00:00 64096.64000 840000.0 3.125 1436.0 \n", "5115 2024-07-18 00:00:00+00:00 63981.43000 840000.0 3.125 1436.0 \n", "5116 2024-07-19 00:00:00+00:00 66708.49000 840000.0 3.125 1436.0 \n", - "5117 2024-07-20 00:00:00+00:00 66635.09000 840000.0 3.125 1436.0 \n", + "5117 2024-07-20 00:00:00+00:00 67473.83000 840000.0 3.125 1436.0 \n", "\n", " cycle_id Halving ATH distance_ath_perc \\\n", "0 1.0 2009-01-03 00:00:00+00:00 0.04951 0.000000 \n", @@ -495,7 +939,7 @@ "5114 5.0 2024-04-20 12:09:27+00:00 73118.09000 -0.123382 \n", "5115 5.0 2024-04-20 12:09:27+00:00 73118.09000 -0.124958 \n", "5116 5.0 2024-04-20 12:09:27+00:00 73118.09000 -0.087661 \n", - "5117 5.0 2024-04-20 12:09:27+00:00 73118.09000 -0.088665 \n", + "5117 5.0 2024-04-20 12:09:27+00:00 73118.09000 -0.077194 \n", "\n", " cycle_progress \n", "0 0.392982 \n", @@ -513,7 +957,7 @@ "[5118 rows x 10 columns]" ] }, - "execution_count": 6, + "execution_count": 68, "metadata": {}, "output_type": "execute_result" } @@ -537,13 +981,13 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 69, "metadata": { "execution": { - "iopub.execute_input": "2024-07-20T05:06:31.645393Z", - "iopub.status.busy": "2024-07-20T05:06:31.645025Z", - "iopub.status.idle": "2024-07-20T05:06:33.094674Z", - "shell.execute_reply": "2024-07-20T05:06:33.093957Z" + "iopub.execute_input": "2024-07-19T05:06:43.702484Z", + "iopub.status.busy": "2024-07-19T05:06:43.702096Z", + "iopub.status.idle": "2024-07-19T05:06:45.171416Z", + "shell.execute_reply": "2024-07-19T05:06:45.170728Z" } }, "outputs": [ @@ -551,13 +995,13 @@ "name": "stderr", "output_type": "stream", "text": [ - "/home/runner/work/btc-cycles/btc-cycles/btc_cycles/artist/static.py:98: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n", + "/Users/giorgiocaizzi/Documents/GitHub/btc-cycles/btc_cycles/artist/static.py:98: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n", " self.f.tight_layout()\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -595,7 +1039,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.14" + "version": "3.11.9" } }, "nbformat": 4, diff --git a/bitcoin.png b/bitcoin.png index 56d1ea1..be0aa21 100644 Binary files a/bitcoin.png and b/bitcoin.png differ diff --git a/btc_cycles/artist/utils.py b/btc_cycles/artist/utils.py index 9ce3423..61bb052 100644 --- a/btc_cycles/artist/utils.py +++ b/btc_cycles/artist/utils.py @@ -2,6 +2,7 @@ from __future__ import annotations +import datetime as dt from typing import TYPE_CHECKING import matplotlib.colors as mcolors @@ -84,8 +85,14 @@ def _get_moments(self, bitcoin) -> None: def _add_predicted(self, bitcoin) -> None: """adds predicted halving date to labels""" - self.predicted_halving_str = r"$\bf{{{} \: (predicted)}}$".format( - bitcoin.predicted_halving_date.strftime("%d-%m-%Y") - ) - - self.labels.iloc[0] = self.labels.iloc[0] + self.predicted_halving_str + # get current cycle length + expected_length = bitcoin.halvings["cycle_length"].dropna().iloc[-1] + # list of predicted dates (0.25, 0.5 and 0.75 of the cycle) + predicted_dates = [bitcoin.predicted_halving_date] + [ + bitcoin.halvings["Date"].dropna().iloc[-2] + dt.timedelta(days=x) + for x in [x * expected_length for x in [0.25, 0.5, 0.75]] + ] + # string and add to labels + for i, date in enumerate(predicted_dates): + predicted_string = r"$\bf{{{}}}$".format(date.strftime("%d-%m-%Y")) + self.labels.iloc[i] = self.labels.iloc[i] + predicted_string diff --git a/coverage.lcov b/coverage.lcov deleted file mode 100644 index f2ebb07..0000000 --- a/coverage.lcov +++ /dev/null @@ -1,360 +0,0 @@ -TN: -SF:btc_cycles/__init__.py -DA:1,1,3pmbihgY8wYSG0BnDsC+YQ -DA:3,1,eTd407FC+cvhmqhZsRbrnA -DA:5,1,XB5cudJcSu+ohnyzSwnrAw -LF:2 -LH:2 -end_of_record -TN: -SF:btc_cycles/artist/__init__.py -DA:1,1,Bx/PGklZ+xJuDQtIgNNSgw -DA:3,1,iNcBpWfytslchA5zzowqxw -DA:5,1,pIG6lqT6YO4GLnzCiFS8pQ -LF:2 -LH:2 -end_of_record -TN: -SF:btc_cycles/artist/artist.py -DA:1,1,7wQxE21MzPazzPpKtdq0Bw -DA:3,1,ydCxunymauVRdfWlNGpIBA -DA:5,1,uqQzsyLE2snBclOsmsd0qA -DA:6,1,6kjQBQjgRJ5RB/jRAVrZtw -DA:8,1,8JHQ//b7bx9GAu5pNLKiCQ -DA:10,1,rOMIMlbvtyu7gXIIy/UEaQ -DA:13,1,UVqa2DFxhiOR2km6vyDw9Q -DA:33,1,wZXD4oQzyCqk/gg8sJnt3w -DA:34,1,AVTXM3ssiuIw0pue3whKtw -DA:36,1,4LgMgWBGno1n5MNJ8WRFsQ -DA:63,1,Ch9auFc1FqAaim5XTZczmw -DA:64,1,/b8A/EaDjmWpliuEQPE8eQ -DA:67,1,em/PikRaszRjQg4pELW6dQ -DA:70,1,+YlEIrBUjLcbslHa2jIt2g -DA:71,1,Kpz1uPTrVRICV0687uzsrA -DA:72,1,Vrx0ZpPOJ/te5VleYTCI/Q -DA:79,1,LflkwbsGYj970Wk1poGCQQ -DA:88,1,hP0vnDTCog2MVExJtw2Agg -DA:89,1,hGgVFKxzqHvfTTtvJi449Q -DA:110,1,HmADa1g/W1C2Vo9Wm4sNNA -DA:111,1,5CkTM6YF/SlbXX9yEf95MQ -DA:114,1,vhR55KQFHUS0Jm2yWPdfuQ -DA:120,1,n0iWNoJ+w3KNejOdSek/ZQ -DA:11,0,DF/edVsXGbBQ0cbV4A/OjQ -DA:73,0,2lZL/CKvu5edMmAcU/izvw -DA:75,0,MK4EuQB7ZrQO617+ESGIQg -DA:77,0,NZZvztWbxKScL0w82kEDuQ -DA:91,0,Aexz6JT+Z1yAqNNQngn9sg -DA:94,0,7fW5iHHGXFI9KRtg+5eVbw -DA:95,0,I4TF3ZWyHwpvAQV5pcsf+A -DA:98,0,0vHnlb2cY+GkmnoqMJi58Q -DA:99,0,tY/vAMwJeZOXF6wJdEpICg -DA:100,0,kj1YCGLwWVpMvvRd33cPjg -DA:102,0,dbKlHuLQGiU40TQNOF8ZIg -DA:104,0,PgcOxsNOWVClBKaJhC1u6g -DA:106,0,HVyrBJ61ni9ux6MdUIeaUA -DA:112,0,ntb8IoSZRnWcIsFG6a9vog -LF:35 -LH:21 -end_of_record -TN: -SF:btc_cycles/artist/static.py -DA:1,1,D58qlvSd2VzQ2qC75Uc/hw -DA:3,1,ydCxunymauVRdfWlNGpIBA -DA:5,1,2/+ysJB2BBzVWbseKUaEjQ -DA:6,1,L/jqrDHxbfUd/SDMFGHfTA -DA:7,1,GY/cXwuHOGqJcx8sUymOUQ -DA:8,1,Fz6U3I1JXdkX/Ji3N4zfzg -DA:10,1,5NkS5vn0zEghj77AZlkh7g -DA:11,1,H6Ih3lhVTepkL/uzTHkubA -DA:12,1,IWWjrCeOtk8NNtrE95++2g -DA:13,1,jwSbY/d8PRmlqla1DhwwmA -DA:15,1,fPdSAF8P0eP/MvAVIjmiyg -DA:17,1,rOMIMlbvtyu7gXIIy/UEaQ -DA:21,1,Dly9nXenTkxybzS0Yzvacg -DA:22,1,tx6rTe0HkTm9MvZV8arfAQ -DA:37,1,SnJqPIApY7uOV951c6q78Q -DA:38,1,0CJUshVjsX29qJqvWxjzgw -DA:39,1,QR8U++fnDHh4UcKaXQz0Yw -DA:40,1,49iD3iCUCcs1fqdlmgC36g -DA:43,1,emSTamHzoTnAQGQk7+frGA -DA:45,1,s+3Pk/B5Kj2y6sRV+kxZHQ -DA:51,1,jlgH6NxrqQ6pksXgjXBzQQ -DA:55,1,f+bsIi6sQYXOl88natIgqw -DA:62,1,qtye7O1Y/8lrc0O09/eTLg -DA:66,1,kbxDa8ohtC0UFYULAgFibQ -DA:67,1,s1MonBJDFe25LtPoZcWsXA -DA:70,1,ZGI9EsF63oSI+PkbPXxKiw -DA:73,1,kMc2ybNS+58LDgEn4wbu7Q -DA:76,1,Ek50YOwFQDSEp1onl+L3FA -DA:79,1,/Gv2d6ah1gmb0rlqciZkZg -DA:85,1,+GiuIbGTvlaocVi7BEr4RA -DA:88,1,OK3fRzy49bJkBEsj8ZpFYQ -DA:91,1,ELK8769nTxTA5dku62LNmg -DA:94,1,UQEADABNN+P6NT4hM/rBDQ -DA:98,1,rpkW/Wh9O23Fwhc58Wi3tA -DA:101,1,mbUxiUBU8xWtnomCGlgbnQ -DA:103,1,ew/XwKrmMzktZPwqZyGeyg -DA:105,1,xjcDBnSwra0OiNOAYAwoHA -DA:107,1,PCC8zfFkI9ZoBcFiFO6q2Q -DA:110,1,q6JadHSAKqAX+GzNgqcLzg -DA:111,1,HSbgHn5j6Lf5OdE8E4/9ZA -DA:122,1,AY0LmYBmIADYFh2Cz5/4Dg -DA:130,1,JuAngCvQbUiku8TobQQEeQ -DA:137,1,BPnPnsZbKVh+NnJsDQaX+g -DA:146,1,9So0N65SuSIXLduJOzWY3w -DA:149,1,+5Wmg4Qt6gFcDNFMZ4u8PA -DA:152,1,z3HEo+nXCJddP85t4sEBPA -DA:153,1,rPzIWYAkmyknmX2xYKncbw -DA:155,1,itXjWu0XUYXACfzC1nyTGg -DA:168,1,/0+Jq/QNHOjbvgKCcm6EHw -DA:181,1,H39GkttqHgnmG6t271oiog -DA:188,1,6iaNEhk8sScG2asSace3Uw -DA:191,1,dIiUeG5DV+ceRseJImZcCg -DA:197,1,BJGpz/agV/6Lk5ndR+ITyQ -DA:200,1,cYuR0TB6f8RF55SOGB+lyQ -DA:206,1,KZQrRHh/0tve5yqTr4HbnQ -DA:209,1,yTaLcbUce8rTTZeox0YKgQ -DA:210,1,RE73YJeauiLKkkyhGdurmQ -DA:213,1,rJq5TOJaJB/Y/ZxrgS408Q -DA:218,1,7qkMzoQDo5nkAddt2HypBg -DA:220,1,ebg/SD/snaCXbpL/DGNwtA -DA:231,1,QFmP3WEeKO5oBY2Mc+JwgA -DA:233,1,tuGBYFkT2ZC22Va+ExhJtw -DA:234,1,BPnPnsZbKVh+NnJsDQaX+g -DA:243,1,7Lj26UKTwQpKqfLurm+XRQ -DA:245,1,U9EoUTISYWof1jjWz7zPfg -DA:254,1,GWzbxLOaZtTxxzVzzKASJA -DA:255,1,BPnPnsZbKVh+NnJsDQaX+g -DA:264,1,U9EoUTISYWof1jjWz7zPfg -DA:273,1,dAfxDngl/7CXOoPsFSy/eA -DA:275,1,HB2ZHtsoGhHHplzPW7cHtA -DA:292,1,PdZf+DsUbQoHO4Vc9ECyHA -DA:293,1,yy3SXt5J+9iagsdPz9lFig -DA:296,1,LtXQ0yyRlnzwWGbMQ1kS+w -DA:301,1,khnSvdSo8r8B0H4L2kljoQ -DA:303,1,l0GrnmWGilpmJB+tDZqcUw -DA:305,1,xLFFwYXyO8C4V9D4r3918g -DA:306,1,pZf5xY5FmVxbqtDpKRWEOA -DA:315,1,sniUN8lSNnOsCGeCVS8Wgg -DA:321,1,t76//YLGH5vTSxuHH9pQCw -DA:324,1,guewB+6PfKiMy+P97UwRbg -DA:18,0,DF/edVsXGbBQ0cbV4A/OjQ -DA:108,0,TulZRDVyZgwaluSyPp9m8w -DA:109,0,EQ3Pi8FUfqLho2veUftMdQ -DA:132,0,1NTRskL433ffR1oI7MoCSg -DA:222,0,BPnPnsZbKVh+NnJsDQaX+g -LF:83 -LH:78 -end_of_record -TN: -SF:btc_cycles/artist/utils.py -DA:1,1,c2YWNk2sJ8LwlQRY51TqMQ -DA:3,1,ydCxunymauVRdfWlNGpIBA -DA:5,1,mjVJPNV1Grbtqt25vnQFRw -DA:7,1,5NkS5vn0zEghj77AZlkh7g -DA:8,1,H6Ih3lhVTepkL/uzTHkubA -DA:9,1,wbex0Ytf94b7jE0u9OATig -DA:11,1,rOMIMlbvtyu7gXIIy/UEaQ -DA:15,1,3IJy8rbseNaU2NsqRbLR8w -DA:16,1,pMC68bY/NqiYHFGp37uMSA -DA:26,1,OBCRD3ymbS4kXfhqbSJQRg -DA:27,1,9Rsg1hVKuZFXm+LP220StQ -DA:29,1,8mMh8FYBC5dM1LVifS3Jug -DA:31,1,Ud+CXAxof943KeiG03+gsA -DA:35,1,5sm0e2z9lQXQQ+4QdjjE9w -DA:38,1,thDDjTUMBRMeweioA5KRnA -DA:39,1,a6UWLDU5HXl8FkhkXni2Ug -DA:49,1,OBCRD3ymbS4kXfhqbSJQRg -DA:50,1,eIvm9aoO7LB5TIsm7lTIAg -DA:52,1,N5c/kugbAEzPKaxNV4dSyQ -DA:54,1,kAyutGmTF4PcZV1IUKvilQ -DA:55,1,bSLqEjGWBxmMWt050zrV8w -DA:57,1,qdtr3HkY7QwU5xmzchL5FQ -DA:61,1,lfuP0lWWjShB1JvgtZ8yNg -DA:62,1,hcNNL3sCAraIrzIe44ncvA -DA:70,1,XD7pn5VYRYFSKGU/QdsRGg -DA:73,1,icg/Q2MPW8KWVoa9s9VJrQ -DA:77,1,ba95ioOekFAsoCYMKzgafg -DA:83,1,KRSTWBl0HnUlNCfZBLNHsQ -DA:85,1,qUzSg34fZ8HOAwof8zUh4A -DA:87,1,867SIqcUh4ZJnp2WDgMDpA -DA:91,1,QHuWSRV2a2j90JYBPsP/Kw -DA:12,0,DF/edVsXGbBQ0cbV4A/OjQ -LF:29 -LH:28 -end_of_record -TN: -SF:btc_cycles/core/__init__.py -DA:1,1,jE2Svww/TyaK8UH1slkqeQ -DA:3,1,Y6Q+Bh/osDHA06Kiidb0tg -DA:5,1,XB5cudJcSu+ohnyzSwnrAw -LF:2 -LH:2 -end_of_record -TN: -SF:btc_cycles/core/bitcoin.py -DA:1,1,cMDojNmZCWQ0veVqd60IzA -DA:3,1,ydCxunymauVRdfWlNGpIBA -DA:5,1,L/jqrDHxbfUd/SDMFGHfTA -DA:6,1,6kjQBQjgRJ5RB/jRAVrZtw -DA:8,1,l1TO0YchkrIxPUeWYoJChA -DA:9,1,uCSznzu2QLC0QB7OrfX5Yw -DA:10,1,MO9o9Rravky6dV4FgLj8Fg -DA:15,1,rOMIMlbvtyu7gXIIy/UEaQ -DA:19,1,MkoBDVLifWJgV3ZWYNtOGQ -DA:20,1,dhpzPru312PpH5wzOY2+RQ -DA:44,1,4LgMgWBGno1n5MNJ8WRFsQ -DA:51,1,kxXhdAJBcsJeaxvwH4DreQ -DA:53,1,ZiPsV8+0rWLeD2ru6eMirw -DA:55,1,NJ81cDh55DjwYGpedf2tvg -DA:57,1,S45JMdXb/LS9TV8gLMtraw -DA:88,1,rCXuGYWMlfbRpug6Vg3Zsw -DA:90,1,JU0+q1Fb2cRRDv6AGqX+Iw -DA:16,0,JSeU6Yw+jMfkpGEiVwqHvg -LF:16 -LH:15 -end_of_record -TN: -SF:btc_cycles/core/halvings.py -DA:1,1,ERsTUm32akS7irN9LcHgqA -DA:3,1,L/jqrDHxbfUd/SDMFGHfTA -DA:4,1,OaTlemF3bXMi5MP7Db8vkQ -DA:5,1,6vWAvNsegNqafFN4IKLrhg -DA:7,1,wbex0Ytf94b7jE0u9OATig -DA:8,1,jkHhMsABSAn8fG2ZAQpm1g -DA:10,1,2fGav+oEPaNcpr7ZSCENzA -DA:13,1,SpkiuiBbdaNFJkftlCzkTQ -DA:22,1,cAteAUZjwL8dBxYHd0lwhQ -DA:23,1,9QGvCVNnsjRStCbSXKFDcQ -DA:25,1,sMImnygMfzJtY+Eg1OAG0A -DA:26,1,swBrkstl0de9OehxwEpZGw -DA:27,1,UfwvOV96rC1TBvcQBx5/mA -DA:30,1,5TkIVHtfOyy9bwko2MZ8ig -DA:44,1,h1Q323Fw3SwPwLLKTOCncw -DA:46,1,MjI/Dt6pRSMM91vcLGA99A -DA:47,1,vIzsZIYrCVO2pjaQ4WGZxQ -DA:50,1,aFNtaJohULECQycVbnGcFQ -DA:51,1,CJIEJEmO+eJAXJDDzUGtjw -DA:59,1,gFdnwIzxJ64X+nD2UauP7A -DA:60,1,iN+xN0TkpO7NzVPUhtETYA -DA:62,1,XvsQuHjSR30GljGx4hSdqg -DA:63,1,JSgBK9JoCHHSgNGfdTQmyg -DA:65,1,UGfzJhTpDuif8/4HtaXKxg -DA:66,1,lk3K3bdOBrcsa55jhgH6ow -DA:68,1,9qN8e8rM4haZtJb/6kEtiQ -DA:70,1,ixL1gFHJ7voh6butVcuvxg -DA:71,1,hhDgONja0+2ViN3B7qKR4A -DA:73,1,Hyo4gX14YIyQo+0z0/n/tw -DA:75,1,ceso4qX8HeNRDsgAzeURGA -DA:77,1,QudJYKryEDRCg1QT5R40JA -LF:29 -LH:29 -end_of_record -TN: -SF:btc_cycles/core/prices.py -DA:1,1,Hdy1K8O29G6GKDtXyRWR6w -DA:3,1,jEc91tz0B1b2beSYnS+UDQ -DA:5,1,wbex0Ytf94b7jE0u9OATig -DA:7,1,8iavWNybP/2pKl7TfPcUhQ -DA:8,1,Hh7XDaWl0DFySgjUmsot0w -DA:11,1,0ZzS+PL6uz9329erm7fKqQ -DA:31,1,pea315D5hn6Pg8NoODitMw -DA:48,1,HPADjZVM+6tW4Y9I3fhk5A -DA:49,1,Lz21/kLvFrXKqdgibpSM3A -DA:73,1,H6sITh3YY4l8Y6QxjiEKIQ -DA:74,1,W9It9dXzZ0ZueXlxHdAzQQ -DA:75,1,VCFScN7+qIUje+RVecuZpA -DA:76,1,R42+lEqpA1wKk+oL/k8abA -DA:77,1,VkOm+eBkQyxJzJwcSt/97g -DA:79,1,ySD/sojl/13JcA/YZeOFyQ -DA:91,1,YCqI2s+jNNuAKHt4Cuw5+w -DA:114,1,z0MGcQJsJtGz+Ih+x1q9Fw -DA:23,0,CdTl2R458WBjxjIrfh7TTA -DA:25,0,mqiYY9zwbOqGBeFx9hr6hw -DA:28,0,Zd/V/6r8DN80/4vXL9nxAQ -DA:42,0,zaL0qx3v0WpDCdE5hClUwg -DA:45,0,Zd/V/6r8DN80/4vXL9nxAQ -DA:80,0,b+9+H5K7xbyZMSHuamrSGg -DA:81,0,/p2d+qwNk58TsYAG4DRH6w -DA:83,0,tYjcK/IAJkWRgURrBosf4w -DA:85,0,ZiPsV8+0rWLeD2ru6eMirw -DA:87,0,noI07Np+ZTxvRtcr4eVShw -DA:89,0,WUoQMUJvpgzs+rrox4ThVQ -DA:94,0,N4si+upQGXDufXz496oNJA -DA:96,0,7/FiWAx9+JKbL7lys6EH4A -DA:97,0,pLgz9GYwUUw3Y6s0ouZlEQ -DA:98,0,T3Hy+BOb8A5P40uO9girog -DA:104,0,R0rkWbV3XDJr+HJKWVNaZw -DA:110,0,EoH6wbSnZBjH7QFVneVG5w -DA:112,0,IUOeCFd662+zDc+SXqLrJA -DA:117,0,/biYRo9x1CxvqR7unim7CQ -DA:119,0,3AzUpgJmYFUfXvuuTc+sNw -LF:35 -LH:15 -end_of_record -TN: -SF:btc_cycles/core/sources/__init__.py -DA:1,1,fjZi5I3vJa3jfT/UsAbv4g -DA:3,1,NY0SMcFRNTXkXd0D5s0Zvg -DA:5,1,Z9ehPUAFrN3sw6KUdQM8Yw -LF:2 -LH:2 -end_of_record -TN: -SF:btc_cycles/core/sources/cmc.py -DA:1,1,lrtL7AA8vX17hz6W5mUqhQ -DA:3,1,jkHhMsABSAn8fG2ZAQpm1g -DA:5,1,+v4rsXPMmKkRxSGWwUWzAA -DA:6,1,hKXA22jxLRmxGzWjnVu1TQ -DA:9,1,Ogd4MkrBWXmYOsHmdULHwQ -DA:10,1,iMZSR1R4LldbH+oSSke37A -DA:12,1,qJqgC1G//v0RioEcVOy74A -DA:15,1,dfADr5x3SPsSsZjQaSwJjg -DA:13,0,/WhoafiHYfih8KZoMK9uag -DA:26,0,YWmpw7PkmW5HXOB2ViWrSQ -DA:30,0,77dsX8wrkr3CZp54CS8izg -DA:35,0,p9TLphrB7lhMwF2+nALjyA -DA:36,0,yjKM5ueVJro01e7L/Mlubw -DA:37,0,UB7EYfFsbTE42KdFUfQYdQ -LF:12 -LH:6 -end_of_record -TN: -SF:btc_cycles/core/sources/source.py -DA:1,1,1YCCkB4lJpzg7gSbEj/g3g -DA:3,1,2IFz84Khr/l5NE1IKLRa2w -DA:4,1,uqQzsyLE2snBclOsmsd0qA -DA:5,1,jEc91tz0B1b2beSYnS+UDQ -DA:7,1,Ffbl3/V+CFYq1+rohcVTqQ -DA:8,1,wbex0Ytf94b7jE0u9OATig -DA:9,1,eA0lpKBwyryi61g9O42lRw -DA:11,1,fVxoZSJ7Td0E1VeeCvlJbA -DA:14,1,Vt5O9l+ixVZ6tA0wFse3JA -DA:16,1,eb6TD1ZZufaFxiZkB1JKsA -DA:20,1,SldGnbsXhjgAhZC1bU0Qag -DA:17,0,b+9+H5K7xbyZMSHuamrSGg -DA:18,0,/WhoafiHYfih8KZoMK9uag -DA:35,0,V064tTKp1eoVTpSLq6A4Zg -DA:36,0,xvWIcpcyNr0gyGcTkdMxXw -DA:37,0,pLyfWB/15TSvwGkJH1btQw -DA:38,0,lTjBhekRmdHFaWmS/2yKCQ -DA:41,0,0XCVDPmbazV/GQiRA2Fxwg -DA:42,0,xjYOle8cmfQAv5SES91Bag -DA:43,0,Kl8/W5PVjxoXAy4t8Yy4Nw -DA:44,0,o7hRjAg9/aU8uxlmMm18Eg -DA:45,0,NrDAqEqcJtvmQgQDEuBvhQ -DA:46,0,5u9bg9dy7sR0e/FXQhHhDg -DA:48,0,YcEKLrnuNcQH6XY251qwcg -DA:49,0,dSJ6aztLsPVE45ymHQu+Hg -DA:54,0,xvWIcpcyNr0gyGcTkdMxXw -DA:55,0,PP9tAR97bOqoOnLDhjz1QA -DA:56,0,kjfZHx9Q2zsB2AqBWoaUgA -DA:57,0,6Wsjpm7MAW81Ls9gNbp/lQ -DA:58,0,NrDAqEqcJtvmQgQDEuBvhQ -DA:59,0,ziMwbdP43Yl2rkv+Iw0+Vg -DA:63,0,494HdZNThJ5E/W4/LcM/EQ -DA:64,0,U0GBJCHs7Y4EKf1fuFzANA -DA:67,0,CjkiJ+Ejej07BnR6oPRj7g -LF:33 -LH:10 -end_of_record diff --git a/poetry.lock b/poetry.lock index 30cd63e..aff7f81 100644 --- a/poetry.lock +++ b/poetry.lock @@ -1,5 +1,27 @@ # This file is automatically @generated by Poetry 1.8.0 and should not be changed by hand. +[[package]] +name = "anyio" +version = "4.4.0" +description = "High level compatibility layer for multiple asynchronous event loop implementations" +optional = false +python-versions = ">=3.8" +files = [ + {file = "anyio-4.4.0-py3-none-any.whl", hash = "sha256:c1b2d8f46a8a812513012e1107cb0e68c17159a7a594208005a57dc776e1bdc7"}, + {file = "anyio-4.4.0.tar.gz", hash = "sha256:5aadc6a1bbb7cdb0bede386cac5e2940f5e2ff3aa20277e991cf028e0585ce94"}, +] + +[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)", "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", "uvloop (>=0.17)"] +trio = ["trio (>=0.23)"] + [[package]] name = "appnope" version = "0.1.4" @@ -11,6 +33,82 @@ files = [ {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 = "asttokens" version = "2.4.1" @@ -29,6 +127,56 @@ six = ">=1.12.0" 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 = "attrs" +version = "23.2.0" +description = "Classes Without Boilerplate" +optional = false +python-versions = ">=3.7" +files = [ + {file = "attrs-23.2.0-py3-none-any.whl", hash = "sha256:99b87a485a5820b23b879f04c2305b44b951b502fd64be915879d77a7e8fc6f1"}, + {file = "attrs-23.2.0.tar.gz", hash = "sha256:935dc3b529c262f6cf76e50877d35a4bd3c1de194fd41f47a2b7ae8f19971f30"}, +] + +[package.extras] +cov = ["attrs[tests]", "coverage[toml] (>=5.3)"] +dev = ["attrs[tests]", "pre-commit"] +docs = ["furo", "myst-parser", "sphinx", "sphinx-notfound-page", "sphinxcontrib-towncrier", "towncrier", "zope-interface"] +tests = ["attrs[tests-no-zope]", "zope-interface"] +tests-mypy = ["mypy (>=1.6)", "pytest-mypy-plugins"] +tests-no-zope = ["attrs[tests-mypy]", "cloudpickle", "hypothesis", "pympler", "pytest (>=4.3.0)", "pytest-xdist[psutil]"] + +[[package]] +name = "babel" +version = "2.15.0" +description = "Internationalization utilities" +optional = false +python-versions = ">=3.8" +files = [ + {file = "Babel-2.15.0-py3-none-any.whl", hash = "sha256:08706bdad8d0a3413266ab61bd6c34d0c28d6e1e7badf40a2cebe67644e2e1fb"}, + {file = "babel-2.15.0.tar.gz", hash = "sha256:8daf0e265d05768bc6c7a314cf1321e9a123afc328cc635c18622a2f30a04413"}, +] + +[package.dependencies] +pytz = {version = ">=2015.7", markers = "python_version < \"3.9\""} + +[package.extras] +dev = ["freezegun (>=1.0,<2.0)", "pytest (>=6.0)", "pytest-cov"] + [[package]] name = "backcall" version = "0.2.0" @@ -40,6 +188,45 @@ files = [ {file = "backcall-0.2.0.tar.gz", hash = "sha256:5cbdbf27be5e7cfadb448baf0aa95508f91f2bbc6c6437cd9cd06e2a4c215e1e"}, ] +[[package]] +name = "beautifulsoup4" +version = "4.12.3" +description = "Screen-scraping library" +optional = false +python-versions = ">=3.6.0" +files = [ + {file = "beautifulsoup4-4.12.3-py3-none-any.whl", hash = "sha256:b80878c9f40111313e55da8ba20bdba06d8fa3969fc68304167741bbf9e082ed"}, + {file = "beautifulsoup4-4.12.3.tar.gz", hash = "sha256:74e3d1928edc070d21748185c46e3fb33490f22f52a3addee9aee0f4f7781051"}, +] + +[package.dependencies] +soupsieve = ">1.2" + +[package.extras] +cchardet = ["cchardet"] +chardet = ["chardet"] +charset-normalizer = ["charset-normalizer"] +html5lib = ["html5lib"] +lxml = ["lxml"] + +[[package]] +name = "bleach" +version = "6.1.0" +description = "An easy safelist-based HTML-sanitizing tool." +optional = false +python-versions = ">=3.8" +files = [ + {file = "bleach-6.1.0-py3-none-any.whl", hash = "sha256:3225f354cfc436b9789c66c4ee030194bee0568fbf9cbdad3bc8b5c26c5f12b6"}, + {file = "bleach-6.1.0.tar.gz", hash = "sha256:0a31f1837963c41d46bbf1331b8778e1308ea0791db03cc4e7357b97cf42a8fe"}, +] + +[package.dependencies] +six = ">=1.9.0" +webencodings = "*" + +[package.extras] +css = ["tinycss2 (>=1.1.0,<1.3)"] + [[package]] name = "certifi" version = "2024.7.4" @@ -539,6 +726,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 = "distlib" version = "0.3.8" @@ -578,6 +776,20 @@ files = [ [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 = "filelock" version = "3.15.4" @@ -659,6 +871,73 @@ 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 = "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 = "httpcore" +version = "1.0.5" +description = "A minimal low-level HTTP client." +optional = false +python-versions = ">=3.8" +files = [ + {file = "httpcore-1.0.5-py3-none-any.whl", hash = "sha256:421f18bac248b25d310f3cacd198d55b8e6125c107797b609ff9b7a6ba7991b5"}, + {file = "httpcore-1.0.5.tar.gz", hash = "sha256:34a38e2f9291467ee3b44e89dd52615370e152954ba21721378a87b2960f7a61"}, +] + +[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,<0.26.0)"] + +[[package]] +name = "httpx" +version = "0.27.0" +description = "The next generation HTTP client." +optional = false +python-versions = ">=3.8" +files = [ + {file = "httpx-0.27.0-py3-none-any.whl", hash = "sha256:71d5465162c13681bff01ad59b2cc68dd838ea1f10e51574bac27103f00c91a5"}, + {file = "httpx-0.27.0.tar.gz", hash = "sha256:a0cb88a46f32dc874e04ee956e4c2764aba2aa228f650b06788ba6bda2962ab5"}, +] + +[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.*)"] + [[package]] name = "identify" version = "2.6.0" @@ -804,6 +1083,41 @@ qtconsole = ["qtconsole"] test = ["pytest (<7.1)", "pytest-asyncio", "testpath"] test-extra = ["curio", "matplotlib (!=3.2.0)", "nbformat", "numpy (>=1.21)", "pandas", "pytest (<7.1)", "pytest-asyncio", "testpath", "trio"] +[[package]] +name = "ipywidgets" +version = "8.1.3" +description = "Jupyter interactive widgets" +optional = false +python-versions = ">=3.7" +files = [ + {file = "ipywidgets-8.1.3-py3-none-any.whl", hash = "sha256:efafd18f7a142248f7cb0ba890a68b96abd4d6e88ddbda483c9130d12667eaf2"}, + {file = "ipywidgets-8.1.3.tar.gz", hash = "sha256:f5f9eeaae082b1823ce9eac2575272952f40d748893972956dc09700a6392d9c"}, +] + +[package.dependencies] +comm = ">=0.1.3" +ipython = ">=6.1.0" +jupyterlab-widgets = ">=3.0.11,<3.1.0" +traitlets = ">=4.3.1" +widgetsnbextension = ">=4.0.11,<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 = "jedi" version = "0.19.1" @@ -823,6 +1137,111 @@ docs = ["Jinja2 (==2.11.3)", "MarkupSafe (==1.1.1)", "Pygments (==2.8.1)", "alab 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" +description = "A very fast and expressive template engine." +optional = false +python-versions = ">=3.7" +files = [ + {file = "jinja2-3.1.4-py3-none-any.whl", hash = "sha256:bc5dd2abb727a5319567b7a813e6a2e7318c39f4f487cfe6c89c6f9c7d25197d"}, + {file = "jinja2-3.1.4.tar.gz", hash = "sha256:4a3aee7acbbe7303aede8e9648d13b8bf88a429282aa6122a993f0ac800cb369"}, +] + +[package.dependencies] +MarkupSafe = ">=2.0" + +[package.extras] +i18n = ["Babel (>=2.7)"] + +[[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" +description = "An implementation of JSON Schema validation for Python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "jsonschema-4.23.0-py3-none-any.whl", hash = "sha256:fbadb6f8b144a8f8cf9f0b89ba94501d143e50411a1278633f56a7acf7fd5566"}, + {file = "jsonschema-4.23.0.tar.gz", hash = "sha256:d71497fef26351a33265337fa77ffeb82423f3ea21283cd9467bb03999266bc4"}, +] + +[package.dependencies] +attrs = ">=22.2.0" +fqdn = {version = "*", optional = true, markers = "extra == \"format-nongpl\""} +idna = {version = "*", optional = true, markers = "extra == \"format-nongpl\""} +importlib-resources = {version = ">=1.4.0", markers = "python_version < \"3.9\""} +isoduration = {version = "*", optional = true, markers = "extra == \"format-nongpl\""} +jsonpointer = {version = ">1.13", optional = true, markers = "extra == \"format-nongpl\""} +jsonschema-specifications = ">=2023.03.6" +pkgutil-resolve-name = {version = ">=1.3.10", markers = "python_version < \"3.9\""} +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)"] +format-nongpl = ["fqdn", "idna", "isoduration", "jsonpointer (>1.13)", "rfc3339-validator", "rfc3986-validator (>0.1.0)", "uri-template", "webcolors (>=24.6.0)"] + +[[package]] +name = "jsonschema-specifications" +version = "2023.12.1" +description = "The JSON Schema meta-schemas and vocabularies, exposed as a Registry" +optional = false +python-versions = ">=3.8" +files = [ + {file = "jsonschema_specifications-2023.12.1-py3-none-any.whl", hash = "sha256:87e4fdf3a94858b8a2ba2778d9ba57d8a9cafca7c7489c46ba0d30a8bc6a9c3c"}, + {file = "jsonschema_specifications-2023.12.1.tar.gz", hash = "sha256:48a76787b3e70f5ed53f1160d2b81f586e4ca6d1548c5de7085d1682674764cc"}, +] + +[package.dependencies] +importlib-resources = {version = ">=1.4.0", markers = "python_version < \"3.9\""} +referencing = ">=0.31.0" + +[[package]] +name = "jupyter" +version = "1.0.0" +description = "Jupyter metapackage. Install all the Jupyter components in one go." +optional = false +python-versions = "*" +files = [ + {file = "jupyter-1.0.0-py2.py3-none-any.whl", hash = "sha256:5b290f93b98ffbc21c0c7e749f054b3267782166d72fa5e3ed1ed4eaf34a2b78"}, + {file = "jupyter-1.0.0.tar.gz", hash = "sha256:d9dc4b3318f310e34c82951ea5d6683f67bed7def4b259fafbfe4f1beb1d8e5f"}, + {file = "jupyter-1.0.0.zip", hash = "sha256:3e1f86076bbb7c8c207829390305a2b1fe836d471ed54be66a3b8c41e7f46cc7"}, +] + +[package.dependencies] +ipykernel = "*" +ipywidgets = "*" +jupyter-console = "*" +nbconvert = "*" +notebook = "*" +qtconsole = "*" + [[package]] name = "jupyter-client" version = "8.6.2" @@ -846,6 +1265,30 @@ traitlets = ">=5.3" 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" @@ -853,18 +1296,197 @@ description = "Jupyter core package. A base package on which Jupyter projects re 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"}, + {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] +importlib-metadata = {version = ">=4.8.3", markers = "python_version < \"3.10\""} +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.4" +description = "JupyterLab computational environment" +optional = false +python-versions = ">=3.8" +files = [ + {file = "jupyterlab-4.2.4-py3-none-any.whl", hash = "sha256:807a7ec73637744f879e112060d4b9d9ebe028033b7a429b2d1f4fc523d00245"}, + {file = "jupyterlab-4.2.4.tar.gz", hash = "sha256:343a979fb9582fd08c8511823e320703281cd072a0049bcdafdc7afeda7f2537"}, +] + +[package.dependencies] +async-lru = ">=1.0.0" +httpx = ">=0.25.0" +importlib-metadata = {version = ">=4.8.3", markers = "python_version < \"3.10\""} +importlib-resources = {version = ">=1.4", markers = "python_version < \"3.9\""} +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] -platformdirs = ">=2.5" -pywin32 = {version = ">=300", markers = "sys_platform == \"win32\" and platform_python_implementation != \"PyPy\""} -traitlets = ">=5.3" +babel = ">=2.10" +importlib-metadata = {version = ">=4.8.3", markers = "python_version < \"3.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 = ["myst-parser", "pydata-sphinx-theme", "sphinx-autodoc-typehints", "sphinxcontrib-github-alt", "sphinxcontrib-spelling", "traitlets"] -test = ["ipykernel", "pre-commit", "pytest (<8)", "pytest-cov", "pytest-timeout"] +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.11" +description = "Jupyter interactive widgets for JupyterLab" +optional = false +python-versions = ">=3.7" +files = [ + {file = "jupyterlab_widgets-3.0.11-py3-none-any.whl", hash = "sha256:78287fd86d20744ace330a61625024cf5521e1c012a352ddc0a3cdc2348becd0"}, + {file = "jupyterlab_widgets-3.0.11.tar.gz", hash = "sha256:dd5ac679593c969af29c9bed054c24f26842baa51352114736756bc035deee27"}, +] [[package]] name = "kiwisolver" @@ -979,6 +1601,75 @@ files = [ {file = "kiwisolver-1.4.5.tar.gz", hash = "sha256:e57e563a57fb22a142da34f38acc2fc1a5c864bc29ca1517a88abc963e60d6ec"}, ] +[[package]] +name = "markupsafe" +version = "2.1.5" +description = "Safely add untrusted strings to HTML/XML markup." +optional = false +python-versions = ">=3.7" +files = [ + {file = "MarkupSafe-2.1.5-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:a17a92de5231666cfbe003f0e4b9b3a7ae3afb1ec2845aadc2bacc93ff85febc"}, + {file = "MarkupSafe-2.1.5-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:72b6be590cc35924b02c78ef34b467da4ba07e4e0f0454a2c5907f473fc50ce5"}, + {file = "MarkupSafe-2.1.5-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e61659ba32cf2cf1481e575d0462554625196a1f2fc06a1c777d3f48e8865d46"}, + {file = "MarkupSafe-2.1.5-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2174c595a0d73a3080ca3257b40096db99799265e1c27cc5a610743acd86d62f"}, + {file = "MarkupSafe-2.1.5-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ae2ad8ae6ebee9d2d94b17fb62763125f3f374c25618198f40cbb8b525411900"}, + {file = "MarkupSafe-2.1.5-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:075202fa5b72c86ad32dc7d0b56024ebdbcf2048c0ba09f1cde31bfdd57bcfff"}, + {file = "MarkupSafe-2.1.5-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:598e3276b64aff0e7b3451b72e94fa3c238d452e7ddcd893c3ab324717456bad"}, + {file = "MarkupSafe-2.1.5-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:fce659a462a1be54d2ffcacea5e3ba2d74daa74f30f5f143fe0c58636e355fdd"}, + {file = "MarkupSafe-2.1.5-cp310-cp310-win32.whl", hash = "sha256:d9fad5155d72433c921b782e58892377c44bd6252b5af2f67f16b194987338a4"}, + {file = "MarkupSafe-2.1.5-cp310-cp310-win_amd64.whl", hash = "sha256:bf50cd79a75d181c9181df03572cdce0fbb75cc353bc350712073108cba98de5"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:629ddd2ca402ae6dbedfceeba9c46d5f7b2a61d9749597d4307f943ef198fc1f"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:5b7b716f97b52c5a14bffdf688f971b2d5ef4029127f1ad7a513973cfd818df2"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6ec585f69cec0aa07d945b20805be741395e28ac1627333b1c5b0105962ffced"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b91c037585eba9095565a3556f611e3cbfaa42ca1e865f7b8015fe5c7336d5a5"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7502934a33b54030eaf1194c21c692a534196063db72176b0c4028e140f8f32c"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:0e397ac966fdf721b2c528cf028494e86172b4feba51d65f81ffd65c63798f3f"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:c061bb86a71b42465156a3ee7bd58c8c2ceacdbeb95d05a99893e08b8467359a"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:3a57fdd7ce31c7ff06cdfbf31dafa96cc533c21e443d57f5b1ecc6cdc668ec7f"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-win32.whl", hash = "sha256:397081c1a0bfb5124355710fe79478cdbeb39626492b15d399526ae53422b906"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-win_amd64.whl", hash = "sha256:2b7c57a4dfc4f16f7142221afe5ba4e093e09e728ca65c51f5620c9aaeb9a617"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:8dec4936e9c3100156f8a2dc89c4b88d5c435175ff03413b443469c7c8c5f4d1"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:3c6b973f22eb18a789b1460b4b91bf04ae3f0c4234a0a6aa6b0a92f6f7b951d4"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ac07bad82163452a6884fe8fa0963fb98c2346ba78d779ec06bd7a6262132aee"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f5dfb42c4604dddc8e4305050aa6deb084540643ed5804d7455b5df8fe16f5e5"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ea3d8a3d18833cf4304cd2fc9cbb1efe188ca9b5efef2bdac7adc20594a0e46b"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:d050b3361367a06d752db6ead6e7edeb0009be66bc3bae0ee9d97fb326badc2a"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:bec0a414d016ac1a18862a519e54b2fd0fc8bbfd6890376898a6c0891dd82e9f"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:58c98fee265677f63a4385256a6d7683ab1832f3ddd1e66fe948d5880c21a169"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-win32.whl", hash = "sha256:8590b4ae07a35970728874632fed7bd57b26b0102df2d2b233b6d9d82f6c62ad"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-win_amd64.whl", hash = "sha256:823b65d8706e32ad2df51ed89496147a42a2a6e01c13cfb6ffb8b1e92bc910bb"}, + {file = "MarkupSafe-2.1.5-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:c8b29db45f8fe46ad280a7294f5c3ec36dbac9491f2d1c17345be8e69cc5928f"}, + {file = "MarkupSafe-2.1.5-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ec6a563cff360b50eed26f13adc43e61bc0c04d94b8be985e6fb24b81f6dcfdf"}, + {file = "MarkupSafe-2.1.5-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a549b9c31bec33820e885335b451286e2969a2d9e24879f83fe904a5ce59d70a"}, + {file = "MarkupSafe-2.1.5-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4f11aa001c540f62c6166c7726f71f7573b52c68c31f014c25cc7901deea0b52"}, + {file = "MarkupSafe-2.1.5-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:7b2e5a267c855eea6b4283940daa6e88a285f5f2a67f2220203786dfa59b37e9"}, + {file = "MarkupSafe-2.1.5-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:2d2d793e36e230fd32babe143b04cec8a8b3eb8a3122d2aceb4a371e6b09b8df"}, + {file = "MarkupSafe-2.1.5-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:ce409136744f6521e39fd8e2a24c53fa18ad67aa5bc7c2cf83645cce5b5c4e50"}, + {file = "MarkupSafe-2.1.5-cp37-cp37m-win32.whl", hash = "sha256:4096e9de5c6fdf43fb4f04c26fb114f61ef0bf2e5604b6ee3019d51b69e8c371"}, + {file = "MarkupSafe-2.1.5-cp37-cp37m-win_amd64.whl", hash = "sha256:4275d846e41ecefa46e2015117a9f491e57a71ddd59bbead77e904dc02b1bed2"}, + {file = "MarkupSafe-2.1.5-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:656f7526c69fac7f600bd1f400991cc282b417d17539a1b228617081106feb4a"}, + {file = "MarkupSafe-2.1.5-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:97cafb1f3cbcd3fd2b6fbfb99ae11cdb14deea0736fc2b0952ee177f2b813a46"}, + {file = "MarkupSafe-2.1.5-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1f3fbcb7ef1f16e48246f704ab79d79da8a46891e2da03f8783a5b6fa41a9532"}, + {file = "MarkupSafe-2.1.5-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fa9db3f79de01457b03d4f01b34cf91bc0048eb2c3846ff26f66687c2f6d16ab"}, + {file = "MarkupSafe-2.1.5-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ffee1f21e5ef0d712f9033568f8344d5da8cc2869dbd08d87c84656e6a2d2f68"}, + {file = "MarkupSafe-2.1.5-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:5dedb4db619ba5a2787a94d877bc8ffc0566f92a01c0ef214865e54ecc9ee5e0"}, + {file = "MarkupSafe-2.1.5-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:30b600cf0a7ac9234b2638fbc0fb6158ba5bdcdf46aeb631ead21248b9affbc4"}, + {file = "MarkupSafe-2.1.5-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:8dd717634f5a044f860435c1d8c16a270ddf0ef8588d4887037c5028b859b0c3"}, + {file = "MarkupSafe-2.1.5-cp38-cp38-win32.whl", hash = "sha256:daa4ee5a243f0f20d528d939d06670a298dd39b1ad5f8a72a4275124a7819eff"}, + {file = "MarkupSafe-2.1.5-cp38-cp38-win_amd64.whl", hash = "sha256:619bc166c4f2de5caa5a633b8b7326fbe98e0ccbfacabd87268a2b15ff73a029"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:7a68b554d356a91cce1236aa7682dc01df0edba8d043fd1ce607c49dd3c1edcf"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:db0b55e0f3cc0be60c1f19efdde9a637c32740486004f20d1cff53c3c0ece4d2"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3e53af139f8579a6d5f7b76549125f0d94d7e630761a2111bc431fd820e163b8"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:17b950fccb810b3293638215058e432159d2b71005c74371d784862b7e4683f3"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4c31f53cdae6ecfa91a77820e8b151dba54ab528ba65dfd235c80b086d68a465"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:bff1b4290a66b490a2f4719358c0cdcd9bafb6b8f061e45c7a2460866bf50c2e"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:bc1667f8b83f48511b94671e0e441401371dfd0f0a795c7daa4a3cd1dde55bea"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:5049256f536511ee3f7e1b3f87d1d1209d327e818e6ae1365e8653d7e3abb6a6"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-win32.whl", hash = "sha256:00e046b6dd71aa03a41079792f8473dc494d564611a8f89bbbd7cb93295ebdcf"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-win_amd64.whl", hash = "sha256:fa173ec60341d6bb97a89f5ea19c85c5643c1e7dedebc22f5181eb73573142c5"}, + {file = "MarkupSafe-2.1.5.tar.gz", hash = "sha256:d283d37a890ba4c1ae73ffadf8046435c76e7bc2247bbb63c00bd1a709c6544b"}, +] + [[package]] name = "matplotlib" version = "3.7.5" @@ -1114,6 +1805,98 @@ files = [ [package.dependencies] traitlets = "*" +[[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 = "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 = "*" +importlib-metadata = {version = ">=3.6", markers = "python_version < \"3.10\""} +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" @@ -1136,6 +1919,46 @@ files = [ {file = "nodeenv-1.9.1.tar.gz", hash = "sha256:6ec12890a2dab7946721edbfbcd91f3319c6ccc9aec47be7c7e6b7011ee6645f"}, ] +[[package]] +name = "notebook" +version = "7.2.1" +description = "Jupyter Notebook - A web-based notebook environment for interactive computing" +optional = false +python-versions = ">=3.8" +files = [ + {file = "notebook-7.2.1-py3-none-any.whl", hash = "sha256:f45489a3995746f2195a137e0773e2130960b51c9ac3ce257dbc2705aab3a6ca"}, + {file = "notebook-7.2.1.tar.gz", hash = "sha256:4287b6da59740b32173d01d641f763d292f49c30e7a51b89c46ba8473126341e"}, +] + +[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.24.4" @@ -1227,6 +2050,17 @@ files = [ {file = "numpy-2.0.0.tar.gz", hash = "sha256:cf5d1c9e6837f8af9f92b6bd3e86d513cdc11f60fd62185cc49ec7d1aba34864"}, ] +[[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" @@ -1374,6 +2208,17 @@ 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" @@ -1511,6 +2356,17 @@ tests = ["check-manifest", "coverage", "defusedxml", "markdown2", "olefile", "pa typing = ["typing-extensions"] xmp = ["defusedxml"] +[[package]] +name = "pkgutil-resolve-name" +version = "1.3.10" +description = "Resolve a name to an object." +optional = false +python-versions = ">=3.6" +files = [ + {file = "pkgutil_resolve_name-1.3.10-py3-none-any.whl", hash = "sha256:ca27cc078d25c5ad71a9de0a7a330146c4e014c2462d9af19c6b828280649c5e"}, + {file = "pkgutil_resolve_name-1.3.10.tar.gz", hash = "sha256:357d6c9e6a755653cfd78893817c0853af365dd51ec97f3d358a819373bbd174"}, +] + [[package]] name = "platformdirs" version = "4.2.2" @@ -1560,6 +2416,20 @@ nodeenv = ">=0.11.1" pyyaml = ">=5.1" virtualenv = ">=20.10.0" +[[package]] +name = "prometheus-client" +version = "0.20.0" +description = "Python client for the Prometheus monitoring system." +optional = false +python-versions = ">=3.8" +files = [ + {file = "prometheus_client-0.20.0-py3-none-any.whl", hash = "sha256:cde524a85bce83ca359cc837f28b8c0db5cac7aa653a588fd7e84ba061c329e7"}, + {file = "prometheus_client-0.20.0.tar.gz", hash = "sha256:287629d00b147a32dcb2be0b9df905da599b2d82f80377083ec8463309a4bb89"}, +] + +[package.extras] +twisted = ["twisted"] + [[package]] name = "prompt-toolkit" version = "3.0.47" @@ -1669,13 +2539,13 @@ diagrams = ["jinja2", "railroad-diagrams"] [[package]] name = "pytest" -version = "8.2.2" +version = "8.3.1" description = "pytest: simple powerful testing with Python" optional = false python-versions = ">=3.8" files = [ - {file = "pytest-8.2.2-py3-none-any.whl", hash = "sha256:c434598117762e2bd304e526244f67bf66bbd7b5d6cf22138be51ff661980343"}, - {file = "pytest-8.2.2.tar.gz", hash = "sha256:de4bb8104e201939ccdc688b27a89a7be2079b22e2bd2b07f806b6ba71117977"}, + {file = "pytest-8.3.1-py3-none-any.whl", hash = "sha256:e9600ccf4f563976e2c99fa02c7624ab938296551f280835ee6516df8bc4ae8c"}, + {file = "pytest-8.3.1.tar.gz", hash = "sha256:7e8e5c5abd6e93cb1cc151f23e57adc31fcf8cfd2a3ff2da63e23f732de35db6"}, ] [package.dependencies] @@ -1683,7 +2553,7 @@ colorama = {version = "*", markers = "sys_platform == \"win32\""} exceptiongroup = {version = ">=1.0.0rc8", markers = "python_version < \"3.11\""} iniconfig = "*" packaging = "*" -pluggy = ">=1.5,<2.0" +pluggy = ">=1.5,<2" tomli = {version = ">=1", markers = "python_version < \"3.11\""} [package.extras] @@ -1752,6 +2622,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.1" @@ -1786,6 +2667,21 @@ files = [ {file = "pywin32-306-cp39-cp39-win_amd64.whl", hash = "sha256:39b61c15272833b5c329a2989999dcae836b1eed650252ab1b7bfbe1d59f30f4"}, ] +[[package]] +name = "pywinpty" +version = "2.0.13" +description = "Pseudo terminal support for Windows from Python." +optional = false +python-versions = ">=3.8" +files = [ + {file = "pywinpty-2.0.13-cp310-none-win_amd64.whl", hash = "sha256:697bff211fb5a6508fee2dc6ff174ce03f34a9a233df9d8b5fe9c8ce4d5eaf56"}, + {file = "pywinpty-2.0.13-cp311-none-win_amd64.whl", hash = "sha256:b96fb14698db1284db84ca38c79f15b4cfdc3172065b5137383910567591fa99"}, + {file = "pywinpty-2.0.13-cp312-none-win_amd64.whl", hash = "sha256:2fd876b82ca750bb1333236ce98488c1be96b08f4f7647cfdf4129dfad83c2d4"}, + {file = "pywinpty-2.0.13-cp38-none-win_amd64.whl", hash = "sha256:61d420c2116c0212808d31625611b51caf621fe67f8a6377e2e8b617ea1c1f7d"}, + {file = "pywinpty-2.0.13-cp39-none-win_amd64.whl", hash = "sha256:71cb613a9ee24174730ac7ae439fd179ca34ccb8c5349e8d7b72ab5dea2c6f4b"}, + {file = "pywinpty-2.0.13.tar.gz", hash = "sha256:c34e32351a3313ddd0d7da23d27f835c860d32fe4ac814d372a3ea9594f41dde"}, +] + [[package]] name = "pyyaml" version = "6.0.1" @@ -1946,6 +2842,63 @@ files = [ [package.dependencies] cffi = {version = "*", markers = "implementation_name == \"pypy\""} +[[package]] +name = "qtconsole" +version = "5.5.2" +description = "Jupyter Qt console" +optional = false +python-versions = ">=3.8" +files = [ + {file = "qtconsole-5.5.2-py3-none-any.whl", hash = "sha256:42d745f3d05d36240244a04e1e1ec2a86d5d9b6edb16dbdef582ccb629e87e0b"}, + {file = "qtconsole-5.5.2.tar.gz", hash = "sha256:6b5fb11274b297463706af84dcbbd5c92273b1f619e6d25d08874b0a88516989"}, +] + +[package.dependencies] +ipykernel = ">=4.1" +jupyter-client = ">=4.1" +jupyter-core = "*" +packaging = "*" +pygments = "*" +pyzmq = ">=17.1" +qtpy = ">=2.4.0" +traitlets = "<5.2.1 || >5.2.1,<5.2.2 || >5.2.2" + +[package.extras] +doc = ["Sphinx (>=1.3)"] +test = ["flaky", "pytest", "pytest-qt"] + +[[package]] +name = "qtpy" +version = "2.4.1" +description = "Provides an abstraction layer on top of the various Qt bindings (PyQt5/6 and PySide2/6)." +optional = false +python-versions = ">=3.7" +files = [ + {file = "QtPy-2.4.1-py3-none-any.whl", hash = "sha256:1c1d8c4fa2c884ae742b069151b0abe15b3f70491f3972698c683b8e38de839b"}, + {file = "QtPy-2.4.1.tar.gz", hash = "sha256:a5a15ffd519550a1361bdc56ffc07fda56a6af7292f17c7b395d4083af632987"}, +] + +[package.dependencies] +packaging = "*" + +[package.extras] +test = ["pytest (>=6,!=7.0.0,!=7.0.1)", "pytest-cov (>=3.0.0)", "pytest-qt"] + +[[package]] +name = "referencing" +version = "0.35.1" +description = "JSON Referencing + Python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "referencing-0.35.1-py3-none-any.whl", hash = "sha256:eda6d3234d62814d1c64e305c1331c9a3a6132da475ab6382eaa997b21ee75de"}, + {file = "referencing-0.35.1.tar.gz", hash = "sha256:25b42124a6c8b632a425174f24087783efb348a6f1e0008e63cd4466fedf703c"}, +] + +[package.dependencies] +attrs = ">=22.2.0" +rpds-py = ">=0.7.0" + [[package]] name = "requests" version = "2.32.3" @@ -1967,6 +2920,171 @@ urllib3 = ">=1.21.1,<3" socks = ["PySocks (>=1.5.6,!=1.5.7)"] use-chardet-on-py3 = ["chardet (>=3.0.2,<6)"] +[[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 = "rpds-py" +version = "0.19.0" +description = "Python bindings to Rust's persistent data structures (rpds)" +optional = false +python-versions = ">=3.8" +files = [ + {file = "rpds_py-0.19.0-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:fb37bd599f031f1a6fb9e58ec62864ccf3ad549cf14bac527dbfa97123edcca4"}, + {file = "rpds_py-0.19.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:3384d278df99ec2c6acf701d067147320b864ef6727405d6470838476e44d9e8"}, + {file = "rpds_py-0.19.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e54548e0be3ac117595408fd4ca0ac9278fde89829b0b518be92863b17ff67a2"}, + {file = "rpds_py-0.19.0-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:8eb488ef928cdbc05a27245e52de73c0d7c72a34240ef4d9893fdf65a8c1a955"}, + {file = "rpds_py-0.19.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a5da93debdfe27b2bfc69eefb592e1831d957b9535e0943a0ee8b97996de21b5"}, + {file = "rpds_py-0.19.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:79e205c70afddd41f6ee79a8656aec738492a550247a7af697d5bd1aee14f766"}, + {file = "rpds_py-0.19.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:959179efb3e4a27610e8d54d667c02a9feaa86bbabaf63efa7faa4dfa780d4f1"}, + {file = "rpds_py-0.19.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a6e605bb9edcf010f54f8b6a590dd23a4b40a8cb141255eec2a03db249bc915b"}, + {file = "rpds_py-0.19.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:9133d75dc119a61d1a0ded38fb9ba40a00ef41697cc07adb6ae098c875195a3f"}, + {file = "rpds_py-0.19.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:dd36b712d35e757e28bf2f40a71e8f8a2d43c8b026d881aa0c617b450d6865c9"}, + {file = "rpds_py-0.19.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:354f3a91718489912f2e0fc331c24eaaf6a4565c080e00fbedb6015857c00582"}, + {file = "rpds_py-0.19.0-cp310-none-win32.whl", hash = "sha256:ebcbf356bf5c51afc3290e491d3722b26aaf5b6af3c1c7f6a1b757828a46e336"}, + {file = "rpds_py-0.19.0-cp310-none-win_amd64.whl", hash = "sha256:75a6076289b2df6c8ecb9d13ff79ae0cad1d5fb40af377a5021016d58cd691ec"}, + {file = "rpds_py-0.19.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:6d45080095e585f8c5097897313def60caa2046da202cdb17a01f147fb263b81"}, + {file = "rpds_py-0.19.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c5c9581019c96f865483d031691a5ff1cc455feb4d84fc6920a5ffc48a794d8a"}, + {file = "rpds_py-0.19.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1540d807364c84516417115c38f0119dfec5ea5c0dd9a25332dea60b1d26fc4d"}, + {file = "rpds_py-0.19.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:9e65489222b410f79711dc3d2d5003d2757e30874096b2008d50329ea4d0f88c"}, + {file = "rpds_py-0.19.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9da6f400eeb8c36f72ef6646ea530d6d175a4f77ff2ed8dfd6352842274c1d8b"}, + {file = "rpds_py-0.19.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:37f46bb11858717e0efa7893c0f7055c43b44c103e40e69442db5061cb26ed34"}, + {file = "rpds_py-0.19.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:071d4adc734de562bd11d43bd134330fb6249769b2f66b9310dab7460f4bf714"}, + {file = "rpds_py-0.19.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:9625367c8955e4319049113ea4f8fee0c6c1145192d57946c6ffcd8fe8bf48dd"}, + {file = "rpds_py-0.19.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:e19509145275d46bc4d1e16af0b57a12d227c8253655a46bbd5ec317e941279d"}, + {file = "rpds_py-0.19.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:4d438e4c020d8c39961deaf58f6913b1bf8832d9b6f62ec35bd93e97807e9cbc"}, + {file = "rpds_py-0.19.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:90bf55d9d139e5d127193170f38c584ed3c79e16638890d2e36f23aa1630b952"}, + {file = "rpds_py-0.19.0-cp311-none-win32.whl", hash = "sha256:8d6ad132b1bc13d05ffe5b85e7a01a3998bf3a6302ba594b28d61b8c2cf13aaf"}, + {file = "rpds_py-0.19.0-cp311-none-win_amd64.whl", hash = "sha256:7ec72df7354e6b7f6eb2a17fa6901350018c3a9ad78e48d7b2b54d0412539a67"}, + {file = "rpds_py-0.19.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:5095a7c838a8647c32aa37c3a460d2c48debff7fc26e1136aee60100a8cd8f68"}, + {file = "rpds_py-0.19.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6f2f78ef14077e08856e788fa482107aa602636c16c25bdf59c22ea525a785e9"}, + {file = "rpds_py-0.19.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b7cc6cb44f8636fbf4a934ca72f3e786ba3c9f9ba4f4d74611e7da80684e48d2"}, + {file = "rpds_py-0.19.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:cf902878b4af334a09de7a45badbff0389e7cf8dc2e4dcf5f07125d0b7c2656d"}, + {file = "rpds_py-0.19.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:688aa6b8aa724db1596514751ffb767766e02e5c4a87486ab36b8e1ebc1aedac"}, + {file = "rpds_py-0.19.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:57dbc9167d48e355e2569346b5aa4077f29bf86389c924df25c0a8b9124461fb"}, + {file = "rpds_py-0.19.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3b4cf5a9497874822341c2ebe0d5850fed392034caadc0bad134ab6822c0925b"}, + {file = "rpds_py-0.19.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:8a790d235b9d39c70a466200d506bb33a98e2ee374a9b4eec7a8ac64c2c261fa"}, + {file = "rpds_py-0.19.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1d16089dfa58719c98a1c06f2daceba6d8e3fb9b5d7931af4a990a3c486241cb"}, + {file = "rpds_py-0.19.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:bc9128e74fe94650367fe23f37074f121b9f796cabbd2f928f13e9661837296d"}, + {file = "rpds_py-0.19.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:c8f77e661ffd96ff104bebf7d0f3255b02aa5d5b28326f5408d6284c4a8b3248"}, + {file = "rpds_py-0.19.0-cp312-none-win32.whl", hash = "sha256:5f83689a38e76969327e9b682be5521d87a0c9e5a2e187d2bc6be4765f0d4600"}, + {file = "rpds_py-0.19.0-cp312-none-win_amd64.whl", hash = "sha256:06925c50f86da0596b9c3c64c3837b2481337b83ef3519e5db2701df695453a4"}, + {file = "rpds_py-0.19.0-cp38-cp38-macosx_10_12_x86_64.whl", hash = "sha256:52e466bea6f8f3a44b1234570244b1cff45150f59a4acae3fcc5fd700c2993ca"}, + {file = "rpds_py-0.19.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:e21cc693045fda7f745c790cb687958161ce172ffe3c5719ca1764e752237d16"}, + {file = "rpds_py-0.19.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6b31f059878eb1f5da8b2fd82480cc18bed8dcd7fb8fe68370e2e6285fa86da6"}, + {file = "rpds_py-0.19.0-cp38-cp38-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:1dd46f309e953927dd018567d6a9e2fb84783963650171f6c5fe7e5c41fd5666"}, + {file = "rpds_py-0.19.0-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:34a01a4490e170376cd79258b7f755fa13b1a6c3667e872c8e35051ae857a92b"}, + {file = "rpds_py-0.19.0-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bcf426a8c38eb57f7bf28932e68425ba86def6e756a5b8cb4731d8e62e4e0223"}, + {file = "rpds_py-0.19.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f68eea5df6347d3f1378ce992d86b2af16ad7ff4dcb4a19ccdc23dea901b87fb"}, + {file = "rpds_py-0.19.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:dab8d921b55a28287733263c0e4c7db11b3ee22aee158a4de09f13c93283c62d"}, + {file = "rpds_py-0.19.0-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:6fe87efd7f47266dfc42fe76dae89060038f1d9cb911f89ae7e5084148d1cc08"}, + {file = "rpds_py-0.19.0-cp38-cp38-musllinux_1_2_i686.whl", hash = "sha256:535d4b52524a961d220875688159277f0e9eeeda0ac45e766092bfb54437543f"}, + {file = "rpds_py-0.19.0-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:8b1a94b8afc154fbe36978a511a1f155f9bd97664e4f1f7a374d72e180ceb0ae"}, + {file = "rpds_py-0.19.0-cp38-none-win32.whl", hash = "sha256:7c98298a15d6b90c8f6e3caa6457f4f022423caa5fa1a1ca7a5e9e512bdb77a4"}, + {file = "rpds_py-0.19.0-cp38-none-win_amd64.whl", hash = "sha256:b0da31853ab6e58a11db3205729133ce0df26e6804e93079dee095be3d681dc1"}, + {file = "rpds_py-0.19.0-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:5039e3cef7b3e7a060de468a4a60a60a1f31786da94c6cb054e7a3c75906111c"}, + {file = "rpds_py-0.19.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:ab1932ca6cb8c7499a4d87cb21ccc0d3326f172cfb6a64021a889b591bb3045c"}, + {file = "rpds_py-0.19.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f2afd2164a1e85226fcb6a1da77a5c8896c18bfe08e82e8ceced5181c42d2179"}, + {file = "rpds_py-0.19.0-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b1c30841f5040de47a0046c243fc1b44ddc87d1b12435a43b8edff7e7cb1e0d0"}, + {file = "rpds_py-0.19.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f757f359f30ec7dcebca662a6bd46d1098f8b9fb1fcd661a9e13f2e8ce343ba1"}, + {file = "rpds_py-0.19.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:15e65395a59d2e0e96caf8ee5389ffb4604e980479c32742936ddd7ade914b22"}, + {file = "rpds_py-0.19.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cb0f6eb3a320f24b94d177e62f4074ff438f2ad9d27e75a46221904ef21a7b05"}, + {file = "rpds_py-0.19.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b228e693a2559888790936e20f5f88b6e9f8162c681830eda303bad7517b4d5a"}, + {file = "rpds_py-0.19.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:2575efaa5d949c9f4e2cdbe7d805d02122c16065bfb8d95c129372d65a291a0b"}, + {file = "rpds_py-0.19.0-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:5c872814b77a4e84afa293a1bee08c14daed1068b2bb1cc312edbf020bbbca2b"}, + {file = "rpds_py-0.19.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:850720e1b383df199b8433a20e02b25b72f0fded28bc03c5bd79e2ce7ef050be"}, + {file = "rpds_py-0.19.0-cp39-none-win32.whl", hash = "sha256:ce84a7efa5af9f54c0aa7692c45861c1667080814286cacb9958c07fc50294fb"}, + {file = "rpds_py-0.19.0-cp39-none-win_amd64.whl", hash = "sha256:1c26da90b8d06227d7769f34915913911222d24ce08c0ab2d60b354e2d9c7aff"}, + {file = "rpds_py-0.19.0-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:75969cf900d7be665ccb1622a9aba225cf386bbc9c3bcfeeab9f62b5048f4a07"}, + {file = "rpds_py-0.19.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:8445f23f13339da640d1be8e44e5baf4af97e396882ebbf1692aecd67f67c479"}, + {file = "rpds_py-0.19.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a5a7c1062ef8aea3eda149f08120f10795835fc1c8bc6ad948fb9652a113ca55"}, + {file = "rpds_py-0.19.0-pp310-pypy310_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:462b0c18fbb48fdbf980914a02ee38c423a25fcc4cf40f66bacc95a2d2d73bc8"}, + {file = "rpds_py-0.19.0-pp310-pypy310_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3208f9aea18991ac7f2b39721e947bbd752a1abbe79ad90d9b6a84a74d44409b"}, + {file = "rpds_py-0.19.0-pp310-pypy310_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c3444fe52b82f122d8a99bf66777aed6b858d392b12f4c317da19f8234db4533"}, + {file = "rpds_py-0.19.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:88cb4bac7185a9f0168d38c01d7a00addece9822a52870eee26b8d5b61409213"}, + {file = "rpds_py-0.19.0-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:6b130bd4163c93798a6b9bb96be64a7c43e1cec81126ffa7ffaa106e1fc5cef5"}, + {file = "rpds_py-0.19.0-pp310-pypy310_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:a707b158b4410aefb6b054715545bbb21aaa5d5d0080217290131c49c2124a6e"}, + {file = "rpds_py-0.19.0-pp310-pypy310_pp73-musllinux_1_2_i686.whl", hash = "sha256:dc9ac4659456bde7c567107556ab065801622396b435a3ff213daef27b495388"}, + {file = "rpds_py-0.19.0-pp310-pypy310_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:81ea573aa46d3b6b3d890cd3c0ad82105985e6058a4baed03cf92518081eec8c"}, + {file = "rpds_py-0.19.0-pp38-pypy38_pp73-macosx_10_12_x86_64.whl", hash = "sha256:3f148c3f47f7f29a79c38cc5d020edcb5ca780020fab94dbc21f9af95c463581"}, + {file = "rpds_py-0.19.0-pp38-pypy38_pp73-macosx_11_0_arm64.whl", hash = "sha256:b0906357f90784a66e89ae3eadc2654f36c580a7d65cf63e6a616e4aec3a81be"}, + {file = "rpds_py-0.19.0-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f629ecc2db6a4736b5ba95a8347b0089240d69ad14ac364f557d52ad68cf94b0"}, + {file = "rpds_py-0.19.0-pp38-pypy38_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c6feacd1d178c30e5bc37184526e56740342fd2aa6371a28367bad7908d454fc"}, + {file = "rpds_py-0.19.0-pp38-pypy38_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ae8b6068ee374fdfab63689be0963333aa83b0815ead5d8648389a8ded593378"}, + {file = "rpds_py-0.19.0-pp38-pypy38_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:78d57546bad81e0da13263e4c9ce30e96dcbe720dbff5ada08d2600a3502e526"}, + {file = "rpds_py-0.19.0-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a8b6683a37338818646af718c9ca2a07f89787551057fae57c4ec0446dc6224b"}, + {file = "rpds_py-0.19.0-pp38-pypy38_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:e8481b946792415adc07410420d6fc65a352b45d347b78fec45d8f8f0d7496f0"}, + {file = "rpds_py-0.19.0-pp38-pypy38_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:bec35eb20792ea64c3c57891bc3ca0bedb2884fbac2c8249d9b731447ecde4fa"}, + {file = "rpds_py-0.19.0-pp38-pypy38_pp73-musllinux_1_2_i686.whl", hash = "sha256:aa5476c3e3a402c37779e95f7b4048db2cb5b0ed0b9d006983965e93f40fe05a"}, + {file = "rpds_py-0.19.0-pp38-pypy38_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:19d02c45f2507b489fd4df7b827940f1420480b3e2e471e952af4d44a1ea8e34"}, + {file = "rpds_py-0.19.0-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:a3e2fd14c5d49ee1da322672375963f19f32b3d5953f0615b175ff7b9d38daed"}, + {file = "rpds_py-0.19.0-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:93a91c2640645303e874eada51f4f33351b84b351a689d470f8108d0e0694210"}, + {file = "rpds_py-0.19.0-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e5b9fc03bf76a94065299d4a2ecd8dfbae4ae8e2e8098bbfa6ab6413ca267709"}, + {file = "rpds_py-0.19.0-pp39-pypy39_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5a4b07cdf3f84310c08c1de2c12ddadbb7a77568bcb16e95489f9c81074322ed"}, + {file = "rpds_py-0.19.0-pp39-pypy39_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ba0ed0dc6763d8bd6e5de5cf0d746d28e706a10b615ea382ac0ab17bb7388633"}, + {file = "rpds_py-0.19.0-pp39-pypy39_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:474bc83233abdcf2124ed3f66230a1c8435896046caa4b0b5ab6013c640803cc"}, + {file = "rpds_py-0.19.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:329c719d31362355a96b435f4653e3b4b061fcc9eba9f91dd40804ca637d914e"}, + {file = "rpds_py-0.19.0-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:ef9101f3f7b59043a34f1dccbb385ca760467590951952d6701df0da9893ca0c"}, + {file = "rpds_py-0.19.0-pp39-pypy39_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:0121803b0f424ee2109d6e1f27db45b166ebaa4b32ff47d6aa225642636cd834"}, + {file = "rpds_py-0.19.0-pp39-pypy39_pp73-musllinux_1_2_i686.whl", hash = "sha256:8344127403dea42f5970adccf6c5957a71a47f522171fafaf4c6ddb41b61703a"}, + {file = "rpds_py-0.19.0-pp39-pypy39_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:443cec402ddd650bb2b885113e1dcedb22b1175c6be223b14246a714b61cd521"}, + {file = "rpds_py-0.19.0.tar.gz", hash = "sha256:4fdc9afadbeb393b4bbbad75481e0ea78e4469f2e1d713a90811700830b553a9"}, +] + +[[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 = "71.0.4" +description = "Easily download, build, install, upgrade, and uninstall Python packages" +optional = false +python-versions = ">=3.8" +files = [ + {file = "setuptools-71.0.4-py3-none-any.whl", hash = "sha256:ed2feca703be3bdbd94e6bb17365d91c6935c6b2a8d0bb09b66a2c435ba0b1a5"}, + {file = "setuptools-71.0.4.tar.gz", hash = "sha256:48297e5d393a62b7cb2a10b8f76c63a73af933bd809c9e0d0d6352a1a0135dd8"}, +] + +[package.extras] +core = ["importlib-metadata (>=6)", "importlib-resources (>=5.10.2)", "jaraco.text (>=3.7)", "more-itertools (>=8.8)", "ordered-set (>=3.1.1)", "packaging (>=24)", "platformdirs (>=2.6.2)", "tomli (>=2.0.1)", "wheel (>=0.43.0)"] +doc = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "pygments-github-lexers (==0.0.5)", "pyproject-hooks (!=1.1)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-favicon", "sphinx-inline-tabs", "sphinx-lint", "sphinx-notfound-page (>=1,<2)", "sphinx-reredirects", "sphinxcontrib-towncrier"] +test = ["build[virtualenv] (>=1.0.3)", "filelock (>=3.4.0)", "importlib-metadata", "ini2toml[lite] (>=0.14)", "jaraco.develop (>=7.21)", "jaraco.envs (>=2.2)", "jaraco.path (>=3.2.0)", "jaraco.test", "mypy (==1.10.0)", "packaging (>=23.2)", "pip (>=19.1)", "pyproject-hooks (!=1.1)", "pytest (>=6,!=8.1.*)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-home (>=0.5)", "pytest-mypy", "pytest-perf", "pytest-ruff (<0.4)", "pytest-ruff (>=0.2.1)", "pytest-ruff (>=0.3.2)", "pytest-subprocess", "pytest-timeout", "pytest-xdist (>=3)", "tomli", "tomli-w (>=1.0.0)", "virtualenv (>=13.0.0)", "wheel"] + [[package]] name = "six" version = "1.16.0" @@ -1978,6 +3096,28 @@ files = [ {file = "six-1.16.0.tar.gz", hash = "sha256:1e61c37477a1626458e36f7b1d82aa5c9b094fa4802892072e49de9c60c4c926"}, ] +[[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.5" +description = "A modern CSS selector implementation for Beautiful Soup." +optional = false +python-versions = ">=3.8" +files = [ + {file = "soupsieve-2.5-py3-none-any.whl", hash = "sha256:eaa337ff55a1579b6549dc679565eac1e3d000563bcb1c8ab0d0fefbc0c2cdc7"}, + {file = "soupsieve-2.5.tar.gz", hash = "sha256:5663d5a7b3bfaeee0bc4372e7fc48f9cff4940b3eec54a6451cc5299f1097690"}, +] + [[package]] name = "stack-data" version = "0.6.3" @@ -2017,6 +3157,45 @@ xls = ["xlrd", "xlwt"] xlsx = ["openpyxl (>=2.6.0)"] yaml = ["pyyaml"] +[[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 = "tinycss2" +version = "1.3.0" +description = "A tiny CSS parser" +optional = false +python-versions = ">=3.8" +files = [ + {file = "tinycss2-1.3.0-py3-none-any.whl", hash = "sha256:54a8dbdffb334d536851be0226030e9505965bb2f30f21a4a82c55fb2a80fae7"}, + {file = "tinycss2-1.3.0.tar.gz", hash = "sha256:152f9acabd296a8375fbca5b84c961ff95971fcfc32e79550c8df8e29118c54d"}, +] + +[package.dependencies] +webencodings = ">=0.4" + +[package.extras] +doc = ["sphinx", "sphinx_rtd_theme"] +test = ["pytest", "ruff"] + [[package]] name = "tomli" version = "2.0.1" @@ -2063,6 +3242,17 @@ files = [ 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.20240316" +description = "Typing stubs for python-dateutil" +optional = false +python-versions = ">=3.8" +files = [ + {file = "types-python-dateutil-2.9.0.20240316.tar.gz", hash = "sha256:5d2f2e240b86905e40944dd787db6da9263f0deabef1076ddaed797351ec0202"}, + {file = "types_python_dateutil-2.9.0.20240316-py3-none-any.whl", hash = "sha256:6b8cb66d960771ce5ff974e9dd45e38facb81718cc1e208b10b1baccbfdbee3b"}, +] + [[package]] name = "typing-extensions" version = "4.12.2" @@ -2085,6 +3275,20 @@ files = [ {file = "tzdata-2024.1.tar.gz", hash = "sha256:2674120f8d891909751c38abcdfd386ac0a5a1127954fbc332af6b5ceae07efd"}, ] +[[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.2" @@ -2133,6 +3337,59 @@ files = [ {file = "wcwidth-0.2.13.tar.gz", hash = "sha256:72ea0c06399eb286d978fdedb6923a9eb47e1c486ce63e9b4e64fc18303972b5"}, ] +[[package]] +name = "webcolors" +version = "24.6.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.6.0-py3-none-any.whl", hash = "sha256:8cf5bc7e28defd1d48b9e83d5fc30741328305a8195c29a8e668fa45586568a1"}, + {file = "webcolors-24.6.0.tar.gz", hash = "sha256:1d160d1de46b3e81e58d0a280d0c78b467dc80f47294b91b1ad8029d2cedb55b"}, +] + +[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 = 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.11" +description = "Jupyter interactive widgets for Jupyter Notebook" +optional = false +python-versions = ">=3.7" +files = [ + {file = "widgetsnbextension-4.0.11-py3-none-any.whl", hash = "sha256:55d4d6949d100e0d08b94948a42efc3ed6dfdc0e9468b2c4b128c9a2ce3a7a36"}, + {file = "widgetsnbextension-4.0.11.tar.gz", hash = "sha256:8b22a8f1910bfd188e596fe7fc05dcbd87e810c8a4ba010bdb3da86637398474"}, +] + [[package]] name = "zipp" version = "3.19.2" @@ -2151,4 +3408,4 @@ test = ["big-O", "importlib-resources", "jaraco.functools", "jaraco.itertools", [metadata] lock-version = "2.0" python-versions = "^3.8.1" -content-hash = "926e30d176fadc68279fae7e486079b3301a9ea5bc3cba473d0ef1d52042d185" +content-hash = "144b9804ec56a5a4a59947d1e42743ad7f04e62e3822a136c4d85765197e9008" diff --git a/pyproject.toml b/pyproject.toml index 89bd096..92d5f58 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [tool.poetry] name = "btc-cycles" -version = "0.3.2" +version = "0.3.3" description = "Track Bitcoin price over halving cycles" authors = ["giocaizzi "] license = "MIT" @@ -27,6 +27,8 @@ ipykernel = "^6.29.4" python-dotenv = "^1.0.1" pytest-mock = "^3.14" pre-commit = { version = "^3.7.1", python = ">=3.9,<4.0.0" } +nbconvert = "^7.16.4" +jupyter = "^1.0.0" [tool.pytest.ini_options] testpaths = ["tests"] diff --git a/temp/cmc.ipynb b/temp/cmc.ipynb deleted file mode 100644 index e330204..0000000 --- a/temp/cmc.ipynb +++ /dev/null @@ -1,100 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "%load_ext autoreload\n", - "%autoreload 2" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "True" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from btc_cycles.core.sources.cmc import CoinMarketCap\n", - "import pandas as pd\n", - "import os\n", - "from dotenv import load_dotenv\n", - "\n", - "load_dotenv()" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "cmc = CoinMarketCap(os.getenv(\"CMC_API_KEY\"))" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'status': {'timestamp': '2024-06-01T18:13:27.467Z',\n", - " 'error_code': 1006,\n", - " 'error_message': \"Your API Key subscription plan doesn't support this endpoint.\",\n", - " 'elapsed': 0,\n", - " 'credit_count': 0}}" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "cmc.get_historical_data(\"BTC\", \"2013-01-01\", \"2021-01-01\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "btc", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.12.3" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -}