diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 00db357..c9e275f 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -5,6 +5,7 @@ on: paths: # Changes to source code - hobj/** + - test/**.py # Changes to workflows - .github/workflows/ci.yml # Changes to project/dependency metadata diff --git a/examples/documentation.ipynb b/examples/documentation.ipynb new file mode 100644 index 0000000..91912b4 --- /dev/null +++ b/examples/documentation.ipynb @@ -0,0 +1,690 @@ +{ + "cells": [ + { + "cell_type": "code", + "id": "initial_id", + "metadata": { + "collapsed": true, + "ExecuteTime": { + "end_time": "2026-03-26T22:12:09.366306Z", + "start_time": "2026-03-26T22:12:08.985875Z" + } + }, + "source": "import hobj", + "outputs": [], + "execution_count": 1 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2026-03-26T22:14:09.088796Z", + "start_time": "2026-03-26T22:14:08.689507Z" + } + }, + "cell_type": "code", + "source": [ + "df_highvar_behavior = hobj.load_highvar_behavior()\n", + "df_highvar_behavior\n" + ], + "id": "b3d7df3ce4bda73c", + "outputs": [ + { + "data": { + "text/plain": [ + " trial assignment_id \\\n", + "156000 0 3018Q3ZVOJ00HY15URPTWYSDSTCARE \n", + "156001 1 3018Q3ZVOJ00HY15URPTWYSDSTCARE \n", + "156002 2 3018Q3ZVOJ00HY15URPTWYSDSTCARE \n", + "156003 3 3018Q3ZVOJ00HY15URPTWYSDSTCARE \n", + "156004 4 3018Q3ZVOJ00HY15URPTWYSDSTCARE \n", + "... ... ... \n", + "317194 95 3ZY8KE4ISKDKXLP3S7RPNVWLITLVQY \n", + "317195 96 3ZY8KE4ISKDKXLP3S7RPNVWLITLVQY \n", + "317196 97 3ZY8KE4ISKDKXLP3S7RPNVWLITLVQY \n", + "317197 98 3ZY8KE4ISKDKXLP3S7RPNVWLITLVQY \n", + "317198 99 3ZY8KE4ISKDKXLP3S7RPNVWLITLVQY \n", + "\n", + " worker_id \\\n", + "156000 cab9074c252435e4079d81051102452d8b585ea1a11a6b... \n", + "156001 cab9074c252435e4079d81051102452d8b585ea1a11a6b... \n", + "156002 cab9074c252435e4079d81051102452d8b585ea1a11a6b... \n", + "156003 cab9074c252435e4079d81051102452d8b585ea1a11a6b... \n", + "156004 cab9074c252435e4079d81051102452d8b585ea1a11a6b... \n", + "... ... \n", + "317194 50320c2ab5b97e8ad2694b2b333c6fb3e7bdaa1ba648e8... \n", + "317195 50320c2ab5b97e8ad2694b2b333c6fb3e7bdaa1ba648e8... \n", + "317196 50320c2ab5b97e8ad2694b2b333c6fb3e7bdaa1ba648e8... \n", + "317197 50320c2ab5b97e8ad2694b2b333c6fb3e7bdaa1ba648e8... \n", + "317198 50320c2ab5b97e8ad2694b2b333c6fb3e7bdaa1ba648e8... \n", + "\n", + " subtask image_id \\\n", + "156000 MutatorObject034,MutatorObject035 MutatorObject035-Image40.png \n", + "156001 MutatorObject034,MutatorObject035 MutatorObject035-Image28.png \n", + "156002 MutatorObject034,MutatorObject035 MutatorObject034-Image65.png \n", + "156003 MutatorObject034,MutatorObject035 MutatorObject034-Image55.png \n", + "156004 MutatorObject034,MutatorObject035 MutatorObject035-Image75.png \n", + "... ... ... \n", + "317194 MutatorObject097,MutatorObject098 MutatorObject097-Image91.png \n", + "317195 MutatorObject097,MutatorObject098 MutatorObject098-Image70.png \n", + "317196 MutatorObject097,MutatorObject098 MutatorObject097-Image05.png \n", + "317197 MutatorObject097,MutatorObject098 MutatorObject097-Image58.png \n", + "317198 MutatorObject097,MutatorObject098 MutatorObject097-Image82.png \n", + "\n", + " trial_type stimulus_duration_msec reaction_time_msec timed_out \\\n", + "156000 main 200 880.0 False \n", + "156001 main 200 1475.0 False \n", + "156002 main 200 1037.0 False \n", + "156003 main 200 922.0 False \n", + "156004 main 200 728.0 False \n", + "... ... ... ... ... \n", + "317194 main 200 289.0 False \n", + "317195 main 200 399.0 False \n", + "317196 main 200 279.0 False \n", + "317197 main 200 441.0 False \n", + "317198 main 200 316.0 False \n", + "\n", + " perf timestamp_start \n", + "156000 True 1639397027 \n", + "156001 False 1639397029 \n", + "156002 True 1639397032 \n", + "156003 True 1639397034 \n", + "156004 True 1639397036 \n", + "... ... ... \n", + "317194 False 1639510528 \n", + "317195 True 1639510529 \n", + "317196 True 1639510530 \n", + "317197 False 1639510531 \n", + "317198 True 1639510532 \n", + "\n", + "[319900 rows x 11 columns]" + ], + "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", + "
trialassignment_idworker_idsubtaskimage_idtrial_typestimulus_duration_msecreaction_time_msectimed_outperftimestamp_start
15600003018Q3ZVOJ00HY15URPTWYSDSTCAREcab9074c252435e4079d81051102452d8b585ea1a11a6b...MutatorObject034,MutatorObject035MutatorObject035-Image40.pngmain200880.0FalseTrue1639397027
15600113018Q3ZVOJ00HY15URPTWYSDSTCAREcab9074c252435e4079d81051102452d8b585ea1a11a6b...MutatorObject034,MutatorObject035MutatorObject035-Image28.pngmain2001475.0FalseFalse1639397029
15600223018Q3ZVOJ00HY15URPTWYSDSTCAREcab9074c252435e4079d81051102452d8b585ea1a11a6b...MutatorObject034,MutatorObject035MutatorObject034-Image65.pngmain2001037.0FalseTrue1639397032
15600333018Q3ZVOJ00HY15URPTWYSDSTCAREcab9074c252435e4079d81051102452d8b585ea1a11a6b...MutatorObject034,MutatorObject035MutatorObject034-Image55.pngmain200922.0FalseTrue1639397034
15600443018Q3ZVOJ00HY15URPTWYSDSTCAREcab9074c252435e4079d81051102452d8b585ea1a11a6b...MutatorObject034,MutatorObject035MutatorObject035-Image75.pngmain200728.0FalseTrue1639397036
....................................
317194953ZY8KE4ISKDKXLP3S7RPNVWLITLVQY50320c2ab5b97e8ad2694b2b333c6fb3e7bdaa1ba648e8...MutatorObject097,MutatorObject098MutatorObject097-Image91.pngmain200289.0FalseFalse1639510528
317195963ZY8KE4ISKDKXLP3S7RPNVWLITLVQY50320c2ab5b97e8ad2694b2b333c6fb3e7bdaa1ba648e8...MutatorObject097,MutatorObject098MutatorObject098-Image70.pngmain200399.0FalseTrue1639510529
317196973ZY8KE4ISKDKXLP3S7RPNVWLITLVQY50320c2ab5b97e8ad2694b2b333c6fb3e7bdaa1ba648e8...MutatorObject097,MutatorObject098MutatorObject097-Image05.pngmain200279.0FalseTrue1639510530
317197983ZY8KE4ISKDKXLP3S7RPNVWLITLVQY50320c2ab5b97e8ad2694b2b333c6fb3e7bdaa1ba648e8...MutatorObject097,MutatorObject098MutatorObject097-Image58.pngmain200441.0FalseFalse1639510531
317198993ZY8KE4ISKDKXLP3S7RPNVWLITLVQY50320c2ab5b97e8ad2694b2b333c6fb3e7bdaa1ba648e8...MutatorObject097,MutatorObject098MutatorObject097-Image82.pngmain200316.0FalseTrue1639510532
\n", + "

319900 rows × 11 columns

\n", + "
" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 9 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2026-03-26T22:14:15.187346Z", + "start_time": "2026-03-26T22:14:15.117739Z" + } + }, + "cell_type": "code", + "source": [ + "df_oneshot_behavior = hobj.load_oneshot_behavior()\n", + "df_oneshot_behavior" + ], + "id": "7746b51438a2b1f4", + "outputs": [ + { + "data": { + "text/plain": [ + " trial assignment_id slot \\\n", + "0 0 3018Q3ZVOJ00HY15URPTWYSD0NIRAX 1 \n", + "1 1 3018Q3ZVOJ00HY15URPTWYSD0NIRAX 1 \n", + "2 2 3018Q3ZVOJ00HY15URPTWYSD0NIRAX 1 \n", + "3 3 3018Q3ZVOJ00HY15URPTWYSD0NIRAX 1 \n", + "4 4 3018Q3ZVOJ00HY15URPTWYSD0NIRAX 1 \n", + "... ... ... ... \n", + "50935 15 3ZWFC4W1UVHVDPID57BLAZ34X3VRFA 4 \n", + "50936 16 3ZWFC4W1UVHVDPID57BLAZ34X3VRFA 4 \n", + "50937 17 3ZWFC4W1UVHVDPID57BLAZ34X3VRFA 4 \n", + "50938 18 3ZWFC4W1UVHVDPID57BLAZ34X3VRFA 4 \n", + "50939 19 3ZWFC4W1UVHVDPID57BLAZ34X3VRFA 4 \n", + "\n", + " worker_id \\\n", + "0 009362951d33e90bceaaf84f4d4373c58ffc464f60ec34... \n", + "1 009362951d33e90bceaaf84f4d4373c58ffc464f60ec34... \n", + "2 009362951d33e90bceaaf84f4d4373c58ffc464f60ec34... \n", + "3 009362951d33e90bceaaf84f4d4373c58ffc464f60ec34... \n", + "4 009362951d33e90bceaaf84f4d4373c58ffc464f60ec34... \n", + "... ... \n", + "50935 e43cc225dbf11ef57616e082e51622e8f1e7d9c9b27b2c... \n", + "50936 e43cc225dbf11ef57616e082e51622e8f1e7d9c9b27b2c... \n", + "50937 e43cc225dbf11ef57616e082e51622e8f1e7d9c9b27b2c... \n", + "50938 e43cc225dbf11ef57616e082e51622e8f1e7d9c9b27b2c... \n", + "50939 e43cc225dbf11ef57616e082e51622e8f1e7d9c9b27b2c... \n", + "\n", + " subtask \\\n", + "0 MutatorOneshotObject24,MutatorOneshotObject29 \n", + "1 MutatorOneshotObject24,MutatorOneshotObject29 \n", + "2 MutatorOneshotObject24,MutatorOneshotObject29 \n", + "3 MutatorOneshotObject24,MutatorOneshotObject29 \n", + "4 MutatorOneshotObject24,MutatorOneshotObject29 \n", + "... ... \n", + "50935 MutatorOneshotObject09,MutatorOneshotObject58 \n", + "50936 MutatorOneshotObject09,MutatorOneshotObject58 \n", + "50937 MutatorOneshotObject09,MutatorOneshotObject58 \n", + "50938 MutatorOneshotObject09,MutatorOneshotObject58 \n", + "50939 MutatorOneshotObject09,MutatorOneshotObject58 \n", + "\n", + " image_id trial_type \\\n", + "0 MutatorOneshotObject29-original.png support \n", + "1 MutatorOneshotObject24-original.png support \n", + "2 MutatorOneshotObject29-original.png support \n", + "3 MutatorOneshotObject29-original.png support \n", + "4 MutatorOneshotObject29-original.png support \n", + "... ... ... \n", + "50935 MutatorOneshotObject58-outplanerotation-135.0-... generalization \n", + "50936 MutatorOneshotObject09-contrast-0.8-0.png generalization \n", + "50937 MutatorOneshotObject09-noise-0.375-0.png generalization \n", + "50938 MutatorOneshotObject58-blur-0.0625-0.png generalization \n", + "50939 MutatorOneshotObject09-original.png catch \n", + "\n", + " stimulus_duration_msec reaction_time_msec timed_out perf \\\n", + "0 200 728.0 False True \n", + "1 200 663.0 False True \n", + "2 200 211.0 False True \n", + "3 200 298.0 False True \n", + "4 200 127.0 False True \n", + "... ... ... ... ... \n", + "50935 200 653.0 False False \n", + "50936 200 296.0 False False \n", + "50937 200 601.0 False True \n", + "50938 200 1535.0 False False \n", + "50939 200 293.0 False True \n", + "\n", + " timestamp_start \n", + "0 1623768767 \n", + "1 1623768770 \n", + "2 1623768772 \n", + "3 1623768773 \n", + "4 1623768775 \n", + "... ... \n", + "50935 1623769458 \n", + "50936 1623769461 \n", + "50937 1623769463 \n", + "50938 1623769464 \n", + "50939 1623769468 \n", + "\n", + "[50940 rows x 12 columns]" + ], + "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", + "
trialassignment_idslotworker_idsubtaskimage_idtrial_typestimulus_duration_msecreaction_time_msectimed_outperftimestamp_start
003018Q3ZVOJ00HY15URPTWYSD0NIRAX1009362951d33e90bceaaf84f4d4373c58ffc464f60ec34...MutatorOneshotObject24,MutatorOneshotObject29MutatorOneshotObject29-original.pngsupport200728.0FalseTrue1623768767
113018Q3ZVOJ00HY15URPTWYSD0NIRAX1009362951d33e90bceaaf84f4d4373c58ffc464f60ec34...MutatorOneshotObject24,MutatorOneshotObject29MutatorOneshotObject24-original.pngsupport200663.0FalseTrue1623768770
223018Q3ZVOJ00HY15URPTWYSD0NIRAX1009362951d33e90bceaaf84f4d4373c58ffc464f60ec34...MutatorOneshotObject24,MutatorOneshotObject29MutatorOneshotObject29-original.pngsupport200211.0FalseTrue1623768772
333018Q3ZVOJ00HY15URPTWYSD0NIRAX1009362951d33e90bceaaf84f4d4373c58ffc464f60ec34...MutatorOneshotObject24,MutatorOneshotObject29MutatorOneshotObject29-original.pngsupport200298.0FalseTrue1623768773
443018Q3ZVOJ00HY15URPTWYSD0NIRAX1009362951d33e90bceaaf84f4d4373c58ffc464f60ec34...MutatorOneshotObject24,MutatorOneshotObject29MutatorOneshotObject29-original.pngsupport200127.0FalseTrue1623768775
.......................................
50935153ZWFC4W1UVHVDPID57BLAZ34X3VRFA4e43cc225dbf11ef57616e082e51622e8f1e7d9c9b27b2c...MutatorOneshotObject09,MutatorOneshotObject58MutatorOneshotObject58-outplanerotation-135.0-...generalization200653.0FalseFalse1623769458
50936163ZWFC4W1UVHVDPID57BLAZ34X3VRFA4e43cc225dbf11ef57616e082e51622e8f1e7d9c9b27b2c...MutatorOneshotObject09,MutatorOneshotObject58MutatorOneshotObject09-contrast-0.8-0.pnggeneralization200296.0FalseFalse1623769461
50937173ZWFC4W1UVHVDPID57BLAZ34X3VRFA4e43cc225dbf11ef57616e082e51622e8f1e7d9c9b27b2c...MutatorOneshotObject09,MutatorOneshotObject58MutatorOneshotObject09-noise-0.375-0.pnggeneralization200601.0FalseTrue1623769463
50938183ZWFC4W1UVHVDPID57BLAZ34X3VRFA4e43cc225dbf11ef57616e082e51622e8f1e7d9c9b27b2c...MutatorOneshotObject09,MutatorOneshotObject58MutatorOneshotObject58-blur-0.0625-0.pnggeneralization2001535.0FalseFalse1623769464
50939193ZWFC4W1UVHVDPID57BLAZ34X3VRFA4e43cc225dbf11ef57616e082e51622e8f1e7d9c9b27b2c...MutatorOneshotObject09,MutatorOneshotObject58MutatorOneshotObject09-original.pngcatch200293.0FalseTrue1623769468
\n", + "

50940 rows × 12 columns

\n", + "
" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 10 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2026-03-26T22:15:04.739801Z", + "start_time": "2026-03-26T22:15:04.715688Z" + } + }, + "cell_type": "code", + "source": "hobj.load_image(image_id=df_highvar_behavior.iloc[1].image_id)", + "id": "aae7cfeec0f88685", + "outputs": [ + { + "data": { + "text/plain": [ + "" + ], + "image/png": "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", + "image/jpeg": "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" + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 17 + }, + { + "metadata": {}, + "cell_type": "code", + "outputs": [], + "execution_count": null, + "source": "", + "id": "c3889be965d793dc" + }, + { + "metadata": {}, + "cell_type": "code", + "outputs": [], + "execution_count": null, + "source": "", + "id": "f58c06464094275c" + }, + { + "metadata": {}, + "cell_type": "code", + "outputs": [], + "execution_count": null, + "source": "", + "id": "e3910bb009633ba8" + }, + { + "metadata": {}, + "cell_type": "code", + "outputs": [], + "execution_count": null, + "source": "", + "id": "eac169bed3ab7ca2" + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/score_example_models.ipynb b/examples/score_example_models.ipynb index 23b7c61..cf36c07 100644 --- a/examples/score_example_models.ipynb +++ b/examples/score_example_models.ipynb @@ -3,8 +3,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-01-27T18:12:05.068082Z", - "start_time": "2025-01-27T18:12:04.841722Z" + "end_time": "2026-03-26T22:23:46.112399Z", + "start_time": "2026-03-26T22:23:46.107394Z" } }, "cell_type": "code", @@ -19,14 +19,14 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-01-27T18:12:06.972624Z", - "start_time": "2025-01-27T18:12:05.071466Z" + "end_time": "2026-03-26T22:23:50.095180Z", + "start_time": "2026-03-26T22:23:46.113436Z" } }, "cell_type": "code", "source": [ "# Load benchmarks\n", - "from hobj.benchmarks import MutatorHighVarBenchmark, MutatorOneshotBenchmark\n", + "from hobj import MutatorHighVarBenchmark, MutatorOneshotBenchmark\n", "\n", "benchmark1 = MutatorHighVarBenchmark()\n", "benchmark2 = MutatorOneshotBenchmark()" @@ -44,8 +44,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-01-27T18:12:06.974944Z", - "start_time": "2025-01-27T18:12:06.973320Z" + "end_time": "2026-03-26T22:23:50.132492Z", + "start_time": "2026-03-26T22:23:50.127829Z" } }, "cell_type": "code", @@ -68,8 +68,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-01-27T18:12:12.334469Z", - "start_time": "2025-01-27T18:12:06.975697Z" + "end_time": "2026-03-26T22:23:55.719115Z", + "start_time": "2026-03-26T22:23:50.134712Z" } }, "cell_type": "code", @@ -84,17 +84,17 @@ "name": "stdout", "output_type": "stream", "text": [ - "LearningCurveBenchmark.LearningCurveBenchmarkResult(msen=0.11344782631802722, msen_sigma=0.0010224279429435987, msen_CI95=(0.1113092143859505, 0.11539759036915627), lapse_rate= Size: 8B\n", + "LearningCurveBenchmark.LearningCurveBenchmarkResult(msen=0.11344782631802723, msen_sigma=0.001029320465701059, msen_CI95=(0.11137540880220907, 0.11541750060967891), lapse_rate= Size: 8B\n", "array(1.), model_statistics= Size: 103MB\n", "Dimensions: (subtask: 64, trial: 100, boot_iter: 1000)\n", "Coordinates:\n", - " * subtask (subtask) " ], - "image/png": "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" + "image/png": "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" }, "metadata": {}, - "output_type": "display_data" + "output_type": "display_data", + "jetTransient": { + "display_id": null + } } ], "execution_count": 5 @@ -151,8 +154,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-01-27T18:12:14.724472Z", - "start_time": "2025-01-27T18:12:12.378736Z" + "end_time": "2026-03-26T22:23:57.954802Z", + "start_time": "2026-03-26T22:23:55.786205Z" } }, "cell_type": "code", @@ -166,7 +169,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "GeneralizationBenchmark.GeneralizationBenchmarkResult(msen=0.18410921895147417, msen_sigma=0.0075863415108709436, msen_CI95=(0.1707254164624649, 0.20003988718928112), model_statistics= Size: 583kB\n", + "GeneralizationBenchmark.GeneralizationBenchmarkResult(msen=0.17902651379876888, msen_sigma=0.008827749299170323, msen_CI95=(0.1632750537580675, 0.19707395861786794), model_statistics= Size: 583kB\n", "Dimensions: (transformation: 36, boot_iter: 1000)\n", "Coordinates:\n", " * transformation (transformation) " ], - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAcoAAAHWCAYAAAD3iMk8AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAABR6UlEQVR4nO3dB3gU1doH8De0BAKhhYTQew899CogShFBMKACiYJXBS6C5YIFBAve6weCiCIqBBWRFlEEQQRp0psEkCYl9E4gAQIJ8z3/g7PubjZLEpLM7sz/9zzLZmZ32TPb3jntPT6apmlCRERELuVwvZuIiIiAgZKIiMgNBkoiIiI3GCiJiIjcYKAkIiJyg4GSiIjIDQZKIiIiNxgoiYiI3GCgJCIicoOBkjzW0aNHxcfHR/7v//7P6KJY5rWOioqy7XvrrbfUvuxm1PMSpYaB0gL27NkjTz31lJQsWVJ8fX2lRIkS8uSTT6r9VrN+/Xr1Q3zlyhWji2Jp169fV+/DqlWrxKqft/fee08WLlxoSLkofRgoTS46Olrq168vK1askMjISPnkk0/kmWeekd9++03t//7778VK8MM1ZswYBso0eOONN+TGjRtZFijxPrgKlFn5vJ70eWOg9B65jC4AZZ2//vpL+vbtKxUqVJA1a9ZIsWLFbLcNHTpUWrZsqW7ftWuXug+Zx82bNyVPnjySI0fGz4Vz5cqlLtnNqOc1g8x438kFrB5C5vSvf/0LK8Noa9ascXn76tWr1e24n2706NFq38GDB7X+/ftrBQsW1AICArSIiAgtISEhxf/x9ddfa/Xr19f8/Py0woULa+Hh4VpsbGyayrdlyxbtwQcf1IoWLaoeX65cOS0yMtJ2+5EjR1RZPvjgA+2zzz7TKlSooOXJk0dr2LChtnnz5hT/34oVK7QWLVpo+fLlU+V+5JFHtL1796Y4NucLnsedjz/+WCtfvrwqY1hYmHo9W7durS72bt68qY0aNUqrWLGiKmepUqW0V155Re23h+ccNGiQ9v3332s1a9ZU961Ro4b2888/p3juEydOqNckKCjIdr8vv/zS4T6//fab+j9nz56tvf7661qJEiU0Hx8f7fLly9rFixe1l156SatVq5bm7++vFShQQHvooYe0nTt3Ovwf+ms9Y8aMFK+XDp8HV68fLrgvJCYmam+++ab6TOBzg/cC78nKlStTPFdq/4fz88Lt27e1sWPH2j4DZcuW1UaOHJnitcX+zp07a2vXrlXvla+vr3rvZs6c6fY9dv68TZgwQStTpox6z1u1aqXFxMQ43PePP/5Qrwf+bzxHcHCwep8uXLiQps+bq/34/zLrfcf/hfcb/0+3bt3U34GBgeqzkJSU5PD/4PF4v/Lnz68+H/isTJw48Z6vl5XwtM3EFi1aJOXKlVM1R1datWqlbl+8eHGK2x5//HEpX768jBs3TrZv3y5ffPGFBAUFyX//+1/bfd59911588031X0HDBgg58+fl8mTJ6v/d8eOHVKoUKFUy3bu3Dl58MEHVS13xIgR6r4YUIKmYmfffvutXLt2Tf71r3+pQR7/+9//pEePHnL48GHJnTu3us+vv/4qDz/8sKoZo08ITXcoS/PmzVX5cZx4zIEDB2T27Nny4YcfSmBgoHqsfU3b2aeffiqDBw9Wr+GwYcNUGR999FEpXLiwlCpVyna/O3fuyCOPPCLr1q2TZ599VqpXry4xMTHqefCczk1suB+O9YUXXpACBQrIRx99JI899pjExsZK0aJF1X3Onj0rTZo0UceMMqCcP//8s2o6v3r1qrz44osO/+fbb7+tahMvv/yyJCYmqr/37t2rnrtXr17q/cT/+dlnn0nr1q3VbeivTiu8/u3bt3fYt3TpUpk1a5b6bADKhc9Knz59ZODAgep9+/LLL6Vjx46yefNmqVu3rjoOvK7PP/+8dO/eXb0vULt27VSfG5+vmTNnSs+ePeWll16STZs2qc/mn3/+maL74NChQ+p+eJ369+8v06dPl4iICGnQoIHUrFnznsf51VdfqXIPGjRI1dAmTZokDzzwgHo/g4OD1X2WL1+uPn/ozihevLjq7582bZq63rhxo3rP3H3evv76a3VMjRo1Up8XqFixYqa975CcnKxe98aNG6sBcfiOjB8/Xj0PXnv9OPBetWvXzvbdxmv6+++/q1Yn+pvRkZqyxpUrV9TZJs4m3UGtC/e7evWqw1nw008/7XC/7t27q5qf7ujRo1rOnDm1d9991+F+OPPOlStXiv3OUJvC86BWmRr9zBvPe+nSJdv+H374Qe1ftGiRbV/dunXV2TdqUPZn/Tly5ND69etn24faQlpqkXrtCM+NmglqNLqoqCj1f9jXKFGzxnOhJmNv6tSp6r6///67bR+2UUs4dOiQQ1mxf/LkybZ9zzzzjBYSEuJQS4HevXurGvP169cdahaoben7dKhxJScnp3hdUQtCDS09NUpnaHVAOTp06GCrpeAar5s91HBQ47L/TJ0/f96hFmnP+XlR+8X2gAEDHO738ssvq/32tVXUKJ1bUc6dO6eOF7Upd/TXIG/evKomptu0aZPaP2zYMNs+59dZr5k5P7e7zxtqefa1yMx83/Xav/17DPXq1dMaNGhg2x46dKiq+TvXMskRG7JNCmfEgNqKO/rtOFO199xzzzlso0Z18eJF2/1QG0ItCrXJCxcu2C44u65cubIaLOSOXtv86aef5Pbt227vGx4ermpw9mUBnNHD6dOnZefOnarWUKRIEdv9UEPp0KGDLFmyRDJi69at6phRM7LvM8OIYfvywLx581Qtslq1ag6vB2oi4Px6oGam1yD0sgYEBNiOCfF0wYIF0rVrV/W3/f+JWkJcXJyqKdtD7Slv3rwO+zDKWe+vQg0Dx5M/f36pWrVqisenR0JCgqoN4nVAjSlnzpxqP671Gg0+H5cuXZKkpCRp2LBhhp9Pf/+GDx/usB81S3BuEalRo4ZDKwpqZDhe/bW9F7QYYIS4DrU+1MrsP0f2rzNqnXhfUAuE+3ldM+t9d/c9tn8d8D3Ee4maJaWOTa8mpQdAPWCmN6CWKVPGYVsPDJcvX1Y/6AcPHlRfZARFV/Qm0fj4eHXR4YcUP1xo+kNTI0YEolmqTZs26gfqiSeeUD/uaS0LHDt2TF3jx9AZgteyZcvUj4G/v7+kh/7/VqpUyWE/giaacu3h9UCTVWrNuGhqdndM+nHpx4RmbIyURHMeLmn5P9G06gzBCk2HGO185MgRFSx1ehNvRuDkAYPFMKrT+f9BEyma+Pbt2+dwEuSqfGl9HxDsnd8HnJThh15/n9L62t6Lq890lSpVZO7cubZtnADgs/vdd9+leB8QzDIqs9538PPzS/F5dH4d0PSP40K3BU4O0B2Ck9+HHnoow8dgRgyUJlWwYEEJCQlRI1rdwe34giD42dNrCM7uthze/QFGHwr6TlzdF7UWQN8IflB0ZcuWtU1unz9/vurPQV8qgtnTTz+tfmCxT398WsriCfB6hIaGyoQJE1zeXrp06XS/voD5r6gxuOLcp+eqVoEpCOhHxmuLvizUuBF00M+lP0d6IfCiFvnNN9+oPkd72IeaPU56XnnlFdV3iWNFfyIC6/1IaxKC7Pi8IJjgJAHHiNcAn1e8nggwGX1dM/N9d/c62MP7g9YYfP/wXcZlxowZ0q9fP3XCQ3cxUJpYly5d5PPPP1cDR1q0aJHi9rVr16qghUEa6YVmQ/zw4GwWZ9upwRfO/rmdv9RorsIFA4MwaAfNmjhLx0CHtELwhf3796e4DbUaDKLQa5Ppyfii/78YHNK2bVvbfjQl4nWz/8HC6/HHH3+oQRGZkVUGNQHU8lEDdB5Akx44GUHZMaDGHmot+uCS9MBnBoNGEGjxXrl6PgyoQtO8/eswevRoh/ul931AAEGtHS0EOgx6wXHo71NmwfM4w6AcvRUBNTLMS8YJ4KhRo9w+zt1xurots9739EBTOZp6ccHrjFomBnzhBMu5Fm9V7KM0MZztIjAhEKJvyh6ajtB/kS9fPnW/9MKIPpyx4sfC+Uwd2/rz4UcTX3j9glGo+o+N8+P02glG7qUHas54LM6A7Sd27969W3755Rfp1KmTbZ8eMNOScAD9amhWxMkGgqMOozydm/FQwzh58qS6rzOMwEXTb3rgtUXTNPqrcByumujS+v84v87oT0VZ0wt9wThOnPh88MEHqT4f2D8nRqhu2LDB4X743KX1fdDfv4kTJzrs12vvnTt3lsyEUcL2rw9G6+IY0DyZ2jG6Kt+9Pm+4zXl/Zr3vaeX8u4DWBv0EML3fQzNjjdLE0NeC4IEzfzQLYng5aoCoDaGGgQECaEKzH1SSVnjMO++8IyNHjrRNmcCZMPrBMFwfQ95R80gNyoV+MwwIwf+FvlIEGTQB2we2tMIPN37ImjZtqo5Tnx6CJmhMF9FhigC8/vrr0rt3b9WXijNpV/2XONPGY4cMGaIG5SBI4FiRDxVltq8RIHED+npw8oGBOzghQK0ANVrsR9MWAm96vP/+++r/wkAS9AlikApOcDCYA0P98XdaWhXGjh2rpjE0a9ZMTXFAoM9Igol///vf6of61VdfVbV+e/hxxQXPh9ok3lcEMHwepk6dqspu31eNEzjsmzNnjmqRQJNwrVq11MVZnTp1VDMk+uwQWNC/jeCFzxA+d/a1/cyAWhROBjCFAsECARAnTDhuwGcUU6AwTQl9sOi6wAkZjtWZu88bbsP7iICPaTr4buK9zoz3Pa3QcoP/D59vTHdCfy++NzjxtK+9W57TKFgyoV27dml9+vRRQ85z586tFS9eXG07T6K2H5qP4fv2MG3A1TD3BQsWqAnlGOqOS7Vq1dRk+v3797st0/bt21UZMKkbQ/cxtaNLly7a1q1bXU4Ad+ZqasGvv/6qNW/eXA3vx5D3rl27OiQc0L399ttayZIl1XSOtEwV+eijj9S0A5SzUaNGaqoHhthj4r69W7duaf/9739VEgHcFwkYcL8xY8ZocXFxDmXHa+QMz+E8XeDs2bPqvqVLl7a9d+3atdOmTZtmu48+TWDevHkp/k9MD8G0CLz3eF3w+mzYsCFFwoS0TA/B/e+VcODOnTvae++9Z3u9MB3hp59+UseFffbWr1+vXh9MlUlLwgG8jpjgj9cBr4e7hAPOXCWIcGb/eRs/frx6DhxDy5Yt1fQde5g+gilThQoVUlM2evXqpZ06dcrl5zK1z9u+fftUMgO8L84JB+73fdcTDjhzfm3nz5+vkn7oiQ3wfUQCktOnT7t9razGB/8YHayJvAn6cdCXhOZnV02t5J3QWoBaHVon3LWGkPWwj5LIDcyRcz6XROYWNFdhSgsRmR/7KIncwFQVpK5DCjj0U6GfCP276EvDPiIyPwZKIjcwJQBzIJGLFbVIDDrBlBcMuNAz0BCRubGPkoiIyA32URIREbnBQElERORGLisO7T916pSaHJ8ZqcaIiMg7oecRyU6Q8EFfZccVywVKBEnnBNVERGRdx48fd1iIXaweKPXlpPDCOK+YQURE1nH16lVVcbrXur2WC5R6cyuCJAMlERH53KMbjoN5iIiI3GCgJCIicoOBkoiIyA0GSiIiIjcYKL3cuas35cPlB9Q1ERFlPgZKL3fuWqJMWnFQXRMRUeZjoCQiInKDgZKIiMgNBkoiIiI3GCiJiIjcYKAkIiJyg4GSiIjIDQZKIiIiNxgoiYiI3GCgNDFm7SEiun8MlCYPkvZZe+wDZ2p/ExGRIwZKL6QHtr2n4mTWxmNqH66xbQt+1xJl9pbjDo/bd+aqCpy4tk99xzR4RESpY6D0QnpgO3A23hYMcY1tVwHv8Pl4Cf9sg8SciFPblxJu225DgL2UwABJRJQaBkoLOHbxumw6cklOx6VsWkWAtQ+cRETkiIGSiIjIDQZKIiIiNxgoiYiIPDVQrlmzRrp27SolSpQQHx8fWbhw4T0fs2rVKqlfv774+vpKpUqVJCoqKlvKSkRE1mRooExISJA6derIlClT0nT/I0eOSOfOnaVt27ayc+dOefHFF2XAgAGybNkysZIL8XdHqR67mOCwX9/G7fp94K/z19T1obPXbPezv93+cURE5MhH0zRNPABqlN9//708+uijqd7nP//5jyxevFh2795t29e7d2+5cuWKLF26NE3Pc/XqVSlYsKDExcVJQECAeJs5W2JlRHSMuHvXfEQko2/q652qy8BWFTJaPCIir5HWeJBLvMiGDRukffv2Dvs6duyoapapSUxMVBf7F8Zb6IkD4FLCLfnj+GWZsPzgPYPg/Zz5vPfzn1I5OL/UCAmQoAC/+/ifiIju7c6dO3L58mUpWrSoeCqvCpRnzpyR4OBgh33YRvC7ceOG5M2bN8Vjxo0bJ2PGjBFvNGtTrEogkJ1QU42YsUWGtqsswzpUydbnJiLrWbp0qcTExEjfvn3VeBVP5FWBMiNGjhwpw4cPt20jqJYuXVq8wZONy0iHGsHprlHeDx8fkRkRYapGSUSU1Ro1aiQHDhyQ+Ph48VReFSiLFy8uZ8+eddiHbbQtu6pNAkbH4uKN0PRp3/zZqkoxtT0yOkbuZFEf5ZC2laRN1aAMPpqIKH0CAwNl8ODBkiuX54Yjr5pH2bRpU1mxYoXDvuXLl6v9VhEeVkamR4Spv4e1r+xwm749IzJMoiLv3sdek3KFbfezv93+/3mwZvEsKzsRUXJysixatEjOnTtn2+fJQdLwQImqNqZ54KJP/8DfsbGxtmbTfv362e7/3HPPyeHDh+XVV1+Vffv2ySeffCJz586VYcOGiZUE5r9bQy5b1N9h/95TV2236/exVym4gO1x9rc7/z9ERFll1apVsn37dpk1a5YkJSWJNzA0jG/dulXNidTpfYn9+/dXiQROnz5tC5pQvnx5NT0EgXHSpElSqlQp+eKLL9TIVxJZttexWZqIyNM0a9ZMjh07Ji1btvT4mqTO0FK2adNG3E3jdJV1B4/ZsWNHFpeMiIiyQt68eSUyMlLNnfcWXtVHSffn0DnPHVVGROaUlJSkusj2799v2+dNQRIYKE0ICzFvPXopxf6NR+7uO37peqqLNTONHRFlps2bN8uff/6pMq9hvrs3YqA0oZ9jzshbi/amevv45QfUfXQbD1+0/R0ZtUWlySMiygxNmjRROb0ff/zxVKfxeTrv6EklB0EFfFXmnCrB+aVPWGmZveW47bY+jUpL59AQORV3Q1YfuOByfuVTjctIlb9HwLauEihz7B6PLmPM0wwO8LONjMXzMZ0dEaUnLV2OHHfrYbh2l8PbG3hMUvTs4u1J0Z3tPhknXSavs23/NKSFurbfBzl8RCKbl5Mv1x1N93MwnR0RpadPcs6cOVK2bFlp0eLu75GnMmVSdLq3z9f+JY/VL6X+frRuCblxK1lNG5n+d1o6H/FRGX7g592npXH5ojJs7k6H1UgQVHF/+xolEVFaYI77oUOH1BSQ0NBQFYi8HQOlyfyw87TkzX33bR3Q8u5yWQiUCHpoPn2jSw3bffWAmZiUbEuLhyA5rkco09gRUYbUqlVL1dBKlixpiiAJDJReDMtwuRrdqvc5YjpIEf/caUqLhz5JrBqCmiSDJBGlx+3btyVnzpy2fsnmzZuLmXDUqxfDMlyuRrfqragvztnpMLrVHb2Z1VXqOyIid0Fy9uzZavoHBvGYEQOlF8MyXG91/acpVadP5Z0YXlceDi3usib64fID6pqI6H6cOnVK9UdiqayLF/+ZamYmDJReDH2OWKfSWXjY3fU2KwXllyL+KWuI564lqgWhcU1EdD/Kli0rvXr1kqeeekqKFbs77sFs2EfpZVAL1AMcsuhMXnkoxX0C/HK57aPUs/Kklp2HiMidW7duqeWy9AQC1apVEzNjoPTCfknUBt2ZtvaIrY8SCQmcXUq47XBNRJSeIPntt9+qvsm+ffuKn5/5k5EwUHphv2SHGsG2GmXkjC22wTvOGXhwnc83pyHlJCJzunr1qlp0GQN3Ll++LCEhIWJ2DJRe2C9pn07u6RYps+1odtczfj8q3eqGqL5MZPGBqzdS9msSEaVFYGCgWjMYGXisECSBgdLLIdOOO0gigCQEuOg6/l0jJSJKi8TERElISJAiRYqo7eBga/2GMFB6uWdbVZBaJQuq/khXnNPRwfZjl1S2HiKitATJb775Rq5cuSIRERFStGhRsRoGSi+HZlhMA7GHNVE1N+nouIAzEaVVcnKyGsCDplYETStioDSh0V1qqIw96UlHpy/dxQToRGQvX7580q9fP7l27ZoUL54ygYkVMOGAibSuHOiwnVo6uivXbzlc6zVTLKXFdSeJ6ObNmyrbjs7f39+yQRIYKE1kzcG7CzWPcZH/VTdnS6ztdlxjm4jIPkh+/fXX6vLXX38ZXRyPwKZXL6Zn6dFXELGfFgK/7Ttny86DVHaYdzkiOsbhflheCyuH2K89yVolkXXlzp1bChQooOZIoiZJIj6aZr9kr/mldUVrb4DE5vfK0pNe6KdEEywRWXsAD0a5mn2E69U0xgPWKE2QpQc1SlfLbb3UoYqULpJPjX7FfMo9p+Lk87/T29kb1r6y1CtTSNU6OZiHyHpu3LghBw8elNq1a6ttrC1p9iCZHgyUJsrSo08L0a/bVgtScyzvVfP88NeDrEkSWRRytn711Vdy5swZNQ2kYcOGRhfJ43Awj8mmhdhf29c8fxrSwuXalahtRkWGqfsQkfXkypVLKleurPojy5Th74ArrFGagD4HskKxux3vhfLlcV/z1JOmp5KQgIisw8fHR9q2bSuNGjWS/Pkdk5fQXaxRmoA+B9LVIs2uDGxZ3lbzDA/jGSSR1SBv6+rVq0Ufy4lgySCZOgZKEyrin0fVMNGsiv5JTCOxV8Avt8uaJxGZH5bHQu7WVatWya+//mp0cbwCA6VJAyVqmBjpikE8mGtJRAQ5cuSQ5s2bq+kQ9erVM7o4XoF9lEREFlOrVi2pWrWqSi5A98YaJRGRycXHx8sPP/zgsPoHg2TasUZJRGRiGLAzd+5cOX78uJoz2bNnT6OL5HVYo7QQ5HqFazdvG10UIsomGNH60EMPSVBQkDzwwANGF8crsUZpEVglBAnRwVUaOyIyrxIlSshzzz2ngialH2uUJnQpIVF2n4xTK4cAcsGqVUP+Tn+vZ8GPvXRd3Q8X5ykkROS9sMgylsnCCiA6BsmM4+ohJoKA12XyOqlVIkB2n7qarscy1yuRecyePVsOHDggZcuWlf79+zNIpoKrh1gYgmTvsNIyZ8vxu6nq7GqR9pD7tWG5IupvrhpCZB5dunRRo1xxzSB5/xgoTQSZeDrWDJZle87agiQ4B0vcDyuLdAoN4SLNRCaBxkE9KGLh5aeeesroIpkG+yhNBAESF3FRg7Tfnh4RJl/2D2OQJDIJNB1OnTpVjh49anRRTImB0kSwVNbE8Lrqb+fGFtQi9WW2AvOzmZXITNasWSPnzp2TpUuX2hKdU+Zh06uJoIZYKejuCgDhYaXluy3HbUESy2nVLFHQ4BISUVZ4+OGH1XWrVq3YJ5kFWKM0EUzxmLXxmPq7SYWiDk2tXE6LyFyQZcd+8eWuXbuqEZyU+RgoTQSrhMz+uxZpj02tROZy5coV+eSTT2Tbtm1GF8USGCiJiLxMTEyMCpYbNmyQpKQko4tjeuyjNKkr128ZXQQiyiItWrRQ60rWrl1bNbtS1uIrbCK/7Dlj+3vMor2GloWIMn+pLH9/fzVYBxcsvkzZg02vJhFz4opMXnnIts0B4kTmcenSJZk2bZosWbKE0z8MwEBpEjN+P8rgSGRSp06dUonOkVDAfvFlskignDJlipQrV078/PykcePGsnnzZrfDoceOHSsVK1ZU969Tp46aYEsikc3LpUgyQETmUKtWLenVq5dKcI7fPrJQoJwzZ44MHz5cRo8eLdu3b1eBr2PHjirDhCtvvPGGfPbZZzJ58mTZu3evWl+te/fusmPHDrG60FKFZMgDlWzbruYcI/E5VglhAnQiz4clsm7d+mdQXo0aNSR//rsJRchCgXLChAkycOBAiYyMVB8C5CrMly+fTJ8+3eX9sb7aa6+9Jp06dZIKFSrI888/r/4eP358tpfdE9UvW9j29+gud9PV9WlU2hYYkbkHS2kxxyuRZ7tw4YL6HcRyWfaJBchigRJnSpgs2759+38KkyOH2sbcIFfQNu/c7JA3b15Zt25dqs+Dx2DNMfuLGc3ZEiuRUVts29tj7y7Y2rFm8VQDIzL5fLj8ABdtJvIwN2/eVL+R169fZ6C08vQQnDElJydLcHCww35s79u3z+Vj0CyLWijyGaKfcsWKFRIdHa3+n9SMGzdOxowZI2aCwIYsPLoL8YkyIjpG7AfD/fjHaXUdOWOLapJ9EAGzgK9D0MT/MWnFQelQI5i1TCIPUqpUKenXr58UKlRItbKRsbxqHuWkSZNUU221atXUPCIESzTbptZUCyNHjlT9oDrUKEuXLi3ebNamWBXg0gKx86OVh9QFzbBPNi6bImASkfHOnz8vefLkseVrLVmypNFFIqMDZWBgoOTMmVPOnr27fqIO28WLF3f5mGLFisnChQtVs8TFixelRIkSMmLECNVfmRpfX191MdtyWqgF6j5f85f88HcN0p3Zm4+rCwb0oK+SiDwnSM6cOVMFyoiICAkICDC6SOQJgRIfiAYNGqjm00cffVTtu3PnjtoePHiw28einxJnW2i7X7BggTz++ONiJagN2tcIX+9cQ8oW9ZfJvx1yaH7VYZktrCCiJ0fnqFciz4Lfw9y5c6uTelyTZzG06RVNopgX1LBhQ2nUqJFMnDhREhISVHMqoI0eARH9jLBp0yY5efKk1K1bV12/9dZbKri++uqrYmUImsMfrKpGvUbM2GKbHoKgqa9F2aZqkNHFJKJUoLkVNUkETAxQJM9iaKAMDw9XTQ6jRo2SM2fOqACIBAL6AJ/Y2Fg1ElaHJlfMpTx8+LCaT4SpIZgygg5vclxOC9ND3lq0V9UkGSSJPA+6mTCyVR8zwbUkPZfhg3nQzJpaU+uqVasctlu3bq0SDdC9FcqXR11zLUoiz4NR/+iTxIh91CRDQkKMLhJ5cqCkzIfRrUX87wZKIvI8GKyDljOMsyhc+J9EIeSZGChNCFNAiMhzoS+yT58+aowFc7d6PsOTohMRWcHp06dl165dDsGSQdI7sEZJRJTFrly5Il999ZUakIjgWKUK5zF7EwZKIqIshhGtNWvWVCsjlS3LrhFvw0BJRJTFkHKzc+fOkpSUxIQCXoh9lEREWeDEiROycuVK0f5Ol4VgySDpnVijNBH7hZntVxdJDVYdsb8mosyB5bG++eYbtcwfpoIg+xh5L9YoTSQ9CzPbr1+Ja2wTUebA0lhYW7dcuXJSu3Zto4tD94k1SgvULp3XsHRevxLXI6NjJDjAzyGTD5fjIso41CLr16/vkIaTvJOPpjegWwTWo8QItLi4OEstZfPh8gNpXsNSx+W4iNIOuamxcEP37t0lVy7WQcwUD/huWoT9GpaoUaK51f4UyXkpLuByXERpg1R0c+fOVasfYa3dtm3bGl0kykQMlBZdw/L9HqGqufUOl+Iium8YzdqzZ0/ZuHGjtGjRwujiUCZjoLSo8LAyqk8S61dyKS6ijEHPFaZ9AAbu4ELmw15mC9ObWbkUF1H6HT16VD7//HOJj483uiiUxRgoiYjSCat+LF68WCU6X716tdHFoSzGQElElE6Y8oFlsurWrSsdO3Y0ujiUxRgoLQbzKTFVBNdElD7I1aorUqSIdOvWjVNBLICB0mKQdADzKdOS4o6I/nH48GH56KOPVHMrWQsDJRFRGka3rlu3Tq5du6amgJC1sM2AiOgeMAUkPDxcBcvWrVsbXRzKZqxREhGlApl2dL6+vtKuXTv2SVoQAyURkQuHDh2SSZMmyZ49e4wuChmMgZKIyIV9+/apHK579+61Lb5M1sQ2BCIiFzp16iTBwcFqqSw9TR1ZE2uURER/u3Dhgq32iKQCYWFhkjNnTqOLRQZjoCQiEpH9+/fLp59+KqtWrWJTKzlgoLQwrDeJxZm57iSRyOXLl1UO14sXLzJQkgP2UVoY1qcc1qGK0cUg8ghNmjRRaekqVaqkml2JdPw0WMyF+ESHayIri42NleTkZNt2lSpVGCQpBX4iLGTOlliJjNqi/sY1tomsCtM+oqKiZP78+Q7BksgZA6UFYKWQVfvPyYjoGNG7XnA9MjpGYk5cMbp4RIbIkyePqj3imtM/yB0GSguYtSlWImZssQVJ3R1NJGr9UaOKRWQo9EU+88wzaqksNreSO/x0WMCTjctIVGSYOJ805/ARiWhWzqhiEWW7AwcOOORvDQkJYZCke+InxCKjW9tUDZL3e4Sq4Ai4HtcjVEJLFTK6eETZ1if53XffyVdffSU3b3Lhcko7Tg+xkPCwMhIc4KeaYadHhKngSWQVQUFB4u/vLyVKlFArgRClFQOlyQfxoH8STa+oVUJgfl+HayKrCAwMlIEDB0qBAgU4eIfShU2vJnbuWqJMWnFQXRNZUUxMjJw9e9a2HRAQwCBJ6cZASUSmzd0aHR2t+iTj4uKMLg55MTa9EpEplSlTRo1qLVmypKpJEmUUAyURmVLevHmlf//+TChA941Nr0RkGjt27JB9+/bZtjG6lUGS7hcDJRGZwpEjR+THH3+UefPmOQzgIbpfbHolIlMoW7as1KxZU82VxJxJoszCQElEpoBUdD169FBNrWxupczEplcT49qTZHZbtmyRtWvXOgRLBknKbAyUJsW1J8nsTp8+LUuWLJGVK1eq/kmirMKmVxOlq9Mz8KAG6WrtSeR5zeHjI30alZZLCbfUY/TUdkTeBnMkH3jgAblx44aUK8dVcCjr+Gia8yqF2WvKlCnywQcfyJkzZ6ROnToyefJkadSoUar3nzhxonz66acSGxurcjf27NlTxo0bJ35+afvBv3r1qhQsWFBl6jDTJOQPlx9Q6erSY2i7yjKsQ5UsKxNRVsBPln3zqvM2UVqlNR4YWqOcM2eODB8+XKZOnSqNGzdWQbBjx44q9ZSrUWvffvutjBgxQqZPny7NmjVTa8tFRESoL8mECRPEypD4vEONYFuNEs2t9qdAWFYLK4bYJ0MPKsDE6ORdNm7cKCdPnpTu3bvb1pFkkCRT1ygRHMPCwuTjjz9W23fu3JHSpUvLkCFDVEB0NnjwYPnzzz9lxYoVtn0vvfSSbNq0SdatW2fpGqUz9EmiufWO9s/ak1hmi8hbXb58Wf1W4Hfisccek1q1ahldJPJyaY0Hhg3muXXrlmzbtk3at2//T2Fy5FDbGzZscPkY1CLxmM2bN6vtw4cPq878Tp06pfo8iYmJ6sWwv1gBgiJqkIBrBknydoULF5ZevXpJq1at1HxJouxiWNPrhQsXJDk5WYKD7zYX6rBtn4LK3hNPPKEe16JFC9UvkZSUJM8995y89tprqT4P+i/HjBkjVsS1J8kM8DuRM2dO9Xe1atXUhSg7edX0kFWrVsl7770nn3zyiWzfvl0tobN48WJ5++23U33MyJEjVbVavxw/fjxby0xEGff777+rMQk3b940uihkYYbVKDFiFWeJzjkZsV28eHGXj3nzzTelb9++MmDAALUdGhoqCQkJ8uyzz8rrr79u69y3h6TIuBCRd7l+/bqsX79eXe/Zs0caNGhgdJHIogyrUWLpG3zw7QfmoJMe202bNnX5GHxhnIOh3iRj8CwXIspk+fLlk379+qlxCwySZCRDp4dgagjWi2vYsKGaO4npIaghRkZGqtvxJcGiq+hnhK5du6ppIPXq1VMjZg8dOqRqmdivB0wi8m5IIIC1JPUxC87jGIgsFSjDw8Pl/PnzMmrUKJVwoG7durJ06VLbFwNJBexrkG+88YaaM4VrzKUqVqyYCpLvvvuugUfhHZCFZ9amWDXfktl4yFOtWbNG5W/FCTS6Z4g8geGZebKbVeZRwu6TcdJl8jr5aUgLta3/XatkQaOLRpTC7du35YsvvpBz587JQw89pFqNiMTqmXmIiHS5c+dW3S3IzFW/fn2ji0PkndNDKG1NrMj7imsib3Dp0iXb31h0mUGSPA0DpclgBREkR8c1crki8TlzupInQq/Pb7/9puZFY2AekadioDQxDNrB6iAcvEOeGigxbxqZd5Bxi8hTsY+SiAyBEe3I3Xrw4EGmpSOPxholEWVrLRLTvnSY/8wgSZ6OgZKIsi1IIvPWjBkz1LqSRN6CgZKIso2eQMRVXmYiT8U+Sou4EJ/ocE2U3ZBVq23btlKlShUpVaqU0cUhSjOe1lnAnC2xEhm1Rf2Na2wTZVdz6+7du9WCB3qwZJAkb8NAaXIxJ67IiOgY0RMV4npkdIzaT5TVli9fLgsWLJBFixZxhR/yWgyUJjfj96O2IKm7o4lErT9qVJHIQkqUKKH6I7EKEGqTRN6IfZQmF9m8nHy/86RDsMzhIxLRrJyRxSKLqFWrlgqShQsXNrooRBnGGqXJhZYqJO/3CFXBEXA9rkeo2k+U2dC8iqkfiYn/DBpjkCRvx0BpgdGt4WFlZHpEmPob19gmygqYJ7ls2TL59ttvbQN4iLwdA6VFRrcG5vd1uCbKCjVq1JC8efOqRdg5V5LMgn2UXgxLaWGVEL0G6Wp0a3CAnwqOh87Fq/2XEjiPkrJ28M6///1v8fNjIn4yjwwHSjSrYGkcrEbu3MTSqlWrzCgb3cOsTbFqSa3UYHRrxIy7NUzdzzFnpFWVoGwoHVlpqax69erZ+iIZJMlsMhQo0Vn/xBNPyLFjx1LMjcIQcCybQ1nvycZlpEONYFuNEs2tzqNb0Sep1yhfnLNTHg4tblyByXRWr14ta9eulZiYGBk0aJDkysVGKjKfDH2qn3vuOWnYsKEsXrxYQkJCOD/KIFhn0n6tSYxuRXMrapL66NY2VR1rj0X82UdJmadBgwayd+9eadGiBYMkmVaGPtlYP27+/PlSqVKlzC8RZRhGs6JPEs2tqEk6B0mizFagQAH517/+pZbLIjKrDA1La9y4seqfJM/D0a2UlTAeAS1JR4/+k9mJQZLMLkM1yiFDhshLL70kZ86ckdDQUMmdO7fD7bVr186s8hGRB9m8ebNs3bpV9UkOHTpUTQUhMrsMBcrHHntMXT/99NO2feinxMAeDuYhMi+MTTh8+LDUqVOHQZIsI0OB8siRI5lfEspSQQV8ZWi7yuqaKD30E2DAgJ0+ffpwAB9ZSoYCZdmyZTO/JJSlMDp2WIcqRheDvLBPcuHCheo7jxGuwCBJVnNf47kxLDw2NlZu3brlsP+RRx6533IRkQfYs2eP6o/Ed71ixYpSqBCT6ZP1ZChQoo+ie/fu6guk903an2myj5LIPMtkYdBeqVKlGCTJsjI0PQSj3cqXL6/S1+XLl0+dda5Zs0Z19K9atSrzS0lE2drcan/y26FDB6levbrRxSLyrhrlhg0bZOXKlRIYGKhWCMAFmTnGjRunEiLv2LEj80tKRFkOrUHR0dHqBLhTp07sjyTKaI0SXyZk5AAEy1OnTqm/0eG/f//+zC0hEWUbjDlAfyROdtFiREQZrFGi3+KPP/5Qza/I0vO///1P8uTJI9OmTZMKFSpkfimJKFvgO92tWzdVowwOvptwn8jqMhQo33jjDUlISFB/jx07Vrp06SItW7aUokWLypw5czK7jESUhdBChH5JPcMWFl0movsMlB07drT9jcTo+/btk0uXLqn16NinQeRdQXLevHmSmJiols5zTkdJRBnso3SlSJEiDJIegBl4KD0uXryoMm0dP35cTQMhopR8NOeVl9Pg5s2bMnnyZLWyOTr80Wxjb/v27eKprl69KgULFpS4uDgJCAgQKzt39abM2hSrFoC2X9eSrAVBEklDkFCAyEqupjEeZKjp9ZlnnpFffvlFevbsKY0aNWJN0kudu5Yok1YclA41ghkoLSQpKUlu3LhhG7leunRpo4tE5NEyFCh/+uknWbJkiTRv3jzzS0REWRok586dKxcuXJCIiAjLt6oQZVkfZcmSJW1no0TkPVCTRJC8du2aXL582ejiEJk3UI4fP17+85//yLFjxzK/RESUZXCC279/f3nqqae4ChBRVja9IqcrBvQguQAmJjsPKcdUESLyDLdv31ajW4sXL662MXgBFyLKwkCJhVtPnjwp7733nsrewcE8RJ4bJL/77js5ceKEqkVy4A5RNgXK9evXq8ToderUycjDiciA1UCcp3ERURYGymrVqqlBAUTk2dAtghYgDOApUaKE0cUhss5gnvfff19eeukltfYk+j4wadP+QkTGQfKAgwcP2raxYAGDJFE21ygfeughdd2uXTuH/WjeQX8l8kcSkTHzJGfPni1Hjx6V7t27S+3atY0uEpE1AyVS1xGR58mZM6dtjVgsUkBEBgXK1q1bZ8JTE1FmQ4tOp06dpGnTpmqhAiIyqI9yzZo1bi/pNWXKFClXrpz4+fmphaA3b96c6n3btGmjfgycL507d87IoRCZok9yy5YtqusD8H1gkCQyuEaJYOXMfi5levoosdDz8OHDZerUqSpITpw4Ua13uX//fgkKCkpx/+joaPXDoMNgIkxT6dWrV0YOxdIuxCc6XJP3wZSPWbNmSWxsrMTHx0vbtm2NLhKR6WSoRokckfYXLLW1dOlSCQsLU6uKpMeECRNk4MCBEhkZKTVq1FABE9l+pk+f7vL+OFNGhhH9snz5cnV/Bsr0mbMlViKjtqi/cY1t8j45cuSQ0NBQ1RpTpUoVo4tDZEoZqlG6Sn/VoUMHNQwdtcNt27al6f9BzRD3HTlypMMXv3379iqhQVp8+eWX0rt3b/H393d5O1Zux0VnxekrWHcSS2rpUIMcER0j+kqkuB4ZHSPBAX4SmP+fBZ+x+DOX3/J8SCmJk0ycMBKRhwTK1CCdHZpM0wqToNFMi8c5/z/79u275+PRl7l7924VLFMzbtw4GTNmjFgZFmfGupPu3NFEImbcrWHqhrarLMM6sJbiaZBnee3ataqZNVeuu19hBkkiDwuUu3btctjGIILTp0+rRAR169aV7IIAiWYnLB6dGtRWUcu1r1FaLd/lk43LqMWZ7WuUaG7Va5SQw0dkekRYiholeRZ817Ce5JEjR9RSWT169DC6SESml6FAiWCIwTv6KDtdkyZNUu1bdAXzvTDv6+zZsw77sa2vdJCahIQElex57Nixbu/n6+urLlaG5lPnJtT3e4Sq5lbUJBEkx/UIlTZVUw6eIs+C712rVq3UIDZMASEiDw2UOJu1h37FYsWKqQEF6YE+zQYNGsiKFSvk0UcftY3iw/bgwYPdPnbevHmq7xErIlD6hYeVUX2SaG5FTZJB0ntgKtWQIUNsza5ElLUy9E3Dgq8IZrhgxKvzqgTpqVWiWRQLyWJAAppQMT0EtUWMgoV+/fpJyZIlVV+jc7MrgmvRokUzcgiEGv3fzaz2za3kebAAwc8//ywPPvig5M+fX+1jkCTKPhn6tmFwDJo8EdxCQkLuaz3K8PBwOX/+vIwaNUrOnDmjmnUx1UQf4IP5Yaix2sOAoXXr1qV7KgqRN/rxxx/V4Db0r+Okkuu/EnlBoMRcx6ioKOnbt2+mFALNrKk1tWKFEmdVq1ZN0T9KZFaoScbFxcnDDz/MIEnkLYES8x+bNWuW+aUhIoeVeADJzZGUg0GSyIsy8wwYMEC+/fbbzC8NEcn169flq6++UiuA6BgkibygRmk/FxGDd6ZNmya//vqrWu8Oq6g7p6UjoozBIDmsJ/n999/L888/n6KPnog8NFDu2LHDYVtPLIDMOPZ45kt0/32SqFU+8MADDJJE3hQouVgzUdZBK40eFJEgA6PBicgz8HSVyGCYN4yujD179hhdFCJygYGSyGBYdBlpG7Fk3O3bt40uDhE5YXoPIoO1bt1aTblCOkfngXFEZDwGSiIDIE8xch1j8BsuGMBDRJ6JTa9E2QzLY33xxRdqgBwzTBF5PgZKomz2119/qUXL//jjD7UIMxF5Nja9WhgWZh7arjIXaM5mmIOcnJwsFSpUkLx58xpdHCK6Bx/NYm0/WIGhYMGCKsl0QECA0cUhi4iPj1dBEQuVE5F3xQM2vRJlw5dxxowZarFx1CSJyLuw6ZUoi128eFGdsSL7DlLTFShQwOgiEVE6MFASZbHy5cvLE088IUWKFGGQJPJCDJREWQA1yFy5com/v7/axsAdIvJO7KMkymRXrlyRqKgotaYkmlqJyLuxRkmUyZKSktQFGXdwTUTejYGSKJMFBgZK//79VYo6TkEi8n5serWAc1dvyofLD6hryhqXL19WK4DYB0sGSSJzYKC0gHPXEmXSioPqmrK2T/LcuXNGF4eIMhkDpQVqkpcSbhldFFPz9fVVo1uReYcp6YjMh32UFqhJTgyva3RRTA3BsW/fvirrTv78+Y0uDhFlMtYoiTKYbefAgQMOwZJBksicGCiJMpC7debMmTJnzhy1ZBYRmRsDJVE6oeZYtmxZKVq0qBQvXtzo4hBRFmMfJVE65ciRQ7p37y6JiYkcvENkAaxREqXB+fPnZePGjQ7BkkGSyBpYoyS6B+RrRZ9kQkKCyrZTv359o4tERNmINUqie8iXL580btxYgoODpVq1akYXh4iyGWuURGnQsmVLadKkieTOndvoohBRNmON0gKuXL+bmedCPFPYpRVS0S1evFju3Llj28cgSWRNDJQWMGbRXnUdGbVF5myJNbo4Hu/27dvyzTffyNatW2X16tVGF4eIDMamV5PldrVPfL716CV1rf29rWkiI6NjJDjATwLz+6p9QQV8JSjAz5DyeirUHDt37izr1q1Tza1EZG0+moafT2tlVSlYsKDExcWZbhkkJEBHbtf0GNqusgzrUCXLyuTN8NXA4stEZO14wBqliTzZuIx0qBFs217x51n58FfHwJnDR2R6RJhDjZJEzpw5I7/++qs89thjtvmRDJJEBAyUJoImVL0ZFX2RE1ekDJLjeoRKm6pBBpXQM2HAzoIFC+TChQsqWHbt2tXoIhGRB2GgNGHfJEa3joiOUX2Szs2sNUsUlN0n49g3aQdZdnr27CkrV66UDh06GF0cIvIw7KM0AfZNZrwmiSBJRNbEPkoL902iRompIM6nQG91rSENyxVRf1u9b/LkyZOycOFCCQ8Pl8DAQKOLQ0QejKfTJoAm1FolC9ou6IN8v0eo6pMEfUwKgqR+Hys3u6IRZfny5apPEs2tRETuMFCaVHhYGTW6FUZ3qWF0cTwKRrP26tVL6tWrJ926dTO6OETk4dj0amL6FJBC+fIYXRSPcOvWLbX6B/j7+8sjjzxidJGIyAuwRkmWcPz4cfnoo4/k0KFDRheFiLwMAyVZwrZt29R6kps2bVJ9lEREacWmV7IEJBEoVKiQNGvWjBl3iChdWKMk07p27Zrt75w5c0qbNm1sfZRERF4TKKdMmSLlypUTPz8/tYr85s2b3d7/ypUrMmjQIAkJCRFfX1+pUqWKLFmyJNvKS97h2LFj8vHHH8vGjRuNLgoReTlDA+WcOXNk+PDhMnr0aNm+fbvUqVNHOnbsqBbNTW3UIlKMHT16VObPny/79++Xzz//XEqWLJntZfcmRfxzq0w8VkoygM8IPi8HDx50WHyZiMir+ignTJggAwcOlMjISLU9depUtar89OnTZcSIESnuj/2XLl2S9evX21abR22U3Cvi72u5dHWtWrVSqalq1qzJNHVEdF8M+wXB2T5GIrZv3/6fwuTIobY3bNjg8jE//vijNG3aVDW9BgcHS61ateS9996T5OTkVJ8nMTFR5fOzv5A5oSVCrz1iwE7dunVtJ1RERF4XKJE+DAEOAc8etrE2oCuHDx9WTa54HPol33zzTRk/fry88847qT7PuHHjVM1Cv5QuXVqsvMoIEqjj2myOHDmimuEXLVrEplYiylRe1SaFH8CgoCCZNm2aNGjQQCW0fv3111WTbWpGjhypMsPrF0w8tyosxYVVRuyX5DKL69evqxOo+Ph4BkoiMkcfJVZswJD9s2fPOuzHdvHixV0+BiNd0ZSGx+mqV6+uaqD26cnsYWQsLmRu6IvMly+fajHIlYvTg4nIBDVKBDXUClesWGHbh5oAttEP6Urz5s1VCjL7GsOBAwdUAOX8OOtB6wD6oHXly5dnkCQiczW9YmoI+pVmzpwpf/75pzz//PMqzZg+CrZfv36q6VSH2zHqdejQoSpAYoQsBvNgcA9Zy19//aU+N7NmzXIIlkREmc3Q02/0MZ4/f15GjRqlmk8xSnHp0qW2AT6xsbEOQ/vRrLZs2TIZNmyY1K5dW82fRND8z3/+Y+BReC7MmzTr/Ek0s6IZHtesRRJRVvLRLJYhGtNDMPoVA3sCAgLESnafjJMuk9fJT0NaqMWbvR1GThcuXNihz5qIKLPjgVeNeiVrQ3Mrmt6dB4QREWUlBkryCphDO3v2bNUvyaQRRJSd2LlDXqFYsWJqmSz0X/v7+xtdHCKyEAZK8goFChRQo6GxygybW4koO7HplTzWvn371CogOtQkGSSJKLsxUJLHric5b948+fbbb1NkbyIiyk5seiWPhDmyFSpUUE2t6J8kIjIKAyV5JCQRQEIKJJzgepJEZCT+ApHH2LNnj2zdutUhWDJIEpHRWKMkj4AUhgsWLBAkiipatKhKcE5E5AkYKMkjYH5k48aN5caNG1K2bFmji0NEZMNASR7Bx8dHHnzwQdvfRESegh1AZJiYmBhZsmSJam7VAySDJBF5GtYoLeRCfKLDtZGuXLkiCxcuVItwY/m00NBQo4tEROQSa5QWMWdLrERGbVF/4xrbRkLe1q5du0qDBg2kVq1ahpaFiMgd1ihN6tzVm3Lu2j81yBHRMaKvPIrrkdExEhzgJ4H5/1nUGQs8BwX4ZWm50MyqN69ioW5ciIg8GQOlSc3aFCuTVhxM9fY7mkjEjLs1TN3QdpVlWIcqWVamnTt3yq5du6RPnz6SO3fuLHseIqLMxEBpUk82LiMdagTbapRobtVrlJDDR2R6RFiKGmVWwbSPZcuWyc2bN2X79u1qKggRkTdgoDQpNKHaN6O+3yNUNbeiJokgOa5HqLSpGpRt5cmbN6888cQTakWQRo0aZdvzEhHdLwZKiwgPK6P6JNHcippkdgXJ27dv25pZMboVFyIib8JRrxaiN7PaN7dmpW3btsmnn34qcXFx2fJ8RERZgYGSsqwmuX79erl8+bIawENE5K3Y9EpZAs2t/fr1U0GyRYsWRheHiCjDWKOkTJWQkGD7u2DBgtKyZUumpSMir8ZASZlm8+bNMnnyZDl+/LjRRSEiyjQMlJQpkLMVUz8SExPl0KFDRheHiCjTsI+SMkWOHDmkd+/esnv3bqlXr57RxSEiyjSsUdJ9OX/+vO3vPHnySP369dknSUSmwkBJGbZhwwY1TxI5XImIzIqBkjK8CsilS5fUNeZKEhGZFfsoKUPQvNqpUyepXLmyuhARmRVrlJQuR44cUbVIPVhWqVKFfZJEZGoMlJRm69atk6+++kp++eUXW7AkIjI7BkpKMz8/P9s1a5FEZBXso6Q0a9iwoZQsWVJCQkKMLgoRUbZhjZLciomJkaSkJNs2gyQRWQ0DJaVq7dq1Eh0dLXPmzFEp6oiIrIiBklJVunRptVxWuXLlVIo6IiIrYh8lpQoBctCgQWq5LCIiq2I1wUKCCvjK0HaV1bUrmPKxadMmuXbtmm0fgyQRWR0DpYUEBfjJsA5V1HVquVuXLl2q5krevn0728tHROSJGCjJpnr16hIQECANGjRQfZNERMQ+SrJTuHBheeGFF8TX13XTLBGRFbFGaWHok1y1apWcOnXKto9BkojIEQOlhW3dulVWr14t33zzjVy/ft3o4hAReSQ2vVpY7dq1Vead0NBQyZcvn9HFISLySAyUFoZm1oiICCYTICJyg7+QFuuTXLZsmezevdu2j0GSiMg91igtBAFy48aNKjiWKlVKChUqZHSRiIg8nkdUJ6ZMmaLSpWGdw8aNG8vmzZtTvW9UVJRaC9H+oq+TSO7VqlVL6tatK507d2aQJCLylholVqYYPny4TJ06VQXJiRMnSseOHWX//v0SFBTk8jGYFI/bdVxE2H1zK+gnFY888ghfLyIib6pRTpgwQQYOHCiRkZFSo0YNFTAxAnP69OmpPgY/9MWLF7ddgoODU71vYmKiXL161eFipSC5ZMkS+e233xwCJhEReUmgvHXrlmzbtk3at2//T4Fy5FDbyDuamvj4eClbtqxaBqpbt26yZ8+eVO87btw4ldhbv+AxVnH06FE1VxLrSp45c8bo4hAReSVDA+WFCxckOTk5RY0Q26n9sFetWlXVNn/44Qc1UR4LCjdr1kxOnDjh8v4jR46UuLg42+X48eNiFeXLl1fN2I8++qiEhIQYXRwiIq9keB9lejVt2lRddAiSSOb92Wefydtvv+1yrqCV0rKhiRUnDzlz5lTbTZo0MbpIRERezdAaZWBgoPpBP3v2rMN+bKPvMS2wykW9evXk0KFDYnUIkosWLZJ58+apmjoREXl5oMyTJ49a0mnFihW2fagNYdu+1ugOAgLSsLFpUeTcuXOya9cuOXDggKWamImITN30iqkh/fv3l4YNG0qjRo3U9JCEhAQ1Chb69esnJUuWVINyYOzYsao5sVKlSnLlyhX54IMP5NixYzJgwACxOvTt9unTR27cuKHmpRIRkQkCZXh4uJw/f15GjRqlBvBgQvzSpUttA3xiY2Md0qxdvnxZTSfBfbF+Imqk69evV1NLrAg1cEyByZs3r9quWLGi0UUiIjIVH02fYGcRmEeJaSIYAYvEBd4eJDH6FycNqJVzBRAiosyPB4YnHKCMw3zSw4cPqxr5yZMnjS4OEZEpGd70ShmHMyDUJDEftXLlykYXh4jIlBgovbC5Fc0E6J/Vp9jgQkREWYNNr14WJL///nv54osvUsw9JSKirMFA6UVu374tly5dkps3b6qpMURElPXY9OpFkIrvqaeektOnT0uFChWMLg4RkSWwRunhkHnIPssO5ksySBIRZR8GSg8PkgsWLJCoqCjZt2+f0cUhIrIkBkoPhkWWkTRevyYiouzHPkoPhtR93bt3VwniS5QoYXRxiIgsiTVKD2xu3bNnj0OwZJAkIjIOa5QeNk9y7ty5apksTP9o3ry50UUiIrI81ig9CGqPpUqVkly5cqV54WoiIsparFF6mJYtW0poaKgUKlTI6KIQERFrlMZLSkpS62mi2VXHIElE5DlYozQQlgKdP3++7N+/Xy2V1a1bN6OLRERETlijNBDmR9arV0/8/PykTp06RheHiIhc8NFQrbGQtK5onZ2Q5BzBkoiIPC8esEZpwAogS5culRs3btj2MUgSEXkuBsps9uOPP8qmTZvUfEmLVeaJiLwSA6UB0z8KFy4sbdu2VX2URETk2dhHaVCaOiY5JyIyFvsoPcStW7fUFJALFy7Y9jFIEhF5DwbKLPbLL7+oJOffffedQ1IBIiLyDkw4kMUeeOABlUygQ4cOKpcrERF5FwbKLIBuX32gTr58+SQiIoIDd4iIvBSrOJksMTFRvv76azl06JBtH4MkEZH3YqDMZEhwfuTIEfnhhx9UcgEiIvJubHrNZK1atVJDjsPCwiR37txGF4eIiO4TA2Umz4vENVcBISIyDza9ZkJC8xkzZsiGDRuMLgoREWUBBsr7tHv3bjl58qSsXbtWrl+/bnRxiIgok7Hp9T41aNBArQRSuXJlNRWEiIjMhYEyg1NAMFAHCQQw9QOJzomIyJzY9JpOqD1GRUWp5bKYko6IyPxYo0wn9EeePXtWTQHBpVChQkYXiYiIshADZTpVqlRJevbsKYGBgQySREQWwECZBhjNivmRvr6+artGjRpGF4mIiLIJ+yjvISEhQWbOnCmzZs1Sg3iIiMhaWKO8h/j4eNUXmStXLhU09VolERFZAwPlPQQHB0u/fv3UdJAiRYoYXRwiIspmDJQuoOZ469YtKVy4sNoOCQkxukhERGQQ9lG6aGpFnyTmSl6+fNno4hARkcEYKF3QNE1dmFCAiIjY9Ookf/78qk8Siy6zT5KIiBgoReTatWuqmbVMmTJqu0CBAkYXiYiIPITlm171Psmvv/5ajh07ZnRxiIjIw1i+Runn56dGtyYlJUlAQIDRxSEiIg/jETXKKVOmSLly5VTQaty4sWzevDlNj/vuu+/UMlePPvpohp8biQTCw8Pl6aeftk0HISIi8phAOWfOHBk+fLiMHj1atm/fLnXq1JGOHTvKuXPn3D7u6NGj8vLLL2d4LciYmBiHYMnaJBEReWSgnDBhggwcOFAiIyNVsvGpU6dKvnz5ZPr06ak+Jjk5WZ588kkZM2aMVKhQIUPP+9NPP8kff/xxHyUnIiIrMLSPEtlvtm3bJiNHjrTty5Ejh7Rv3142bNiQ6uPGjh0rQUFB8swzz8jatWvdPgcSmdsnM4+Li1PXefPmVdM/kMeViIis5+rfv/+YN++xgfLChQuqdoh8qvawvW/fPpePWbdunXz55Zeyc+fOND3HuHHjVM3TGZp6cSEiImu7du2aFCxY0ByjXnEwffv2lc8//1wtnJwWqK2iD1R35coVKVu2rMTGxrp9Ycx0xlS6dGk5fvy4JfphrXS8VjpWqx2vlY7VyONFTRJxpUSJEm7vZ2igRLDDgshnz5512I/t4sWLp7j/X3/9pQbxdO3a1bZPTzOHATn79++XihUrOjwGy2K5WhoLQdIKH0AdjpXHa05WOlarHa+VjtWo401LhcnQwTx58uSRBg0ayIoVKxwCH7abNm2a4v7VqlVTo1XR7KpfHnnkEWnbtq36G2ckREREmcnwplc0i/bv318aNmwojRo1kokTJ6plrjAKFpB3tWTJkqqvEfMsa9Wq5fD4QoUKqWvn/URERKYIlJjsf/78eRk1apScOXNG6tatK0uXLrUN8EFfIkbCZhY0w2IQj6vmWDPi8ZqXlY7VasdrpWP1huP10e41LpaIiMjCDE84QERE5MkYKImIiNxgoCQiInKDgZKIiMhqgdLIZbs8/XijoqLUMdpf8DizvrfIxDRo0CAJCQlRI+qqVKkiS5YsETMeb5s2bVK8t7h07txZzPr+YjpZ1apVVe5mzKMeNmyY3Lx5U8x2rLdv31Y5rpFQBffHKkuYHeAt1qxZoxLFIAMOPpMLFy6852NWrVol9evXV9/bSpUqqd8uw2gm891332l58uTRpk+fru3Zs0cbOHCgVqhQIe3s2bNuH3fkyBGtZMmSWsuWLbVu3bppZj3eGTNmaAEBAdrp06dtlzNnzmhmPNbExEStYcOGWqdOnbR169ap93jVqlXazp07NTMe78WLFx3e1927d2s5c+ZU77kZj3fWrFmar6+vusZ7u2zZMi0kJEQbNmyYZrZjffXVV7USJUpoixcv1v766y/tk08+0fz8/LTt27dr3mDJkiXa66+/rkVHR2OWhfb999+7vf/hw4e1fPnyacOHD9f27t2rTZ48WX2Wly5dqhnBdIGyUaNG2qBBg2zbycnJ6gM2bty4VB+TlJSkNWvWTPviiy+0/v37e1WgTO/x4kezYMGCmjdK77F++umnWoUKFbRbt25pVvks2/vwww+1AgUKaPHx8ZoZjxf3feCBBxz24Ye1efPmmtmOFScAH3/8scO+Hj16aE8++aTmbSQNgRInBjVr1nTYFx4ernXs2FEzgqmaXvVlu7BMV0aX7bLC8cbHx6vE8Giq6tatm+zZs0fMeKw//vijSoWIplcksED2pvfee0+tWGPW99YeVtnp3bu3+Pv7ixmPt1mzZuoxepPl4cOHVbN6p06dxGzHiqUCnbtI0NyM1ZTMaMOGDQ6vD3Ts2DHNn/3MZqpA6W7ZLmT9cbdsF1YkscLxoj8Hi2L/8MMP8s0336jcuvjBOXHihJjtWPHDOX/+fPU4/IC++eabMn78eHnnnXfE02XkeO0heOzevVsGDBgg3iAjx/vEE0+ok9wWLVpI7ty5Vf8d+mlfe+01MduxIkhgkfuDBw+q7+zy5cslOjpaTp8+LWZ05swZl68PVhm5ceNGtpfHVIEyO5bt8naoYSF/LlIFtm7dWn3ZihUrJp999pmYDX5Q0FIwbdo0lXwf6RJff/11mTp1qpgdTv5CQ0NV/mSzwmAPtBB88sknsn37dvVZXrx4sbz99ttiNpMmTZLKlSurhSGwmMTgwYNVPuzMTO9JHpzr1duW7fLm43UFZ+L16tWTQ4cOiSfLyLFipCuOD4/TVa9eXZ2tovkLPzhmfG+xqABGcKO25S0ycrxoIcCJrl5rxokBjv3ZZ59VJ0SeGkQycqw4mcVIUYzovXjxoho9OmLECKlQoYKYUfHixV2+PliCC03O2c0zP0kZZLVlu9J7vK6gCQivAYKK2Y61efPm6gRAP/mBAwcOqGP15CB5v+/tvHnzVJ/WU089Jd4iI8d7/fr1FMFQPyny5BTW9/Peop8SqyklJSXJggUL1BgDM2ratKnD6wNobk7r71qm00wGw64xZDwqKkoNK3722WfVsGt9CkTfvn21ESNGpPp4bxv1mt7jHTNmjBpGjyHm27Zt03r37q2GmWOIutmONTY2Vo36HDx4sLZ//37tp59+0oKCgrR33nlHM/NnuUWLFmqEoLdJ7/GOHj1avb+zZ89W0wl++eUXrWLFitrjjz+ume1YN27cqC1YsEB9b9esWaNG+5YvX167fPmy5g2uXbum7dixQ10QdiZMmKD+PnbsmLodx4pjdp4e8sorr2h//vmnNmXKFE4PyWyYc1OmTBk1TwnDsPEh07Vu3VoFQ7MEyvQe74svvmi7b3BwsJpj6C1zsTLy3q5fv15r3Lix+lHCVJF3331XTQcy6/Hu27dP/RAhaHij9Bzv7du3tbfeeksFR5zslS5dWnvhhRe8Jnik51gx/7d69erqc1y0aFEVVE6ePKl5i99++019Lp0v+jHiGsfs/Ji6deuq1wffXSPnA3OZLSIiIqv0URIREWU2BkoiIiI3GCiJiIjcYKAkIiJyg4GSiIjIDQZKIiIiNxgoiYiI3GCgJCIicoOBkogcYKmqF198Mc33j4qKkkKFCmVpmYiMxEBJRETkBgMlERGRGwyURF7UJDpkyBDVLFq4cGG14jsWHccajFjEt0CBAlKpUiX5+eefbY9ZvXq1WrzZ19dXLS+GNQyxRJMOj8VC3vnz51e3jx8/PsXzYsmul19+WS3v5O/vL40bN1aLJhNZBQMlkReZOXOmWvh38+bNKmg+//zz0qtXL2nWrJls375dHnzwQbWYMdZqPHnypHTq1EnCwsLkjz/+kE8//VS+/PJLeeedd2z/3yuvvKKC6Q8//CC//PKLCoD4f+wNHjxYNmzYoBaD3rVrl3q+hx56SA4ePGjAK0BkAMPWLSGidMEyRFhrUoflwvz9/R3W8Tt9+rRavmjDhg3aa6+9plWtWlW7c+eO7Xas65c/f34tOTlZrRGIJYzmzp1ru/3ixYta3rx5taFDh6ptrBeIdQCdl3Rq166dNnLkSPU3lj8qWLBglh47kZFyGRGciShjateubfs7Z86cUrRoUQkNDbXtQ3MsnDt3Tv7880+1IryPj4/t9ubNm0t8fLycOHFCLl++LLdu3VJNqboiRYpI1apVbdsxMTGSnJwsVapUSdEci+cmsgIGSiIvkjt3bodtBEH7fXpQvHPnTqY8H4IqAvK2bdvUtT30axJZAQMlkUlVr15dFixYgO4VWwD9/fff1aCfUqVKqdojguymTZukTJky6nbUMg8cOCCtW7dW2/Xq1VM1StRQW7ZsaejxEBmFg3mITOqFF16Q48ePq0E/+/btUwN2Ro8eLcOHD5ccOXKoGuEzzzyjBvSsXLlSdu/eLREREeo2HZpcn3zySTUyNjo6Wo4cOaIGEo0bN04WL15s6PERZRfWKIlMCtM5lixZogJhnTp1VA0SgfGNN96w3eeDDz5Qzatdu3ZVNc2XXnpJ4uLiHP6fGTNmqJGyuA0jaTHqtkmTJtKlSxcDjooo+/lgRI8Bz0tEROQV2PRKRETkBgMlERGRGwyUREREbjBQEhERucFASURE5AYDJRERkRsMlERERG4wUBIREbnBQElEROQGAyUREZEbDJRERESSuv8H6vboAQ3UzVQAAAAASUVORK5CYII=" + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAcoAAAHWCAYAAAD3iMk8AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAABSMklEQVR4nO3dB3QU5doH8CeFTkICoffekQ6hyqXDRYhAUEFCk+ancOHeS7lKsyDXCzYElBoLCFGpohQFaaF3pHdCCTUJTSDMd/6vzrqbbJYkJJndmf/vnDmbnW1TNvvM257XS0Q0ISIiIqe8na8mIiIiBkoiIqInYImSiIjIBQZKIiIiFxgoiYiIXGCgJCIicoGBkoiIyAUGSiIiIhcYKImIiFxgoCS3Vbx4cdE0TYYPH270pljmWIeFhdnWjR07Vq3LaEZ9LlFSGCgtoFKlSvLll1/KhQsX5P79+xIVFSVfffWVWm81wcHB6oc4V65cRm+KpWXLlk2dh6ZNm4pVv2+jRo2Sjh07GrJdlHK4dONi0mMQEhKi3b9/X7t48aL21ltvaX369NEmTJigRUVFqfWdOnUyfBuTWooXL67B8OHD0+w98V6A9zZ6/9zxWIeFhdnW+fj4aFmyZEmXz8uTJ4/6vLFjxyZ6LD0/N6MXV9+3uLg4be7cuYZvIxd54jHwTUVgJQ9RqlQpVZI8deqUNGnSRK5du2Z77KOPPpKNGzeqx6tVqyanT582dFspbWXJkkUePHjwVFWY8fHxasloRn2uGaTFeSfneEVh0mMwffp0dTXbqFEjp483btxYPY7n6etwhQ+lS5dWV7s3b97Ubt26pc2ZM0fLli1bovfo3r27tnPnTu3u3bva9evXtQULFmhFihRJ1vbVqlVL++mnn7SrV6+q1586dUqbPXu20xLlK6+8op04cUKVgrdv367Vrl070fs1a9ZM27Bhg3b79m213UuWLNEqVKiQaN8SelLpcvDgwdrJkyfVNm7btk0dz3Xr1qnF/nmZM2fWxo0bpx0/flxt57lz57RJkyap9fbPg08++UTr2LGjduDAAfXcgwcPaq1bt0702YUKFVLH5PLly7bn9e7d2+E5TZs2Ve/ZrVs3VWtw4cIFLT4+XsuVK5cWGBiovf/++9r+/ftVCSYmJkZbuXKlVq1atSeWKPXjpd/H9yEpeskwU6ZM2vjx49V3At8bnAuck2effTbRZyX1Hgk/Vy9lvvHGG7bvwOnTp7V33nkn0bHF+uXLl2sNGzZU5+revXvq3L388stP/D7af9+GDh2qnTlzRp3z9evXa5UrV3Z4btWqVdXxwHvjMy5duqTOU+7cuZP1fXPGvnT5tOcd74XzjfdZvHix+js6Olp9F7y9vR3eB6/H+YqNjVXfD3xXXn/9dcN/v8SNFpYoTaxDhw6qpLhp0yanj6NEicfbt2+f6LFFixapx9COUrNmTXnllVckOjpaRo4caXvO6NGj5a233lLPnTVrluTNm1dee+012bBhg9SoUUNiYmKS3DY8d/Xq1XL16lV577335NatW1KiRAl5/vnnEz33pZdeEj8/P/nss8/UlfK///1v+f7771WJ+dGjR+o5zZs3lx9//FGVnseNG6fawLAtmzdvVtt/9uxZ9Zpy5cqp9xs6dKithI1tSMrAgQPl008/Vfv0wQcfqG1csmSJ3Lx5U7X56ry8vGTZsmXSqFEj+fzzz+Xw4cNStWpV+cc//qE+MyQkxOF98Tzs67Rp0yQuLk5ef/11+e6776RYsWJy48YN9Zx8+fLJ1q1b1T5PnTpVbWfbtm1lzpw54u/vr2oF7L355puqNPG///3PVrJAO3SnTp0kIiJCnc/8+fPLgAED5Ndff1WPXbp0SZILx3/t2rUO69q0aSM9evRQ3w3AdvXr108WLFggM2fOVOetb9++smrVKqlbt67s27dP7QeO64wZM9Q5wQL79+9P8rPx/erVq5faj8mTJ0u9evXU969ixYqJvjNlypSRb7/9VmbPni3h4eHSp08fmTdvnuzatUt+++23J+5nz5491XbjvGfNmlWGDBkiv/zyizqf+n62bNlSff/mzp0rly9flsqVK0v//v3Vbf369dVzXH3fcMywT9u3b1ffFzh58mSanXfw8fFRx33btm3yz3/+U1q0aKFu8Tk49oB133zzjTqvI0aMUOtwTBs2bCgff/zxE4+VlRgerbmk/THw9/dXV5u4mnT1PJS6IGfOnA5XwbNmzXJ43nfffadKfvr9YsWKaQ8fPtRGjRrl8DxceT948CDR+oQLSlOAUmVSz9GvvPG5AQEBtvUdOnRQ69u3b29bt3v3bnX1jRKU/VX/o0ePtHnz5qWqjRKlI3w2SiYo0ejre/bsqd7DvkSJkjU+CyUZ+/fo37+/em5wcLBtHaCUUKpUKYdthVdffdW2bubMmaot2b6UgmX+/PmqxJw1a1aHkgVKW/o6fUGJy8vLK9FxRSkIJbSUlCgTLqh1wHasWrXKVkrBLY6b/fNQwkGJy/475aqNMuHnovQLn3/+ucPz/vvf/6r19qVVlCgT1qIEBQWp/UVpytX51o/BnTt3VElMX1+nTh21fvLkybZ1CY+zXjJL+NmpaaNMi/Oul/7tzzGWXbt2aTt27LDd/+CDD1TJP2Epk4s4HAP2ejUpXBEDSiuu6I/jStWefsVpX/oMCgqyvS+u4r29vVVpMk+ePLYFV9fHjx+XZs2aufxclCDh73//u/j6uq7YWLhwoe35+rYAruihQIECqgSLUgNKeroDBw7ImjVrpF27dpIatWvXVvuMkpF9m9nXX39tK/XpunbtqkqRR44ccTgeKIlAwuOBK3iUfu23FSVwfZ+gc+fOsnz5clVatX9PlBICAgJUSdkeSk/o1WzPvr0K5yt37txy+/ZtOXr0aKLXp0T27Nll8eLF6ni/+OKL8vjxY7Uetw8fPlR/Y7sDAwPV+d25c2eqP08/f1OmTHFYj5IlJKwROXTokEMtCkpy2F/7Y+sKagwuXrxou79jxw5VwrP/HtkfZ5TicF7wHHia45pW593V/7H9ccD/VY4cOVQJmZLGqleT0gOgHthSGlDPnTvncF8PQPjhw3PLli2rfnhPnDjh9H31H0v8E+bMmdO2HgEHP1yo+kP1GKpJUT25fv169QM1f/58W9VRUtuiB01siz4GEPBjmBCCF6oH8cN+9+5dSQn9fRPuI/bhzJkzDutwPFCVad9hyh6q01ztk36M9X1C1TT+RjUpluS8p7MOWfixRdXh4MGDpWTJkg4XJdevX5fUwsVD6dKlpUGDBokuGlB1ibGvFSpUkMyZM9vW218YpPQ84JgnPA9XrlxRx0w/T8k9tk+CC72Ejh07JqGhobb7eC8M+3jhhRdUdba9pxl6lFbnHe7du5fo+4jjgIslHar+sV8//fSTakpAcwgufhGU6S8MlCYVGxurrorRo9UVPI5/kISBMqleh/jhBQRJlB7QduLsuSi1ANpEEAx1CDD4wdZLYWhrQltq69atVXsPfmDRxnPnzp1kb4s7wPFAG9uwYcOcPn7+/PkUH19Ar2SUGJxJ2KaHH8aE0I739ttvq/Y6tGUhqOG8ffjhh7bPSCm0p6LdrXv37qrN0R7WYXtR2nz//fdVmx72FW3dCKxPI7k9OTPi+4JggosE7OPevXvV9x3HEwEmtcc1Lc87JKfnMNo/q1evrv7/8L+MBW26+Gy0CdMfGChNbMWKFaqDARrm0aklIXQoQdBKWD2THOgQgH9qXM06uwLXffHFFw7VYAn/qdHRAMsbb7yhqvBQosRVOn7YkwsddaB8+fKJHkOpBj8GemkyJd3m9fdF5xCUeHXoJIFOPfY/WDgezzzzjPz888+SFrDNuNjBZz3Ne3bp0kVV/6KDjT1U4SVV+nUF3xl0GkHHJpwrZ5+HY5Gwg8348eMd7qf0POA4oNSOqm37khVKX/p5Siv4nITQKUevRcCxQyeYMWPGqM5sOnxPEnK1n84eS6vznhKo/cFvBRZcTKCUic5W2De9g5HVsY3SxHC1iwCB3or21S2AHxgESJTc8LyUQo8+9DhF9ZMz+uchkOIfXl+2bNli+7FJCFfmeptPSqBddM+ePSr9mn21F3ogtmrVSlauXGlbp5dUnX1+QmhXQzBBj1/8cNmXmhIeT5QwihQpop6bEHpOouo3JVDqQy9YtFdhPxJC22lyoFSRsCSFYIZtTSm0BWM/ceHzr3/9K8nPA/vPRG9XZKixp1+4JOc86OcPPUft6aX3H374QdISegkXKlTIdr9OnTqqlgO9qpPaR2fb96TvGx5LuD6tzntyJfweI3jrF4Ap/T80M5YoTQxtOgge6HyCziIopSFwoTSELvv4p0MpLjVtR3gNSoEY2qEPmUD1LUqoGAqBLu96ZwtnsF1oN0MVHa5a0VaKIIMOLfaBLbnww40fssjISLWf+vAQvJ991S+GCMA777yjusXjahodJ5y1X+IxvBZd9FEqQ5DAvqJKCsfWvkSAqjK09eDiAx13UIJHcEWJFutRtaV/dnJhKA7eCyVutAliaAN+2NCZAyUadPB4EpQScDGDoQW4SMEQBwT61JQUMFwAbWj//e9/VanfHn5c8R3D5+FHHucVAQzfB5ROsO32bdXofIJON926dVPtf6gSPnjwoFqXEN4bHbXQZofAgvZtBF+cB3yOfWk/LeDc4mJg+vTpKljoQzuw34DvObYBw5QyZcqkUkLigkxvUrDn6vuGx3Ae0UaPZhL8b2K4SFqc9+TCEBW8N77faIJBey/+b3DhifZ9+gu7Apv8GFSpUkX7+uuvVZfz33//XaWzw/2Eg6jtu+aj+779egwbcNbNHSnyMKAcXd2x/Pbbb2owfdmyZV1uU/Xq1dU2YFA3uu5jaMeyZcu0mjVrJiuFnbOhBX/729+0jRs3qu796PK+dOlSh4QD+vKf//xHO3/+vBrOkZyhIv/3f/+nhh1gO7du3aqGeqCLPQbu2z/P19dX+9e//qWSCOC5SMCA57355puan5+fw7bjGCX8HHxGwuECefPmVc89e/as7dytWbNG69evn+05+jCBzp07J3pPDA/BsAicexwXHJ969eolSpiQnOEheH5S7M/FyJEjbccLwxHatWun9gvr7Letfv366vhgqExyEg7gOGKAP44DjoerhAMJj4OzBBEJF/vv2z/+8Q/1GdiHX3/9VQ3fsX8uho9gyNSNGzfUkI2FCxdqBQoUcPq9TOr7Vq5cOZXMAOclYcKBpz3vesKBpP6/9fvPP/+8SvqhJzbA/yMSkOTPnz9df5PE8xbDN4ALj4FHfQcwLvHatWuJxvVx8exjkB65hbmIKY4B2yiJXHDWToPhD6j+SusqPyJyT2yjJHIBnTjQwxOp0zDuEO1EaN9FexzWEZH5MVASuYAhARgDibGD6PSATicY8oIOF3pSBSIyN68/62CJiIjICbZREhERucBASURE5IIl2yiRdeNJs2oQEZH5IdmJ/WwxzvhaMUgikwYREREULlzYZbC0XKDUS5I4MCxVEhFZuzQZFRX1xFhguUCpw4FhoCQioidhZx4iIiIXGCiJiIhcYKAkIiJygYGSiIjIBQZKIiIiFxgoLcAvKI+0GtRX3RIRUcowUFqAf9480npwP3VLREQpw0BJRETkAgMlERGRCwyURERELjBQEhERucBASURE5AIDJRERkQsMlERERC4wUBIREbnAQGnybDwFy5WR+l06OX2MmXqIiJ7MshM3mxWCX3DXTnJm7wGVjefq2XPSIDREPZYjIEA6DH9NcuQOkDrPtVPPXT19tsRdu270ZhMRuS2WKE2ari5HYC51v9WgfrbHgooVlmd7vaSCJCCAFixbyrBtJSLyBAyUJpevRDHb39n8/BI9niMwIIO3iIjIszBQEhERucBASURE5AIDJRERkbsGysaNG8uyZcskKipKNE2Tjh07PvE1TZs2lV27dsn9+/fl+PHjEhYWliHbSkRE1mRooMyRI4fs27dPXn311WQ9v0SJEvLDDz/IunXrpHr16vLhhx/KrFmzpFWrVum+rZ4iZ+5AdZunSKFEj+Ut/lfHHp2z5xER0V+8REQTN4ASZadOnWTp0qVJPue9996T9u3bS9WqVW3rFixYIAEBAdK2bdtkfY6fn5/ExsaKv7+/xMXFiZnUDekgXceNFG9vb3U8vbxwev+S1LodS1fKwjffzuCtJSIyVnLjgUclHAgODpa1a9c6rFu1apUqWSYlc+bMkiVLFocDYyZIGlCwbGnJW6KohIwcJl7ef1QSJAyIrtbV6dhOAgsXkEvHTsjZvQfl5M49TEJARBnC29tbAgMD5fp190184lGdeQoUKCBXrlxxWIf7uXLlkqxZszp9zahRo9QVg76gPdRMkIVnwOcfyfOj/2kLkimFYFm2Ti1p0r2bvPz+W+o9iYgyQps2baRfv35SsGBBtz3gHlWiTI2JEyfKlClTHEqUZgqWkRFLVLq6hCXKlED164mdux1KlEREGWH79u1Srlw59dt86dIltzzoHhUoL1++LPnz53dYh/sxMTGqF6wzDx48UItZ6Xla79y6JSd37ZUydWqmOEhePHpcvv73WFa3ElGGu3btmkydOlUePXrktkffo6peIyMjpXnz5g7rWrZsqdZbGapKhy0KT3GQhC3ffCeFK5RTOWKJiDKiTbJDhw6SL18+2zp3DpJuMTzkmWeeUQuULFlS/V20aFF1/91335Xw8HDb82fMmCGlSpWSSZMmSfny5WXQoEESGhoqH3zwgVgZql+nhIap5asRY2wlxYS2L16RaF1M9NUM2UYiImjWrJnUqlVLunfvLr6+nlGpaehW1q5dW9avX2+7rwe8efPmSe/evVXjbrFif439O3PmjBoegucNGTJELly4oBqBV69eLVaG6teEU2Vt/W6pBCeYh/LaufMZvGVERI42b94sxYsXlw0bNrh9SdItAuWvv/7qdMiCDsHS2Wtq1kx5FaPVnNyxO1GgJCIy2v3792XOnDniSTyqjZKIiDyLj4+PaiJDc5mnYqAkIqJ0U7duXalUqZKEhIQkOd7d3XlGSyqlm3smS+NHRO5l27Ztahjf/v37kxzG5+5YojSZ2KvXZdW0WXLnZkyix66dj1JjJnX7Vv8i186ZJ/kCEbkHL7u+J48fP5YlS5bIqVOnxFMxUFrAuf2HbL1ePx/4D/nt183q/smdu1WiAiKitOLr6ysvvfSSNGrUyDQHlYHSZJA4oPXgfmpSmONbd6h15w7+Znu8YuMGUqFxsPq708hhUqVZE8O2lYjMp0KFClK2bFlp0qSJmpXDDNhGaVJ3bsXI/rXrpWz9OvJYe6zWlaheVQVHZMYA3LYY0Nv2GKptE47HJCJKiYMHD6qJKjDOHRNRmAFLlBboqFOpyR9VIJhhRA+SOv0+Husy5t8GbCURmaG61dvutwVJBc6ePStmwUBpYndu/tH+GFS0sLpd+dF01bCeFATU8g3rSeGK5WwL5rskIkpKpkyZVJskhn8kvBA3C1a9mrz61V5AwQIuv8jePt7Sf4bjJNjoQbt6+ux020Yi8myFChVSKemQji5Pnjxy9ar58kczUJpYztyBDvcPrF0vp3btkR6TJqj7KF3aB87H8fEy69XhcvvGTds6tFsSESUFVayLFi2Su3fvmjJIAgOlSaE3q95RR4ehIPbDQdZ+Nlda9O8l3j4+KkhGjJ8kRzdvM2BricjTqlt9fHxsCQSOHj0qZmbOCmULyxEQoG4RJBNWs6Jna76SxW33D67boEqQgNvti5dn8NYSkafJnDmzmiLr5Zdf9tiUdCnFEqXJVG3xrLp11haJnq0J6dWs9tWtRERJ8ff3V5Mu4zcmICBALl++bPqDxUBpMqd27pEGoSFOH/v+3f/J3ZhYWxslEVFKXbt2TcLDw9WQECsESWCgNJEmPV+Q5/75uu2+fWcdzE+5f816lbmHiCglsmTJIjly5JAbN26o+1euXLHUAWSg9GAY46gHPvRw7TD8NYdkxPZTYkd+u8SALSQiMwTJHj16qGrWefPmyfXr1usJz0DpwYK7dvozr6tzXnbtlKhuxZjIQ+s3ZtDWEZEZ+Pj4qA48qGrFrRUxUHqwyIgltsCHEmW/aVMcx0XaVb3i7/t37ti9drEaI8mqWCJy5e7du6pN0s/Pz3JVrjoOD/FgSGAedfiYWjD+ccOXCx0et6+GRcDsMOz/1BAROLlzjwqS+nASIiIdhn0UK1bMIVhesWiQBJYoTSRztqxJBkpAYgF9iIje83XLosUZuIVE5AltkhgjmT9/fpk/f75HT7icVliiNBGkqLOnJUiAjuw7GCICX40YI1NCwxK9hoisDTlb4+Li5MGDB3LHrrnGyliiNBH79HSw9ftlEtylk/pbT1EXdeSPVFPRp8+qKlv0nEUnH+Z0JSKIx29FRISaU1IfDmJ1LFGa2Mntu2Xn8h8dUtTpidL1W7RzYnYQTthMZF3ZsmWTqlX/6L+gB0sGyb8wUJrYS++NkxsXLtpS1NUN6aB6xgJucZ+IrA0Jznv27CmdO3eWWrVqGb05bolVryZKOlCxcbDDY+jpqs8gUr11c3m2dw/bcBHcdh07QmKio1UQRdUrS5VE1vPw4UM5fvy4Gv5x7tw5ozfHLaFbpCYWgi9DbGysSuyLBmtP12pQX5dJB5KLEzQTWRtS1Fmt845fMuMBq149vDR5Zu9+1ZMVCQWc0df/MvsLp71gPx84VPV+RfICIrKG7NmzS9OmTR2GkFktSKYEq15NnMIOTu3aK2Xq1JS9q36WRw8eqhIocKJmImtCswvGSRYsWFClpFuzZo3Rm+T2WKL0YCgFojSIUqGzEuWPn8yQn2eGO0zUrONEzUTWhN+KTZs2SUxMjOzevdvozfEILFF6MHS+0TvgRIx7T3XOQfYdTdNUlcrhjZFJvpYTNRNZ16FDh+To0aMquQA9GUuUJoExkiglwuKJk43eHCJys446HTt2dJj9g0Ey+RgoTUQvJeqddpDwHMM+mHmHyNq6desmNWrUkOeee87oTfFIDJQmlM3PT93mCMzFzDtEJD/99JOa/eOXX37h0UgFtlESEZncxYsXZcaMGar/AqUcS5RERCYcSI8hIIGBf+R0BgbJ1GOgJCIymb///e9SunRp1YGHnh6rXi1EnzGEiMxt+fLl4uPjIytWrDB6U0yBJUqLsJ85BKo0a2Lo9hBR2rJPR3f79m356quv5FaCOWopdViiNKF7fyb3zeaXUwpXLKdKkl3HjbTNHAKYVeTMvgO2ISWcPYTIc2GS5ZdeeklWrlwpZ8+eNXpzTIeB0oS8/gyInd/4d5LPQdDsP+ND233OHkLkuRo3biz58+eXtm3bymeffcaOO2mMgdKEOo0cZvs78tslcmDtelXtal+iRL7HWYOHOZQoichzx0nChg0bGCTTAdsoTTTlVr4SxdU/iX1ArPf8H5k41n42Vx7HP7Zl7lk++RM5unmbRB0+phZO2kzkWTJlyuSQjg4ddzC3IqU9lihNPuWWfRXrzuU/Su0ObWXm4GEqSBKRZwoICJCwsDA1C8iuXbuM3hzTY4nSRFNuOZtuC/f1yZl3Lf+jekZ7rKl5KVEKJSLPU7VqVZVMIDg4WHx9Wd5JbwyUJoGqU5QSMd2WXsWqV7nqVax3/uwqjhywKH3652WgJPJEGzduVBMuh4eHcxaQDMBAacLptpZMmuJ0smYi8uypsuxt3rxZ4v4cCkbpi4HShO7GsEGfyExy584tAwYMkHbt2hm9KZbEQElE5OYKFSqkEp2XLFlSsmbNavTmWI7hgXLw4MFy+vRpuXfvnmzdulXq1KmT5HPRaP3mm2/KiRMn1PP37t0rrVu3ztDt9TTM70rk+Q4ePCgREREyb948uX//vtGbYzmGBsrQ0FCZMmWKjB8/XmrWrCn79u2TVatWSd68eZ0+/+2331bVD6+99ppUqlRJza+2ePFiqV69eoZvuzsrXaem7W8kGkCeVyLyLOjVaj9W8rfffpM7d+4Yuk1WZWigHDZsmMycOVNdJR0+fFgGDhwod+/elT59+jh9PuZXe/fdd+XHH39UpVAESuQ2HD58eIZvuzvCcI/yDetJ/T+TDOjjKLuOHSGFK5QzdNuIKPmCgoLU7yDyt9oHS7JYoMTJr1Wrlqxdu9a2DlllcB9jg5zJkiVLomoHVME2atQoyc/JnDmzqtu3X8ycdADJBfRcrzpvHx9p1D3UsO0iopRBOyR+u7Jnz85AaeVAiSsmtDleuXLFYT3uFyhQwOlrUC2LUmiZMmXUlDItWrSQ559/XgoWLJjk54waNUqlddKXqKgoMXvSAaSos/c4Pl42fb3IsO0iopS5cOGCfPHFF2qcJGrZyOKdeVJiyJAhcvz4cTly5Ig8ePBApk6dKnPnzk2UjcbexIkTxd/f37YULlxYzJ504NcvFzoEyYjxkyTqyDGV+ByzhNy5yTnqiNwNCg/4jdLhop5B0uKB8tq1ayqjBKaGsYf7ly9fTvI1ISEhauBt8eLFpUKFCmqC0lOnTiX5OQioGJRrv5jdsci/8rjOenW4SkKgB9LV02fbqmbZI5bIPaADY69evdRiHyzJ4oHy4cOHKplv8+bNbetQnYr7kZGRLl/7+++/y8WLF1XVbefOnWXp0qUZsMWeAT1c0dNVV+KZqkk+zh6xRO4BF/T4TcRvG27JvRiaTRdDQ1AHv3PnTtm+fbsMHTpUlRZRnQp4DNUPo0ePVvfr1q2rqk4xfhK348aNU706//vf/4pVe7na52tFCbHruJEO02y1GNBbbt+8qbL1ZM/lr+aq1B/Xe8TGREfb5qUEVNFy2i2ijBMTE6N+9xAk0UGR3IuhgXLRokWqymHChAmqAw8CYJs2bSQ6Olo9XqxYMYf2R/QEw1jKUqVKqSpXDA3BkBF8yawoqam17CEYPj/6n0k/7uNjm4ZLh3ZMVNESUfpBMxN6/6PjDnAuSfflhVEZYiEYHoIvJNoBPL290lmJEtWp9iVKXGgseW+K0xKlejw+XrVjskRJlPHjJH18fNQ48kuXLvHwu3E84ERmHgzVowmrSDHNFqpTUVLUp9navOA72+MP7z+wVc8iiKJHLCdxJspYqAXDUDiUKG/e/KvZg9yXZqXFz89PA9wavS3ptZRvWE+bfCBSLYUrlkv0eMMXO6vHcGv0tnLhMbDqdyBTpkxalixZDN8OKy9+yYwHHjWOkpLHvhrV1TRcnI6LKOMgMUrVqn/1Qtd7uZL7Y9WriUVGLFY9WInIWAEBAdKzZ0/VIRHB8dixYzwlHoSB0sSQ0o7DPIjco00SU2Whp+vZs2eN3hxKIQZKIqJ0hgkfMJwNSVKYUMDzsI2SiCgdIClKs2bNHIIlg6RnYomSiCiNYXosJENBmyTG5yH7GHkuliiJiNIYZv3A3LqYYH7//v08vh6OJUoionSAUiQmfkCVK3k2lihNSJ93MqmhIUhlZ39LRE+vaNGi0rVrV9VhR8cgaQ4sUZqQPu+kM5hmC/leAbdIaafPV0lEqYNUdN26dZOcOXOqeXPXrVvHQ2kiDJQmZ584PeE0XM6m2eIUW0Qph96s3377rdSvX182bdrEQ2gynD3E5FoN6vvEqbjscYotouTDZPOsXvVcnD2EbNl5Dq3fmPQ0XAmm2WLKO6LkKVGihLRq1Urmz5+v5scl82LVq8Wm4rKfhgtBktNsEaWuJNm+fXs18XyTJk1U1h0yN8OnOnHHaVXMvOjTcOHW6G3hwmPgqd+BwMBArWPHjpqvr6/h28JFUnUMOM0WJUmvZn3SdFxE5Mh+6AcmXF66dKk8evSIh8nkOI6SiCgZSpUqJa+//rqaV5KshYGSiCgZGjVqJP7+/moICFkLA6WJx09iaAhuiejpLVy4UDZu3CjLli3j4bQYBkqTQpIBjJ/Ukw0QUepmAdH9/vvv8vPPP0t8fDwPpcUwUBIROVGmTBkZOnSoVKpUicfH4hgoiYicqFChgmTOnFkqV67M42NxTDhAROTEDz/8IFeuXFFTZZG1sURJRPSnoKAg27FADtcdO3bI48ePeXwsjoGSiEhEypcvL4MGDZJmzZrxeJADBkoiIhEJCAgQHx8fyZMnj8rlSqRjGyURkYhs27ZNpaU7ceIEp84iByxREpFlFStWTJUidceOHWObJCXCQElEllSxYkXp1auXdOnSxSFYEiXEQGlBmJx51bRZnKSZLO3hw4eq9PjgwQOWIskltlGaVM7cgQ639jCR8+rpsw3YKiL3gbbIWbNmqbGSGApClBSWKE2obkgH6Tdtivobt7hPRCLlypVzyN96+fJlBkl6IgZKkylcoZx0HTdSvL3/OLW47Tp2hFpPZPU2yRdeeEHCwsIka9asRm8OeRAGSpNp3D3UFiR13j4+0qh7qGHbROQOoqOj5c6dOxIVFaVmAiFKLgZKk9n49aJEHRMex8fLpq8XGbZNRO7g+vXrMnPmTFm+fDmrWylFGChNJurIMYkY954KjoDbiPGT1Hoiq6lSpYrky5fPdj82NpZBklKMgdKEti9eLrNeHa7+xi3uE1kxd2vnzp1Vm6S/v7/Rm0MejIHSJPyC8kirQX3VLdy+cdPhlshqzp49K5cuXZLffvtN4uLijN4c8mAcR2kS/nnzSOvB/eTQ+o1qnCSR1d2/f1/mzZunEgtwnCQ9DZYoicg0atSooapcdci6wyBJT4uBkohMoWTJktKxY0cJDQ2V/PnzG705ZCKseiUi07RJHjx4UG7fvq3S0hGlFQZKIjIFjB/+/vvvmeCc0hyrXonIY9WuXVsaNWpku58w2QZRWmCJkog8UoECBeTvf/+7+htp6U6fPm30JpFJMVASkUfCzB8///yzSnDOIEmmrnodPHiw+pLfu3dPtm7dKnXq1HH5/CFDhsiRI0fk7t27cu7cOZkyZYpkyZJFrM7V/JNEZrVx40ZZs2aN0ZtBFqAZtYSGhmr379/XevXqpVWsWFH77LPPtBs3bmh58+Z1+vwXX3xRu3fvnrotXry41rJlSy0qKkqbPHlysj/Tz89PA9waue9pudQN6aC9v2+zNvlApLrF/cIVy6n7uDV6+7jwGKTVd6BevXpa586dNW9vb36v+L3SnvYYJDceGFqiHDZsmMrmj+wZhw8floEDB6qSYp8+fZw+v0GDBrJ582ZZsGCB6gqOK0n8XbduXbESpKkrXLGcWso3rOd0/sl8JYpLZMRiyRGQSz1PT21H5KkCAgKkVatWUrVqVTW3JJHp2ygzZcoktWrVkokTJ9rWIYPG2rVrJTg42OlrtmzZIj169FDVszt27FADjNu1aydffvllkp+TOXNmh6pZPz8/8XTBXTupdHVJwfyTPf474c/nhqjbVdNmyerpszNsG4nS2q1bt2TRokVSsGBBOXToEA8wmT9QBgUFia+vb6KBwbhfoUIFp69B6RGv27Rpk3h5ealgO336dIdgm9CoUaNk3LhxYiaREUtUTle9TbLftCkOkzVjai3MGmKfED32KvO/kmfy8fGR+D+njTt69KhaiCzVmSclmjZtKqNHj1YdgGrWrCkhISHSvn17eeONN5J8DYIoptjRl8KFC4unQ9LzqMPH1HJ08zan809ivf4cLEyUTp4IzS1oikHPViLLlSivXbsmjx49SpSTEffR7duZt956S1Wzzp79RxUi0lXlyJFDPv/8c3nnnXecJj9GUmQsZob5JmOio6X/jA9VSRJBksjTZcuWTRo2bKj+xytVqiS7d+82epPIogwrUWLqm127dknz5s1t61CdivuRkZFOX5M9e/ZEmTf0Khm81so4/ySZDYaMhYeHy+rVqxkkyboJBzAGEv8IO3fulO3bt8vQoUPV1ePcuXPV43gMGTdQ3QrLly9XPWX37Nkj27ZtkzJlyqhSJtYzdRWReUqSCJIQHR2tFiLLBkr0YMubN69MmDBBpaPau3evtGnTxvaPUaxYMYcA+Pbbb6vqVdyirfHq1asqSP7nP/8xcC+IKK00adJE9WrHkLHr19kBjdwD6isTN+yZGIaHxMbGqo49cXFxYhYYKzlsUbhMCQ1TnXeIPA16wb/yyiuqn8LKlStVLRORO8QD5nolIreAzn1obilfvrxqXiFyFx41PISSB1l4Wg3qy2w85BFy585t+xuZuRgkyd0wUJqQf948KnMPbonc2bPPPqvGRZcuXdroTSFKEgOlRbCUSe4GQ7rQiQ9tk+jUR+Su2EZpsVImUt8xSw+5A/Rgj4iIkLJly6qp84jcFUuUJoFcrkh8zpyu5O4w7Ms+YQiDJLk7BkqTQCkRs4OwtEjurEWLFip3a/369Y3eFKJkY6AkogyjJxBhJi3yJGyjJKIM88svv8ixY8fkwoULPOrkMViiJKJ0VblyZYdJCxgkydMwUBJRumnZsqV07dpVOnTowKNMHouB0oRy5g50uCUyysWLF1XPVswCROSp2EZpMnVDOkjXcSPV3/2mTZGIce+piZ2JjHDo0CEVLG/evMkTQB6LJUoTKVyhnAqS3t5/nFbcdh07Qq0nyigY+pE5c2bbfQZJ8nQMlCbSuHuoLUjqvH18pFH3UMO2iaw3ThJzynbv3t2hAw+RJ2OgNJGNXy9KND7tcXy8bPp6kWHbRNaratVnAEGKOiIzYKA0kagjx1SbJIIj4DZi/CS1nigjXLp0ST7++GPZu3cvDziZRqo786BapUyZMpIvX75E1X0bN25Mi22jVEDHnZjoaOk/40OZ9epwObp5m1rPnrCUHvA70KxZM1WC1Nsi79+/z4NNppKqQFmvXj2ZP3++FC9ePFE7BKpbMG0OGef2jZsOt+wJS+mlSZMmaqlatap8+umn8ujRIx5sMp1URbQZM2bIzp07pX379qqqhW0R7jXvZL6SxdXfuEVJ0llPWJQ69UCKGUeYTJ1SY9euXSrzDmqRGCTJrFAcTHGL++3bt+WZZ56RkydPiqfx8/OT2NhY8ff3l7i4ODGbVoP6qnknUwLTc2HmEaLU8PHxUUkFiMwaD1JVoty2bZtqn/TEQGl2kRFL5OrZc9Jj0gT5asQYuRsTqxIP2Lcjo5MP2i/tS5REyYGmlrZt28pvv/0mZ86cUesYJMnsUhUoP/nkE5k8ebIUKFBADhw4IA8fPnR4HOvIGKhCjT59Vv2N26jDf/SERXUrxlTqPWH1Tj5EKe2fULduXalWrZp89NFHcu/ePR5AMr1UBcrvvvtO3c6ZM8e2Du2UuNpkZx7P6QlLlFLom1CqVCnZt28fgyRZRqoCZcmSJdN+SyhDe8ISpQY67KDHO5GVpCpQnjt3Lu23hIjcDtq2O3XqJGfPnlU9XIms6KkGPFasWFGKFSvmkAAZli/nbBVEZoChH2iPrFSpkpw4cUJiYmKM3iQiz6l6Xbx4sRpkrLdNgj6ekgkHjIVerBjywd6s9LTQMQ+d9s6fP88gSZaVqlyv6O12+vRplb4OCZBx1YnsHGjof/bZZ9N+KynFPV8xLpJJBCi11a32GbfWrFkjR44c4cEky0pVoAwODpYxY8bI9evX1WwVWDZv3iyjRo1SCZGJyHODZOfOnaVdu3ZGbwqRZwdKZOLQsxhcu3ZNChUqpP5Gg3/58uXTdguJKMOgzwHaI2vUqCH58+fnkSdKbRvlwYMHVQo7ZOZAlp5///vf8uDBA+nfv7+cOnWKB5bIQ+F/esmSJapJ5cqVK0ZvDpHnBsq3335bcuTIof5GFeyKFStUUmRUxXbr1i2tt5GI0hFqiFDlqmfYQjIBInrKQLl69Wrb38j3imEigYGBtvnoiMhzgmTXrl0lS5YsKpFAwnSURJTKNkpnGCSJPE/u3LnVcK+iRYuyTZIoLUuUuPp87bXX1MzmGCJiPzMF1KpVKzVvS0QZ7OrVq/LVV1+ppCEXLlzg8SdKq0A5e/ZsadWqlXz77beyfft2TtzsAZiEgOyrW7Nly6bmlQUkEyAi17SULrdu3dIaNGiQ4te5w+Ln56cBbo3elgzf96A8WqtBfdWt0dvCxZhj4Ovrq7300kva66+/rvn7+/M88Lto6e+AXzLjQaraKKOiolzOBk3uyT9vHmk9uJ+6JWvKmjWrBAUFqZnd0QGPiJ4sVYFy+PDhMmnSJDU4mYg8B6pbw8PDVbskEoQQUTq1USKnK65MkVwAA5MTdinPk4clFiJ3gUkK8D+pJxDADCCcBYQonQPlggULpHDhwjJ69Gj1z6fPGkJE7hckX3zxRSlSpIh8+eWX7NlKlFGBskGDBiox+v79+1PzciLKIJgFRJ8NBL1diSiDAiWm3EH3ciJyb2gWQcYddOC5dOmS0ZtDZJ3OPCNHjpTJkydL06ZNVWYP9KCzX4jIOJkyZZIyZco4BEsGSaIMLlH+9NNP6vbnn392WI/qHbRXol2EiDIe/vdeeuklKVGihCxevJjNI0RpIFURDanriMj9PHr0yDZH7I0bN4zeHCLrBsoNGzak/ZYQUZpYuXKlREZGMlASGdlG2bhxY5dLSg0ePFhOnz4t9+7dk61bt0qdOnWSfO66detU9W7CBXNiElkREprb/8/g/4GlSSKDS5Tr169PtM5+LGVK2ihDQ0NlypQpMnDgQNm2bZsMHTpUVq1aJeXLl1czGyT0/PPPqx8GHQZSY6LZiIiI1OwKkUdDv4Du3btL8eLFJWfOnOpCkojcoESJHJH2C6baatOmjezYsUPNKpISw4YNk5kzZ8q8efPk8OHDKmAi20+fPn2SnPcSSQ70pWXLlur5DJRkRbhAPXDggKqNOXr0qNGbQ2RKqSpRxsbGJlq3du1aefDggSod1q5dO9nd2DF35cSJEx3+8fFeSGiQHH379pVvvvlGBUtnUPrE/Jk6Kw9fyZk70OGWzAEpJQ8dOqSCJRG5SYkyKSjhoco0uTAIGtW0eg5K+/cpUKDAE1+PdpmqVavKrFmzknzOqFGjVGDXF8x8YkV1QzpIv2lT1N+4xX3yTLjwa9GihUMTB4MkkZuVKBGcEraTFCxYUCUi2Lt3r2QUlCaRRg9VvklBaRWlXPsSpRWCpV9QHtt0WihBdh03UqUyA9x2HTtCYqKj5faNmw6TO8ddu27YNlPydOvWTUqVKiX+/v7y/fff87ARuWOgRDBEFSkCpD30WE2qbdEZjPfCuK/8+fM7rMf9y5cvu3xt9uzZ5YUXXpAxY8a4fB6qg7FYTXDXTmruyaR4+/hI/xkfOqxbNW2WrJ4+OwO2jp4GhmehE9uWLVt4IIncNVCWLFnS4f7jx49VD9Xff/89Re+D1Fq7du2S5s2by9KlS9U6BF/cnzp1qsvXdu3aVVVBYV49SiwyYokcWr/RVqJEdateolTnLD5eZr06PFGJktzfmTNn5OOPP5b4+HijN4XIElIVKM+dOyd/+9vfVEBDj1f7H2C9SjS5UC2KiWTRIWH79u1qeEiOHDlk7ty56nE8hqpSTOmV8DOWLFnC8WJJQBWqfTVqxLj3VHUrSpIIkhHjJ8nRzdtSctrJIJj7tV27drJ69Wo18TIwSBK5eaBEdScWBDckW36a+SgXLVokefPmlQkTJqgOPKjWxVCT6Oho9XixYsVUidVeuXLlVGIDDA2h5Nm+eLlqk0R1K0qSDJKeo2PHjlKxYkXVJolhVESU8bSULhcvXtR69OiR4te5w+Ln56cBbo3eloxeClcsp00+EKlujd4WLsk/BoGBgVr//v21fPny8bjxu8PvgGR8PEhViRJjE9mRgChjIMnG559/zsNN5EnjKDFuEVP5EFHaQ4/usLAwNeSKiIyX7BIlJmrWofNO//791aBnjGNE71V7w4cPT9utJLIQdJJDz3LkNZ42bdpT9QEgogwMlDVq1HC4rycWqFKlisN6/lMTPR30bkWpEhOj8/+JyIMCJYaDEFH6QC2N3rsb45EXLlzIQ01kxlyvRJRyGDeMpozKlSvz8BG5IQZKIoNhth2MIca44JTM5UpEGYP/lURukLsVQ66QzhG5j4nIvTBQEhkAgVFP1o8OO2vWrOF5IHJTrHolymA5c+aUV155RZo1a8ZjT+QBGCiJMliZMmVUfuPq1atLtmzZePyJ3ByrXokyGMYg+/j4yKlTp+TevXs8/kRujoGSKIOGgNy/f982PRY67hCRZ2DVq4VgYuZV02ZxguYMhumx+vTpoyYbR0mSiDwLS5QWgomcV0+fbfRmWE7u3LklV65cKvsOUtPFxcUZvUlElAIMlETp7MyZMzJ//ny5fv06gySRB2KgJEqn6lYkD7h79666j447ROSZ2EZJlMZQzdq7d281pySqWonIs7FESZTW/1S+vmpBxh3mbiXyfAyURGkMbZHz5s1TE5rHxsby+BJ5OAZKojQQEBCg8rdGR0fbgiURmQPbKCkRv6A80mpQX3VLyQuSepskUtMRkbkwUFIi/nnzSOvB/dQtPRky7ty5c0elo2NKOiLzYdUrURoEyi+++EJ13Ll9+zaPJ5HJsERJycLq2MTZdsqWLesQLBkkicyJgZKShdWxdsfC31969eolL7zwgpQuXZrfICKTY6AkSiGUHM+ePat6tl6+fJnHj8jk2EZJlEKPHz+WxYsXS5YsWdh5h8gCWKIkSoagoCCpV6+eQ7BkD1cia2CJkugJsmXLptokc+bMKQ8ePJA9e/bwmBFZCEuURE+AkuO2bdtUe+SRI0d4vIgshiVKomTYuHGjREZGqqmziMhaWKIkciJfvnzSvn178fb+61+EQZLImliipERy5g50uLUaZNjp0aOHGi+JiZfXrVtn9CYRkYFYoiQHdUM6SL9pU9TfuMV9q0HJ8YcffpDz58+r6lYisjaWKC2els4+8TlKkF3HjbRVN+K269gREhMdLdlz+at1OQICxAqOHj0qx44dU5MvE5G1MVBaWHDXTmqWEFe8fXyk/4wPbfertnhWjkVuF7MpUKCAtGjRQr799luVtxUYJIkIGCgtLDJiiRxav9GhRInqVvsOLI/j42XWq8NVibLHpAlyYO16MRsvLy/p3LmzmksSwXLFihVGbxIRuRG2UVpY3LXrEnX4mG05unmbRIx7TwVHwG3E+Elq/d2YWLXOy9tLzAYlx4iICFXdumbNGqM3h4jckGalxc/PTwPcGr0t7rqUb1hPm3wgUt3ift2QDtr7+zardbjFfaO3MS0WLy8vw7eBC48BvwPuHw9Y9UqJr5we47shqrq1fMN6SXbwuX3jpu01sVevqxKqpyhUqJCEhITIN998o2YBISJKCgMlJYIOO4A2yeR08IFV02bJ6umzPeZotmrVSrVJNm/eXBYtWmT05hCRG2OgpETQYadBaIh8NWKMaptMqoNPwhKlJ0FwRJBctWqV0ZtCRG6OgZISuXPrlrqNPn1WdfJBBx9Ut6Ikad/Bx9NkypRJHj58qP5Gxp3ly5cbvUlE5AHY65WeaPvi5aoECbjFfU9TpEgRGTJkiJQuXdroTSEiD8NAScmiV7PaV7d6ktq1a6v5JOvXr2/0phCRh2HVK1kCqllv3rwpW7ZsMXpTiMjDsERJpoUSpC4+Pl5+/fVXWxslEZHHBMrBgwfL6dOn1SzyW7dulTp16rh8fq5cuWTq1Kly8eJFlZMT2VTatm2bYdtLnqFYsWLy2muvsaqViDw7UIaGhsqUKVNk/PjxUrNmTdm3b5/qro/xbUn1WkSKsRIlSkiXLl2kfPny8sorr0hUVFSGbzu5N3xHsmTJImXLllW5XImInoZh6YO2bt2qffLJJw4pxS5cuKCNGDHC6fMHDBignThxQvP19U33lEVWXvyC8mitBvVVt/q6whXLqRR2uDV6+5K7VK9e/am+K1x4DPgdMPd3ILnxwLASJUqHtWrVkrVr1/4VsTVN3Q8ODnb6mueee05NpPvpp5/K5cuX5cCBAzJq1CiHwfAJZc6cWfz8/BwWcg2p6JBlx5NS0gFqIuxLj3v37lWTMBMRPQ3DAmVQUJD4+vrKlStXHNbjPuYGdKZUqVKqytXHx0fatWsnb731lgwfPlzeeOONJD8HgTQ2Nta2sJrWvFWt/fv3VxdTrGolIlN15kkJlByjo6PVD+Lu3btVGrJ33nlHBg4cmORrJk6cKP7+/ralcOHCYlZ+QXmk1aC+6tZqsmfPri6g0NPVVQ0DEZHHjKO8du2aqhbLnz+/w3rcR7WqM5cuXVLd+x8/fmxbd/jwYSlYsKBDejJ7Dx48UIsV+OfNI60H91OTMXtatenT+u233+SLL76Q8+fPq6EgRERpxbBLbwS1Xbt2qcTUOlSZ4T7aIZ3ZvHmzlClTxqFqrVy5cmqoCMfHWU/RokVVz1bdmTNnGCSJKM0ZWkeFoSEY3tGzZ0+pUKGCTJ8+XXLkyCFz585Vj4eHh8u7775rez4ez507t3z00Ueq2z/aKUePHq0695C1oL06LCxMunfvrjpsERGZMoUd2hjRU3HChAmqAw96KbZp00a1Q+qDxu2rWS9cuCCtW7eWDz74QPbv36865iBoTpo0ycC9ICMgQQVqETALCKtaiSi9GT6WxR3HzXjikp5jHZ2NrTR6CQoK0nx8fAzfDi48BvwOiKnjAZOiU4rGVhoJU2TduHFDJTfXO4QREaU39qMnj2mTfPHFF6VXr15qmA8RUUZhiZI8Atqtb926pRJS3L592+jNISILYaAkj4DgOGfOHDVjjH0HLyKi9MaqV3JbmB0Gqel06OHKIElEGY2BktwShgZhGraXXnpJ8uXLZ/TmEJGFseqV3BKyLZ06dUpVtbJ3KxEZiYGS3BLyAC9cuFBVtbK6lYiMxKpXchuVKlVSc5TaB0sGSSIyGkuU5BaQwhBzjWKKLCQVOH36tNGbRESkMFCSW8DUalu3blXzSmIWECIid8FASW5j9erVago1TUN6RSIi98A2SjJM1apV1VRp9hgkicjdsERJhggICJBOnTqJj4+PnD9/Xg4cOMAzQURuiYHSRHLmDnS4dWfI27ps2TIpWrSoHDx40OjNISJKktef821Zhp+fn8TGxqoZKOLi4sQs6oZ0kK7jRqpeoxhSETHuPdm+eLm4G7ZBEpGnxQOWKD2UX1Ae8c+bx1aC1IMk4Lbr2BESEx0tt2/8MXcjxF69ruaVNEr16tWlWrVqsmDBAnn48KFh20FElBIMlB4quGsnaT24X5KPe/v4SP8ZHzqsWzVtlmGTL2fLlk1at26tbmvUqCHbt283ZDuIiFKKVa8mKVH2mzbFVqKEx/HxMuvV4W5VoixSpIhUrFhR1qxZY9g2EBGltOqVgdJMbZRjR6iSJIJkxPhJbtFG6evrq1LRERF5aqDkOEqTQFBECRJw6w5BEnlbBw8erL6ERESeioHSRPRqVvvqViNLkg0aNJDcuXPLM888Y/TmEBGlGjvzULpAdWt4eLjq5bpp0yYeZSLyWCxRUprKkSOH7W/U/TNIEpGnY6CkNFOnTh157bXXVO9WIiKzYKCkNMu4g6EfWbNmlTJlyvCoEpFpsI2S0gRm/UDGHcwIsnv3bh5VIjINlijpqQQFBdn+Rlo6BkkiMhsGSkq14OBgNU6Swz+IyMwYKCnVAgMDVdo83BIRmRXbKCnVfvzxRzlx4oQcO3aMR5GITIslSkqRkiVLOnTgYZAkIrNjoKRka9SokYSFhUmrVq141IjIMhgoKdnu3bunbu/fv8+jRkSWwTZKSrZdu3bJxYsX5dKlSzxqRGQZLFGSS0gggJlAdAySRGQ1DJTksk2yc+fO0q1bN5WijojIihgoKUnnz5+XBw8eyJkzZ1QPVyIiK2IbJSXp7NmzMnXqVDVdFhGRVbFEaSKxV6/Lqmmz1G1q1atXT3LmzPnXezJIEpHFMVCaSNy167J6+mx1mxoNGjSQtm3bqrGS9h14iIisjIGSbA4fPiwxMTFqGMijR494ZIiIMN8uMpFZ6Uj4+fmp6kR/f3+Ji4szenPcTubMmVUHHiIis/NLZjxgidLimjZtKgULFrTdZ5AkInLEQGlhtWvXlmbNmsnLL78s2bJlM3pziIjcEntsWNj+/fulWrVqcuDAAVseVyIicsRAaWGoZp03b548fvzY6E0hInJbrHq1GEyRVblyZdt9BkkiItdYorSQKlWqqLGS8fHxEhUVJbdu3TJ6k4iI3J5blCgHDx4sp0+fVu1kW7dulTp16iT5XAyGR95R+4Xta8lz6NAh2b17t/zwww8MkkREnlKiDA0NlSlTpsjAgQNl27ZtMnToUFm1apWUL19erl696vQ1GBSPx3VM2J08OE7Lli1LozNHRGQdmpHL1q1btU8++cR238vLS7tw4YI2YsQIp88PCwvTbt68mez3z5w5s+bn52dbChUqpAH+Nnrf03vBsWzfvr32t7/9zfBt4cJjwO8AvwPiZscAcSA58cDQqtdMmTJJrVq1ZO3atX9FbU1T94ODg5N8HZJ2Y+qnc+fOyZIlS6RSpUpJPnfUqFEq84K+oG3OKkqUKKGqsRs3biwFChQwenOIiDySoYEyKChIJd++cuWKw3rcT+qH/ejRo9KnTx/p2LGj9OjRQ7y9vWXLli1SuHBhp8+fOHGiSk+kL0k9z4zQ7vvTTz+pi4nLly8bvTlERB7J8DbKlEJnHyw6BEkk8x4wYICMGTPG6VhBK6Vl8/LyUos+7MP+WBERkYeVKK9du6ZmqcifP7/DetxPbgkIr9+zZ4+UKVNGrA4BskOHDqqDlI+Pj9GbQ0RkCoYGyocPH6opnZo3b+7wY4/7kZGRyXoPVL1WrVpVLl26JFaXN29elZKuXLlyUrRoUaM3h4jINAztdRQaGqrdu3dP69mzp1ahQgVtxowZ2o0bN7R8+fKpx8PDw7V3333X9vw333xTa9mypVayZEmtRo0a2vz587W7d+9qFStWTNNeTp66lC5dWqtSpYrh28GFx4DfAX4HxM2PQXLjgeFtlIsWLVIloQkTJqgOPHv37pU2bdpIdHS0erxYsWIOadYCAwNl5syZ6rk3b95UJVJkm0E7pRWhBJ4lSxa5f/++un/y5EmjN4mIyFQ4cbOHB8lOnTqpi4bw8HC5e/eu0ZtEROQxOHGzRU5yqVKlVIm8UKFCRm8OEZEpGV71SqmHBAqYJgvjUU+cOMFDSUSUDhgoPQx6+ebKlUu1z8L169fVQkREJp49hJIfJENCQqRfv36SL18+HjYiogzAQOlBkBs3d+7ckjVrVgkICDB6c4iILIFVrx7k999/ly+//FIKFiyo8rgSEVH6Y4nSA6pbixQpYruP8ZIMkkREGYeB0s2DZJcuXaR3794OE1UTEVHGYaB0c/Hx8WqOTvvsRERElHGYmccDSpWYTYVJ34mI0hYz83goTI9VqVIl232UJBkkiYiMw6pXN8vdirkksTRs2NDozSEiIgZK94K2yAsXLqh5OlmKJCJyDxxH6WY2btwoBw4ckFu3bhm9KURExBKl8Xx9fdV8mui0o2OQJCJyHyxRGgzjJCtUqKCmylq6dKnRm0NERAmwM4/B9uzZI/fu3ZN9+/YZvSlEROQEx1G6ASQ5R2o6IiLKOBxH6cYzgLRp00YFRx2DJBGR+2LVawZ77rnnpH79+tKtW7eM/mgiIkoFBkoDhn/cuHFDfvnll4z+aCIiSgW2URoAQ0GY5JyIyFhso3SjNkkMAQkKCrKtY5AkIvIcrHpNZ61atZIqVarICy+8oHK5EhGRZ2HCgXS2bt06yZcvn6xevVrlciUiIs/CQJnO7t69K3Pnzk3vjyEionTCqtc0liVLFunZs6eULl06rd+aiIgMwECZxpDgvFSpUtKpUyeV8JyIiDwbf8nT2IYNG8Tf31+2b98ujx49Suu3JyKiDMZAmQZ8fHwkPj5e/Y1bzgJCRGQerHp9SsjZ2rt3b5WWjoiIzIeB8ilVrlxZihQpIk2aNJHs2bOnzVkhIiK3warXp7Rr1y7Jli2bHD9+XA0FISIic2GgTOUQkAcPHtgSCGzatCmtzwsREbkJVr2mEEqPvXr1ko4dOzIlHRGRBbBEmUKFCxeW/PnzqyEgWGJiYtLnzBARkVtgoEyhEydOSEREhFy7do1BkojIAhgokwG9WTE+8vfff1f3Dx8+nN7nhYiI3ATbKJMRJMPCwqR79+6SOXPmjDkrRETkNhgokzEDNtoiAwMDJWfOnBlzVoiIyG2w6vUJrly5Il988YUaDnLjxo2MOStEROQ2GCidyJEjh6pmvXnzprp/6dKljD4vRETkJlj16iRIok0SYyVR3UpERNbGQJmAl5eXw0JERNbGqtcEbt++LeHh4ZIpUyZb1SsREVkXS5QiqjdrsWLFHIIlgyQRETFQ/tkmifbIl19+WYoXL85vBRERObB81Suy7aD06Ovry5R0RETknlWvgwcPltOnT8u9e/dk69atUqdOnWS9rlu3bmqqq8WLF6f6sx89eiQLFy6UOXPmyK1bt1L9PkREZE6GB8rQ0FCZMmWKjB8/XmrWrCn79u2TVatWSd68eV2+DtWk//vf/2TDhg2p+twqVao4BMvY2NhUvQ8REZmb4YFy2LBhMnPmTJk3b55KNj5w4EC5e/eu9OnTJ8nXeHt7y9dffy1jx46VU6dOpepzO3ToINWqVXuKLSciIiswtI0SQzBq1aolEydOtK1DVeratWslODg4ydeNGTNGoqOjVXVp48aNXX4GMuxkyZLFIXcrIBgjJZ1+n4iIrMUvmb//hgbKoKAg1YkG+VTt4X6FChWcvqZhw4bSt29fqV69erI+Y9SoUTJu3LhE69966y21EBGRtfn5+UlcXJw5er1ivOOXX34pr7zyily/fj1Zr0FpFW2g9gckKipKChcu7PLAmAX317x4bs2L5zZjj/XFixddPsfQQHnt2jXVkSZ//vwO63H/8uXLiZ5funRpKVmypCxfvtyhvRIePnwo5cuXT9RmiVk/sCSEIGmFQKnj/poXz6158dymv+TEAUM78yC47dq1S5o3b25bh/yquB8ZGZno+UeOHFG9VVHtqi/Lli2TdevWqb/Pnz+fwXtARERmZ3jVK6pFkVt1586dsn37dhk6dKjKljN37lz1OB5DVeno0aNVcoBDhw45vF4f+5hwPRERkSkC5aJFi9SYyQkTJkiBAgVk79690qZNG9WrFZCD9fHjx2n2eQi26NyDWyvg/poXz6158dy6F8wjpRm9EURERO7K8IQDRERE7oyBkoiIyAUGSiIiIhcYKImIiKwWKI2ctsvd9zcsLEzto/2C15n13ObKlUumTp2qMm/cv39fjh49Km3bthUz7i/GEyc8t1hWrFghZj2/Q4YMUeOrkbv53LlzariZfW5ns+wrUn2++eabcuLECfV8jA5o3bq1eIrGjRurMe8Y6ofvZMeOHZ/4mqZNm6px9vi/PX78uPrtMpJmpiU0NFS7f/++1qtXL61ixYraZ599pt24cUPLmzevy9cVL15cO3/+vPbrr79qixcvNu3+hoWFabdu3dLy589vW/Lly2fKfc2UKZO2fft2bcWKFVqDBg3UOW7SpIlWrVo1U+5vYGCgw3mtVKmS9vDhQ3XOzbi/L774onbv3j11i3PbsmVLLSoqSps8ebLp9vW9997TLly4oLVt21YrWbKkNnDgQO3u3bta9erVDd8XScbSpk0b7a233tI6deqkQceOHV0+v0SJEtrt27e1//3vf1qFChW0V199VX2XW7VqZdQ+GH8Q03LZunWr9sknn9jue3l5qS/YiBEjknyNt7e3tmnTJq1Pnz7a3LlzPSpQpnR/8aN58+ZNw7c7I/Z1wIAB2okTJzRfX19L7G/CZciQIVpMTIyWPXt2U+4vnrt27VqHdfhh3bhxo+n2FRcAgwcPdlj37bffal9++aXh+yIpXJITKHFhcODAAYd1CxYs0H788UdDttlUVa/6tF2Ypiu103ZZYX+RXP7MmTOqqmrJkiVSqVIlMeO+PvfccyoV4qeffqpyBx84cEDNJqPnBzbjubWHWXa++eYbVS1pxv3dsmWLeo1eZYk80O3atZOVK1eK2fYV1cmogrSHKthGjRqJGQUHBzscH1i1alWyv/tpzf1/MdJo2i5k/XE1bRdmJLHC/qKNDpNio42gR48eKmjgBwezqZhtX0uVKiVdunQRHx8f9QOKadWGDx8ub7zxhri71OyvPQSPqlWryqxZs8QTpGZ/FyxYoC5yN23apCY+wIQI69evd5jf1iz7iiCBSe7LlCmj8mG3aNFCnn/+eSlYsKCYUYECBZweH/Q5yJo1a4Zvj6kCZUZM2+Xp0GkA+7xv3z7ZsGGD+me7evWqDBgwQMwGFwGoKejfv7/s3r1bpUt85513ZODAgWJ2uPjbv3+/7NixQ8wKnT2QAxqdYmrWrCkhISHSvn17j7gQSil0WkKHFnRcwkUBOqghH3ZapvckN8716mnTdnny/jqD1+/Zs0ddqbqz1OzrpUuX1Hm0/zE5fPiwugpH9RceM+O5zZ49u7zwwguqtOUpUrO/qCHARd/s2bPV/YMHD6oJFT7//HN1QYTqTLPsK16DCwFUwebJk0f14n7vvffc+vfpaeA4ODs+MTExiaqgM4KpSpRWm7YrpfvrDC4MUEWHoGK2fd28ebOtqkpXrlw59SPjzkHyac9t165d1Q/qV199JZ4iNfuLC4KEJar4+Hjba814bpEsHd9fVN127txZli5dKmYUGRnpcHygZcuWyf5dSw+amRZ0u0aX8Z49e6puxTNmzFDdrvUhEOHh4dq7776b5Os9rddrSvf3zTffVN3o0cW8Ro0a2vz581U3c3RRN9u+FilSRPX6/Pjjj7WyZctq7dq10y5fvqyNHj3a8H1Jj/3Vlw0bNqgegkZvf3rv79ixY9X57datmxpO0KJFC+348ePaN998Y7p9rVu3rhYSEqL+bxs1aqR6+548eVLLlSuX4fsiyVhy5MihPfPMM2qBoUOHqr+LFi2qHse+Yp8TDg+ZNGmSVr58eW3QoEEcHpLWJwVjbs6cOaPGKaEbNr5k+mPr1q1TwdAsgTKl+ztlyhTbcy9duqTGGHrKWKzUnNv69etrkZGR6kcJQ0VGjRqlhgOZdX/LlSunfogQNIze9vTeXx8fH23MmDEqOOJi7+zZs9rUqVM9JnikZF8x/vfQoUPqe3z16lUVVAoWLGj4Pkgyl6ZNm2rO6PuIW+xzwtfs3r1bHR/87xo5HpjTbBEREVmljZKIiCitMVASERG5wEBJRETkAgMlERGRCwyURERELjBQEhERucBASURE5AIDJRERkQsMlETkALmOP/jgg2QflbCwMLl58yaPIpkWAyUREZELDJREREQuMFASeVCV6Mcff6yqRW/cuKHm7OvXr5+abmrOnDkSGxurJvdt06aN7TVNmjSRbdu2qTn8MD3TxIkTxcfHx/Y4XhseHi5xcXHq8WHDhiX63MyZM8v7778vFy5ckNu3b6vJvzFpMpFVMFASeRC0B2IS37p168onn3wi06dPl4iICNmyZYvUrFlTVq9erSYzzpYtmxQqVEhWrlwpO3bskGeeeUYGDRokffv2lTfeeMP2fgiACHodO3aUVq1aybPPPqvex97UqVMlODhYTQZdrVo19Xk//fST20/2TZSWDJ+ChQuPAb8DT/4OYBoizDWp38d0YXFxcQ7z+OXPn19NX1SvXj3t7bff1g4fPuzwHpjXLzY2VvPy8lJzBGIKoy5dutgeDwwM1O7cuaN98MEH6j7mC3z48GGiKZ3WrFmjvfPOO+pvTH908+ZNnkP+H2tmPQa+aRpyiShd7d+/3/b348eP5fr163LgwAHbuitXrqjbfPnyScWKFRPNCL9582bx8/OTIkWKSGBgoGTJkkVVzerQe/Xo0aO2+1WrVhVfX185duyYw/vgdfhsIitgoCTyIA8fPnS4r2laonXg7Z02rSo5c+aUR48eSa1atSQ+Pt7hMbRXElkBAyWRSR0+fFg6d+7ssK5hw4aq0w865qBD0IMHD6RevXpy/vx59XhAQICUK1dOfv31V3V/z549qkSJEuqmTZsM2Q8io7EzD5FJTZs2TYoWLao6/ZQvX16ee+45GT9+vEyZMkWVRO/cuSOzZ89WHXqaNWsmlStXlnnz5qkqXR160X711VfyxRdfSEhIiJQoUULq1KkjI0eOlHbt2hm6f0QZhSVKIpPCcA8EMwTCffv2qRIkAuPbb79te86//vUvVb26fPlyNURk8uTJkitXLof36d27t+opi8cKFy6set1iiMiKFSsM2CuijOf1Z68eIiIicoJVr0RERC4wUBIREbnAQElEROQCAyUREZELDJREREQuMFASERG5wEBJRETkAgMlERGRCwyURERELjBQEhERucBASUREJEn7f4P4wxjvAyfcAAAAAElFTkSuQmCC" }, "metadata": {}, - "output_type": "display_data" + "output_type": "display_data", + "jetTransient": { + "display_id": null + } } ], "execution_count": 7 diff --git a/examples/view_experiment1_behavior.ipynb b/examples/view_experiment1_behavior.ipynb index a7423a8..0dca904 100644 --- a/examples/view_experiment1_behavior.ipynb +++ b/examples/view_experiment1_behavior.ipynb @@ -9,8 +9,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-01-27T18:11:55.739221Z", - "start_time": "2025-01-27T18:11:55.495694Z" + "end_time": "2026-03-26T22:23:26.063761Z", + "start_time": "2026-03-26T22:23:26.059240Z" } }, "cell_type": "code", @@ -25,13 +25,13 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-01-27T18:11:57.282743Z", - "start_time": "2025-01-27T18:11:55.741133Z" + "end_time": "2026-03-26T22:23:27.770785Z", + "start_time": "2026-03-26T22:23:26.064934Z" } }, "cell_type": "code", "source": [ - "from hobj.benchmarks import MutatorHighVarBenchmark\n", + "from hobj import MutatorHighVarBenchmark\n", "benchmark1 = MutatorHighVarBenchmark()\n", "target_statistics = benchmark1.target_statistics\n", "print(target_statistics)" @@ -45,13 +45,13 @@ " Size: 103MB\n", "Dimensions: (subtask: 64, trial: 100, boot_iter: 1000)\n", "Coordinates:\n", - " * subtask (subtask) " ], - "image/png": "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" + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAi4AAAHHCAYAAACY6dMIAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAACPQUlEQVR4nO2dB3xUVfbH70wmPZOEkEIKLZQEQRFCBGwg4MKKiqx1dRfruohd14LrKvYONtTVVRfLWv4isi4qiohID10gCb0lIYW0mdSZZP6f+2LCnJPkvsyEZDKZ3/fzeZ/kzmv33Xvf5OTe8zvHIIRwCAAAAAAAL8Do6QoAAAAAALQVGC4AAAAA8BpguAAAAADAa4DhAgAAAACvAYYLAAAAALwGGC4AAAAA8BpguAAAAADAa4DhAgAAAACvAYYLAAAAALwGGC4AnAT+9re/iX379gm73S62bNmCNu0AfvrpJ20DAPg2MFxAt+Taa68VDoejaauqqhLZ2dnitddeE7GxsSf1Xueff7544YUXxOrVq8X1118vHnrooZN6fdA+goODxaOPPirGjRuHpgSgG2DydAUA6Ej+8Y9/iAMHDoigoCBx9tlni1tuuUVccMEFYtiwYZoxczKYMGGCqKurEzfeeKOw2Wwn5Zrg5BESEiLmzJmjbT///DOaFgAvB4YL6NZ8++23YtOmTdrv7777rjh+/Li49957xbRp08Snn37a7v/kpfEjZ3Dkz5NptEhDq7q6+qRdDwAAugtYKgI+xfLly7Wf/fv3b/rsmmuuERs3bhSVlZWaYfPJJ5+IpKQkcp70rfj111/FyJEjtf/aKyoqxNNPP60tQ91www0iLCysaVlKLlNJ/Pz8xMMPPyz27t2rGSFy5uepp54SAQEB5Nry86+//lr87ne/ExkZGZoR9Ne//lVb2pDXu/zyy8Ujjzwijh49KsrLy8X//d//ifDwcO068+bNE/n5+cJisYj33nuv2bWvu+468eOPP2rHyDrs3LlTzJw5s1m7NNbhrLPOEuvXr9fqIH12/vznPzc7NiIiQsydO1c7R17zyJEjYsGCBaJnz55Nx8h6yBmOPXv2aMccPnxYPPfcc83q1xp/+ctftHaTfSLrI2fLOP7+/uKxxx7T+q60tFRYrVaxcuVKMX78+KZj+vbtK4qKirTfZX0a+0guHUlOPfVU8f7772vPKp85Ly9PM3CjoqLaVE8AQOeDGRfgUwwYMED7KQ0UifRHeeKJJ8Tnn38u/vWvf4mYmBhx++23a38AR4wYIcrKyprOlX+Y5QyOnKn56KOPNGNA/tG8+eabxRlnnCFuuukm7bg1a9ZoP+X1pOEgDY2XXnpJjB49WrvfkCFDxB/+8AdSr5SUFM1g+uc//yneeecdzR+nkdmzZ2t/VJ999lkxcOBArX5ydqe+vl706NFD+4M8ZswYzb9GGhPyeRqRS2PSWPnvf/+rOQ5fdNFF4s033xRGo1G88cYbpA7y2l988YX2h1saItIg+/e//63NWO3atUs7JjQ0VPzyyy/aM0hDafPmzSI6OlpcfPHFmrEn29VgMGj3k8bG22+/LTIzMzUD4e677xaDBw8W06dPV/aRvK88T/oMvfzyyyI5OVm7XnFxsWYkNSKNN9nmst1km5nNZm25bunSpVp/bNu2TRQWFmqG2ltvvSW+/PJLbZNs3769yT9JXl8aL8eOHRNDhw7V+lP+lG0KAOiaOLChDbrbGLj22msdkgkTJjh69uzpSExMdFxxxRWOwsJCR0VFhSMhIcHRp08fh81mc8yePZucO3ToUEdtbS35/KefftKud/PNNze71/vvv++wWCzks9NOO007/u233yafP//889rn48ePb/rswIED2me/+93vyLHjxo3TPt++fbvDZDI1ff7xxx876urqHEuWLCHHr169WruW82dBQUHN6vvtt9869u7dSz5rrMPZZ5/d9Fl0dLSjqqrK8cILLzR9NmfOHO24Sy65pNW2v+aaaxx2u91x1llnkc9l20nGjh3b6rnyOY8dO+bYvHmzw9/fv+nzm266STtX9kPjZ0ajkRwjt4iICEdeXp7jX//6V9Nnsv8ljz76aLP7tdQ+V155ZbO2wIY2wBgQXaYNsFQEujVymUQuFchlls8++0xbTpD/8efm5mqzHnLmQc62yNmUxk3+5y2XOM477zxyLbnkIf8zbwvSAVgil1SckTMvkqlTp5LP9+/fL77//vsWr/XBBx9osyWNyKUTWW854+GM/Lx3797aEpVznZ1nKOTzyaUuOfMky87ImZlVq1Y1lWW7yZkfOSPRyKWXXiq2bt0qvvrqq1afXS5tyVmWrKws0q6Ny3S8XZ0ZNWqUiIuL02ZInH2G5MyPXA5yRs44NR4jZ3nk7JPJZNJmweSSXltwbp/AwECtnuvWrdPKbb0GAKBzwVIR6NbMmjVL7N69W/vDL5d25B9i6eMgGTRokGYASF+KluDOtjk5OW12wJW+FVJpxK8t61BSUqLtd0Yu8bSG9A9xpnH5ynnZpPFzabRIHxS5rCI588wzNT+QsWPHass8zsjjpM9Ma/eRyLpKg6ARafAsXLhQ+eyyXU855ZQm3xKOSo7e2C7ScHRG9p807jgzZszQnK1TU1OJ/0xLx7aEfDbp73LVVVdpBhNvHwBA1wOGC+jWbNiwoUlVxJFGi/yv/fe//71mZHDk7Iwz7sinG40kPVTXbqluqs/l7INEzpTIGSc583HPPfdohk5tba02GyTL8vlduV5bkdeVPiTyHi3BDS53kU7V0hdn0aJFWhydgoIC7RmkT1CjL5MecrZNGnfyfDmTJPtc1l/6yfD2AQB0DWC4AJ9FKknkHyc528H/w28vhw4d0mY/5OyDNBycZxvkf/lyf0cjHXGlrFo6zjobC6qlmra0mYyBo3fM8OHDNaPJVRrbRbabc5RcuQQklWDS4baRyy67TLsXd3SWM0xtMR4jIyPFpEmTNMWWs0OzdFIGAHRd8C8F8FmkwkQuQTRKYzntkcR+88032s+77rqLfN44C7FkyRLR0TTOoDjPmEi/Fqk+che5THT66aeLSy65RDmLIRVGUtLMkYaUDAjXGtI/Rc6cSCWQlDs3ItVZzktWrT2fVBPJZTFnpKS60VDRO7+lPgMAdC0w4wJ8FukHIeOsSJlxv379NIdTGQ9F/mcvHXilJLfRmdZV5FKJdCiV8VjkH0zpECv/qMo/wHJpY8WKFaKjkc6+NTU1WnwWKbOWsWakMSENg4SEBLeuKZdU5EyHlHhL52C5DCcNPDmrI40N+dwffvihuOKKKzQHWzm7I2XNcvZJ+qHIzydPntzq8p00JGWfyLaXzrzSoVr2hzS25OyKM//73/80Z2HZntIQlMfJOkjptnzWRhrj11x55ZWav5P0/9mxY4f2meyX+++/XzOSpA+TjKXjHOMHANA18bi0CRvaoKPk0GlpabrHTp8+3bFy5UpN0iy3Xbt2OV577TXHoEGDmo6RMtxff/21xfNbkkPLzc/Pz/GPf/zDsW/fPkdNTY3j0KFDjqeeesoREBDQTIr89ddfNzu/UQ596aWXtunZpNxXIuW/jZ9deOGFjq1btzoqKysd+/fvd9x3332O6667Tjuub9++unWQz+0sQZZbjx49HK+++qrjyJEjjurqasfhw4e1NoiKiiKyZnkv2WZSUn38+HFHRkaG1h5ms1m3T2bOnKm1mzx3w4YNmjS5pbo8+OCDWt3lcZs2bXJccMEFWl24LHzMmDHa/WV9naXRUha/cOFCR3FxsaOkpMTx2WefOXr16tWqfBob2gBjQHi8DQy//QIAAAAA0OWBjwsAAAAAvAYYLgAAAADwGmC4AAAAAMBrgOECAAAA+ADnnHOOlrBUKuhkfKNp06bpniOz1EsVoFTnyXhX1157rfA0MFwAAAAAHyA0NFQL4njrrbe26XgZJkKGGpDBIGX8JpmtXWa9l2EDPAlURQAAAICP4XA4tECSixcvbvUYGeNKJoQ99dRTmz775JNPtNhUMlWKpzB5S6K8++67T/Tq1UuzFm+//XaRkZHR5vNlsC0ZWAwAAADQw2w2axnkOxKZjdw5MejJpKamRstL1l5kFOply5aRz2QeLznz4km6vOEiI23OnTtXi4i5fv16LRy3bLiUlBRRWFjYJqNFrucBAAAAbSUxMbHDjBdptFRVHBYGv9YzpbcVi8WiGVrOzJkzp1nOLneQkwUyo70zsiwzp8v0HdLvxRN0ecNF5nZ55513tPDpEmnAyKmrG264QTz33HO65zfOtJwz921RUWvTfo8+4xg5psgSSsq9e5SS8oW9tpNyeV0wKacE5pFydk28sk75tRGkPDLsICmHGdSDYXBAESlvrklSHp9ddaI+CQElZJ/Zj97rghD6LMdYxuB/HT+blG/quYqUPylNJ+W/9NjA6hpDynl2mj9mZBBNPmitD6TH19HjB/nTl2pzdV/l8zm3hSQlmD5ve+H12WOLc6m+U0Npsse8OvofWZ49QjnWwv2qlM+vqguHt328iWbL3l0bTe9lpPey1Acp9++u7UXKgwOOKfuaE+9XqqxfmIHG1txjMyvvz8ce75t4U6nyPfy5kiZnHBeyl5Tz7CfSELTEiEDad99UxiufV699Obx9LPUnckFxzMaG78rW+pozMpD+E2nVYpu2/r1wYfhW5VjbWEXTLiSy7y29vufPxt8bFSZDiJjSf1mHztLLmRZptNQXnCOEg9bdJQxhwhz7i2ZkOddXzrh0Z7q04SLzh6SlpYlnnnmGrMvJqSueSM15QEhrtpFGS1QaLRW/TZ2F1NFOrbDTQV7J9tvqG5K0NVJbT+9pd1Sw/fQLiFNdH6C8vt2oPr+eDXR+PqfGqT78WBs3kti16x3UcKlmz8br4nwv7XJsv91BE+zZWFvw69U57C4dr/d8vH56becqzetjdqm+vL3qHfR57Q6TcqzZDDr9q6gLh7c9P97uoAZ8nYPey87GDt/Pn72OvUe8r5vVz1ihrJ+DBQWvcxiV99frG/6e6x3ffCzTP+bNcFSq24c9r177cnh96h2tGy71DpuyrznNx61B+d7pvefNxrVOW+g9G39vugr1Dkv7DBfh0BQ20mjpCEPr2LFjIi6O/vMly2VlZR6bbenyqqLo6GgtnX1LU1VyCqslZs+eLcrLy5s2LBMBAADoitQ56tu9dSRr164VEydOJJ+df/752ueepEsbLu4gZ2fCw8ObNjmFBgAAAHQ16oWj3Zurcujhw4drm0RmQpe/9+7dWys//fTTYsGCBU3HywzvycnJmluG9Cu95ZZbNL/TefPmCU/SNefPfqOoqEhLc9/SVJWcwmoJ6Ul9MrypAQAAgO7EqFGjxIoVK5rKjQaI9CG9/vrrRXx8vOjTp0/T/oMHD2o+pfK4O++8Uxw9elTcdNNN4vvvvxeepMvHcVm3bp3YsGGDuOOOO7SywWAQhw8fFq+//nqbnHOlj4tcMhr2zqvCamswaPyiqA/L0ES1g+awCOpZPsm8k5TXVw4gZUsddZobEkzPTw2g90vxp9N92TY6EZbBHNXSgw8o96cyZ+EU//ITx9ZQL/ZcWw/ltbkDYI6dHs/hz8bJqqUOh+lBh0k5o/rESyPJrEog5TNC97H60bX3RFOJ+v7MmZW3VYKJrhMvrxhMytPCskk5lznP8vYqZ+VwHQdKveN5/XLtZpccNJ3rx9tiQuhuei3m3JptC1feS89ZNMGvVtl2/D14tijdpfdID37/5VV9XbreMutQUk4KKFaOPb2+HB9Mn/cvR84i5ZmxP7XLGTeHOb6nBhQqx47z2OL7+HfcrT1+JeXFFXRm26zjp6f3HuiNc962/HuA96UrY9NgCBMJiXu0GfuOctBt/LtUcWxou51zQ3vt7NC6dkW69IyLREqh5dTVxo0bNQNGyqHldNf777/v6aoBAAAAblPncEjP5na0oMMnW7/LGy6ff/65iImJEY8//rjmkLt161YxZcoUUVBQ4OmqAQAAAKCT6fKGi2T+/PnaBgAAAHQXGpxrMePSLQ0XAAAAoDsaLjzekCsYfHSpqNvJoQEAAADQfenyqqL20qQq+uylJlVRUhz1/j+aT5Uyfibq7T9+AA3DHmqiqqTMUhoMb3r8FlJeWUKVKcmhNFR4fg1Va1TYA5THZxynagjOkEgqFV9+ZFDT76PjqYonLrBcqdzgqh4eQp4rqPj+beU0HcHxappeIb0nDbO+o4ze7x99vibll3Ink3JsEPWkr7DT0OEDQ6gv1N5KqqpKM9N0C5ss/ZT7Ofx4PXh9uDKFt/f+Chpq/dweu5UqMN4+w8OPknKE34kIpN8VDiP7Qky1yrYN86tRqus+Lhrr0jjWG0t8LPL9XAW1qPx0ocL52SVldTSKcx5LxTEhfJdwheXlp5ByQbVZ+fz8+Tj8ebNYuopUnXQVvH3/79goUr6810ZSPlob1eq1eNvEB5Qp68q/0/TeI67u43xVOlK5Pz3sgFLh9faxccr3KMH/xPEmQ6i4MHlNp6iKivJSmkUddgWDIUxEx2dDVQQAAACAzlEVyTQ27mLo3vMOrYKlIgAAAAB4DXDOBQAAADyAdEpoz5yJQfgmMFwAAAAAD1AHVZFb+IxzbtqT80VFTYPzoeN06nD13OkLlU523PGLO6JxxzI9RzIOdwLcUDFAGeaeh8vWC8PvSt2d0wO0FJadhxHndeGhtHmIfz14qG4epp3Dw9DrhfTnocKb37+wXaHGOTylAcdS769s30RTqUvtye+nSgnAU0U4Oyi21Ld8bFgc9P+9rNoYWpfAAuXx/NnNRpuy7hy9scbDzuuNVb2210vnwNNncOdh/jx8rHJn2mmhOfT8ujpl+/Hn5w6q/H4c5/vrjVve1xy97yi99Ap6qUb4s/H9E4Kp0z9PdXJxKHXUttY71dcQJsLjMzvFOfdQzqB2O+f27eD0BF0R+LgAAAAAwGvAUhEAAADgAeDj4h4wXAAAAAAPUC8M2uYuRh91z8VSEQAAAAC8Bsy4AAAAAB6g3tGwAdfwGVXR8FdeF9baBoWKPYJ655t7UW/sQBPdX1pOQ4PH96ThroNNVA3RM6hCGea+uIpeb1APqmQ5aqXqhpRIqs4orA6j16um14sKoh7z2QUnPOpHJNAQ8HtKqDpgclKmMr3A4WLqvc+vx5+Vt83+EhpW3GajtnNKLH3WKjtVTnB4W0YF02fnuFp/npKAtwe/f7C/TdkX/Hl4egaesuCwtYdL7VFaRdUY8WZLq+fzY3k6CJ6eQC99g9645/v5OK+y+bs0FvnYGhaRqwyp/8HRscq+5fB0C/x5bu2zXKlG5H2ZXUqVLUlhVLUUylIurDqcrByret8TPOVCJSvzseTcnlNidigVZy/un6y8N4enFlmZP5CUR0YfUaYU4Kk69J4tJsiqbHvOX/utbPrd3xgirhqwvFNURVlHU0R9O1RFRkOYSE3yvZD/WCoCAAAAgNeApSIAAADAA9S10znX4aPOuTBcAAAAAA9Q7zBom/sYhC+CpSIAAAAAeA2YcQEAAAA8AJaK3MMnVUWRQ4+TY06PyVGqdrhagecU4WqLq2LXK3MP8fOTAoqVz6CXc4Tn40kwWVrNacLzwfB8J3o5QvTqxvO/cPRyHfG68/wuvD56OVX4+esraV8MCcpR5tfhuZD4+Xp9x/PlTAimxy+uSHTp/Mxq9fGTwnaS8jLrUFK+tcevTb9vrKGKKA4fZ3q5dzh8LCwqS6N1iVor2gPPP6OXW4jXR28/z5O1vKqvMu9XevABl3If8XdxUfnpLo1NnkeM097nVx2r+o5pS44xvbqn+MuYsifIthmV43p0CM3nxtGrr3NfmQyh4sLkNZ2iKtp0ZFi7VUVpvXf4nKoIMy4AAACAB3C008fFAB8XAAAAAICuDWZcAAAAAA/5uMjNfQzCF4HhAgAAAHiAOodR29zHKHwR33xqAAAAAHglPjPjUhdSL+p+81Tn+WTW5/VR5nfheTUKy8OU+XU+LRhNyrFBFqWqaEVpqkuqJq5kefno+aTcL4yqpgqqT6g/zu1BlSGbLP2U976810Zlvheer+Wr0pGknBpMFU9ldSFKZYa1LlB5/tFamusoNYDufymX5lAZHk7zu3C+Lh5ByhtYTpX8mnBljpS9plhlTpYdZQmk/CnLR8PHBs9vc1HUFmV7LdxDlSgRQyuVx/9p37RWc1zp5ZtZWTKYlPlY+q5wGCmHsGdNDi0i5fnFdCxx+FiYEL7LJbVeXm2Esm3TzAeVY3NtcbLyXeBjkZcnmXcqVVU8lxInNYDmMHuucDwph/nVuKRWzKxKUNYvqza+1XHDcxVlVcQrn53XJcJPnUOMKyPnl6jVfzx3Eb8+70veFlwNmWvrQXIVdRYyam59O+YPDFgqAgAAAEBnAR8X98BSEQAAAAC8Bp9ZKgIAAAC6EnDOdQ8YLgAAAIAHaPBxQQA6V/GZkP8jXjoR8j9tfJbynErmgKnnZMjhjmDcsY2jF6qcw8Pec0ez8cE0XPammtpWw4wvrxisdJLTC/nPnWM5/Fm48y53uOQpADg8LDkPq84dGlWhvdvS9in+1NnWwqJc8rD3vH4ZVf2FCj429OrDQ5fz/uNOkTxlgHP76o0j/ix87GTVxijb3lX0+orD72c2OJQpAfjxg/1DW31PWmr7UYHUATS3rk5ZP7324c+r17783TjZ75Lz/fm44s63Z4TucymdAX9Wjl5b85D/HL2x4ux8q5cmRYbRH5y0u1NC/i87mC7qHBVuX8fPECom9ctAyH8AAAAAdDxSUVTXLlWRUfgiWCoCAAAAvNDHxQDDBQAAAACdOePSnjgu9T5quPjmUwMAAADAK8FSEQAAAOAB6hwGbXMXAyLndm/qTULU17ccZp2TWdqLlKfE7FAer6fEyaxOJOXRIfuUHvXc2985FHdLShF+v7dKg1qtH/f2Tw8+oKzLhOBDLqlquOqFq2r0wrbfGrWWXr+OKrw4ekoWPRURbw9ezraFK9UOQtDnTfDzo3vr85QqJbOR/u9gqbfTso4640/hdCzNLzmVlCeF7Wyz+oLXjT87p1lbMlUP7zs9tRwfO3qqGN7WH5UPUL6XvH5vlSYq3wUOVxHpqYImBFN1oRC0vtlU/NdMycMVZ/x74c9Ra1xSoPH22lgT0uq7Oi0s2yWFFm9bTsJv6VZaa0s+LjfSbAa6Y1UIOhZT+P10viecv8ekUof2RMchHXPhnOs6WCoCAAAAgNeApSIAAADAA9Q7jNrm9vnCN+ceYLgAAAAAHgBLRe7hm+YaAAAAALwSzLgAAAAAHkC6ELdHVWR0/1SvxmcMl/oAh6j/LS3T6rxksi/Yn6oBSquod35WZLxSdTQjiXr7/9+xUaS8v4Tm+VhuTiHlPmFUPRAXSD3mrXWBpFxQbVbmVuIcjaD3dya/hipHQk3UnT/Mr8alPEw51VTh9F3hMGXdeB6obDOtzzLLUFIeEpyrzKFiqQtSth2HP9/+imhSnhq9nZTXVw5Q3o/ncFleforyfjy30NpiOjZjgqykXMH6mivkKuz0eZcXtD7W+DhbUnSaMifXJPNOZd/wsTQ+kuYEy6xKULZ1KBsL/Hyupns4f6TyvTgaSsdGDhs7WVXxyrHEx3o5U+1wRZxeX/KxzsdWWV2Isvxp+WhSHh5+lJQj/CqV9V3E1I187DrX/7o9V5F9M5LWKtWEWTXxyrrn1UaQcmpwnvJ7Qk/Jye/H+46PxTTzwTbnCDMaOu/PIgLQuQeWigAAAADgNfjMjAsAAADQnXIVGdtxrjcDwwUAAADwAPXCoG3tOd8X8ai5ds4554j//ve/IicnRzgcDjFt2rRmxzz22GMiNzdXVFZWih9++EEMHDjQI3UFAAAAOmLGpT2bL+LRpw4NDRXbtm0Tt956a4v777//fnHHHXeImTNnitGjR4uKigqxdOlSERiodrgEAAAAQPfEo0tF3333nba1xl133SWefPJJbVZGMmPGDJGfny8uueQS8dlnn7l0r4DjRhFY02CnRZ1Gve+HRB4j5YPWnkolyPT4LUrv/GERuUoPeZ5DhaszuJqBqxVEmHCJ9KDDTb9n1caQfbkBPdT3YmRY++vkOqLnX95ro1IZwpUZHK5k4UoJ3lYcnmuJ51zheaS4soUzJChHWf9cWw+leqJZ/hydfDw8r5VeHiuurrgmmqpBviod2WrbcQUWb3ueHyaLnc8VVTyfDR87XFXDaaZ6YWPnksjNwhX42OEKLP6e87bk7wZ/Xt73Hw1YrMzPk1HdR6kK4mOF7+foqZJ4f/PnU33H8WNTA9TjmudP4+8Nz0OVmpSnVO/pvee8L0SoOq9Wgh99zxdbT6jv/I0hIk14RwA6o4/qa7rsU/fv31/Ex8eLZcuWNX1WXl4u1q9fL8aOHevRugEAAADtpd5haPfmi3RZ59xevRpipcgZFmdkuXFfSwQEBJClJLOZxhsAAAAAgPfSZWdc3GX27NnazEzjJh1/AQAAgK6GDEBX146tvvv9CW8TXfapjx1r8DuJi4sjn8ty476WeOaZZ0R4eHjTlphIfRgAAACArpQduj2bL9Jln/rAgQMiLy9PTJw4kSz7SHXR2rXU4dCZ2tpaYbFYyAYAAACA7oHJ03Jo57gs0iF3+PDhori4WBw5ckS8/PLL4uGHHxZ79uzRDJknnnhCi+ny1VdfuXyv2p71oqZWprQSYvdB6iOzx58qTa4+LUOZU0UPnieDsyhvhFLVtMnSj5SzS2n9ksKoh/y5PXYrzxeRrSs7uJJi6dEhpHxZ3y1KJcYThy9SKqq4GmBFaapQkRUQr8xhUmX3J+WeQRVKpcojeZOVuZjiA8pIeWBIgTK/zvSITcq+1sul9Paxccq+40qaj4vGKvP38OvznDDL6qhizZVxlh52oFVFUkuKKa6wstQHCxU8pxdX3/H6ZZnilX23rTxJmWuJ9w3va972HN7WXPH1Navvu/vPIuXJSZlKJUyiqcSlvFj83dJTvHElEIePdRXLrEOV99ZThCWY6D+ULxz7HSmv2DeIlOekfe3S9fmzc4XccqbGW1kyuOn3YL8g8RfROdQJg7a153xfxKOGy6hRo8SKFSuayvPmzdN+/vvf/xbXX3+9eP755zXj5u233xaRkZFi1apVYsqUKaKmhv7xAQAAALyN9i731PvoUpFHDZeff/5ZGAxqi/HRRx/VNgAAAACALiuHBgAAALozMiRh+5aKfBMYLgAAAIAHwFKRe0hTzyG6MVKJJOO5jHjpdWGtbQjzbBxsJceMSDiqdOrjDpgV9gBSvip2vbIOPKw8d2TjLC8/hZT/HLXGJcc4Hk5b5fA3KWxnm0NhSyaE7laGLecOftwhku/nTnMcHjqc08xJj4Vld0530FJ9uUMkDwvP4aHDLex4HpKf7+dOibl2dYBEveN5ffXql1UT32pIeD4WzEabsm68LryuvK31nEN5XfWeLcceqXzPmqXOYA6c3HmYjyWezoK3h9lAvzqzbWqnfD42+PUWlZ+ufK/TA6kzMcfCoqjy/uEpGzjO77peagqeakKvbzOq+rv0PcLfSz62eOoSPVxpO6MhTAxO2q2F0+goVWrj36Vnd10pauvpuHSFAGOwePCUzzq0rl0R3/TsAQAAAHyUWbNmaUrdqqoqsW7dOpGenq48/s477xRZWVmisrJSHD58WMydO9ejyY5huAAAAAAewCEMor4dm8MN/5grrrhCMzwee+wxMXLkSLFt2zaxdOlSERPT8izWH//4R/Hss89qxw8ZMkTceOON4sorrxRPP/208BQwXAAAAAAPUOcwtntzlXvuuUe88847WtiRzMxMMXPmTG0m5YYbbmjx+DPPPFOsXr1afPLJJ+LQoUPihx9+0H4/44wzhKeA4QIAAAB4MWazmWwy2XBL+Pv7i7S0NLFs2bKmzxwOh1YeO5YGu2xkzZo12jmNy0kyUOwFF1wgvvnmG+EpoCoCAAAAPEC9w6Bt7TlfwpMJz5kzR1va4URHRwuTySTy8/PJ57KcmtpyVHM5uyLPkwFgZdw1afy8+eabWl5AT+EzhostvF7YbA0h//1sfmTfui0nwj1LNpXRDgwcStUMo+OpUuXF/TSs/JGjPUl50jAa6vtfv9JQ4EMT1R75L1XT63O+OERTCEQFV5JycdUJ9ciNyauVCiUeNp2jF4I/vechUn541XRSjo6jygZzX6pWWF6QokyHUFBNlRLHq0NJuU8YVSMkRtPykqLTSHlPCV3XDfanSo9gk02ZYoCH7OfpHHh94gLLlSoovbDuXAmkF6beWhfYavvFBlEVwku5k5XPxpUm92Vephx3E2KzlXXlIfRX5g+k94/bq3wWnq6C88HRscqxxFMa8Prwsl4qjzTzQeX5vK/XFieT8tio/crrX5n5Z1IeGX1EmYKBv6v9wo6T8kFrz1ZTLjirz9rUFpHqdA783llV9Pqbi3qT8t+Sl9LjK+KV6SB4+gb+3jxXOL7NYyfQGCweVX8NnjQaszy353yJTCbsrCo6mdHlx40bJx566CHNoXf9+vVamp5XXnlFS8fz5JNPCk/gM4YLAAAA0B2xtDGhcFFRkbDb7SIuLo58LsvHjlHDvhGZI/DDDz8U7777rlbesWNHUyqep556Sltq6mzg4wIAAAB4cKmoPZsr2Gw2sWnTJjFx4sSmz+TyjyyvXbu2xXNCQkJEfX3DakUjdXUNMXv1UvZ0FJhxAQAAADxAvTBqW3vOdxUphV6wYIHYuHGj2LBhg7jrrru0GZT3339f2y/3SZ8ZuTwk+frrrzUl0pYtW5qWiuQsjPycGzSdBQwXAAAAwEf4/PPPtZgtjz/+uOjVq5fYunWrmDJliigoaPAT6tOnDzFIpB+LXA6SP6UvTWFhoWa0/P3vf/fYM8BwAQAAADxAncOgbe053x3mz5+vbS1x3nnnNVsWkkaO3LoKPpOraOhH84TV1pCHx9yTKkNmDV6pvAZXcnCPdb38PDzvBs+/MyH4kDLniKXe36U8IYvK0lqtj15deG4fnu+E5zpyJU9SS2qFBP8SZU6RjJpYZX4ZDn8+Ds+5wlVVPF8Pb2ue70bveXmOleUVg5U5W3hf83w8qQGFyv7R60/nHC96bcnHFa8L76vcugCX8jRxeL4aVd1bqj+vL8+7xd8rfj/et7k2dZ4s3ne8L0YFUpXV/JJTle+OXp4pjl57cvjz8u8d51xLejmy9N6j0SH7lHmn+Hujl0eJjy1X4WNXhckQKi5MXtMpuYru33aDqGlHrqJAY7B4fvh7PperCDMuAAAAgAdwOIxahuj2nO+L+OZTAwAAAMArwYwLAAAA4AHqhEHb2nO+LwLDBQAAAPAA9Y4TYfvdPd8XwVIRAAAAALwGn5lxMfjXC4No0KZby6ka4Y3d55LyhN57SDmztJcy5wnPe8FVRpYA6lG/soQqSzKC+pPyJZGbSfmZgxco8+VkhiYoc7qQ+jAhCc9BwnOMhJhqlbmBIuKpcmIDux5XYPEcI1kmqtqZXzqBlGf3oxlIN1QMUD6rJThImR+GPy/Pn6On5Pi6mOYiCjXRvq+w0/pcE71WWR+uMuIKtgg/2r56cFUVV+KoVDSuqloWW1OUCjGu+uGKMj21nl7bcFUOV4B9aO2vzE3E24orX3hfZbDr8fpwyutp/Ti8vT8sPpOU4wPKlHnEropdr7w+b3/e3x+UjWhVCcTHDVcB8bbmKqJlFqoyOiOU7tcbSzwv1lelI5Xn87xLdyX9oDw+szqRlKeHb2363WhwX+XjKvXtdM6t91HnXJ8xXAAAAICuRMO/0+1YKhK+6ePim+YaAAAAALwSzLgAAAAAPhQ519uB4QIAAAB4APi4uIfPGC4BQTYRaLJpv09OzlQemxqcp3SS0wtnzZ3iuANobJBF6TTIw7bPSFqrdCrkYfhvjVrbquPbkqLT1A5+1He12bPyMOaLK6iT24PRGaS8sYY6MGZVxSsdkS9hkbl5aPFJZhqSn8P7gjvh6YVZNxttyuulmQ8qnQi5Ayov8+P5G8j7noex506RfGxNCKf9lW1rPSUBTw3B25aHYV9e1UMZ8p7D0xfwtjUbHMqQ/Hw/xzlEfUvpEHhIez0sDnXIdP7e6aVz0EsHweHvAh97/F3k8LGWHnxA6Wzt7JDKw/rrvRd8bPCQ/KrvIO36rG7csZs/+wMxK5SOxX/us0ZZX2EXyrZ0dkaWIf9pT4Kuhs8YLgAAAECXc85tTxwXgaUiAAAAAHQSjnaqihwwXAAAAADQWcjZlvZFzjUIXwRyaAAAAAB4DfBxAQAAADwAVEXuIeeZunWaJrPZLMrLy8XQ918RVltD+Ponz1tIjkkPOtzmMOktqYa48iMtkHrY/7eCKmvSAwtcUktwuLKHw5U8zsqcBL9apZKDk+DnR4+vtyvrytUGHLPRpLwer4/e/fXQu15uXZ26vi4qX/Sej+Nq+3G4miPHHqlU2jg/P392Pu75uRy9Z29eV3q/wf40fYS1nqpwwoxUWZJntyrvx6+vp0ribadHin+9S/fjY8VZtdNSX/OxwFVL7b1+Rk0sKV8cSr9Hdtsq3O5bDh/38aawVu/VkgKNK6B4W3D03mtX3mODIUwkJO4R4eHhwmJR37e9f5dmrL9bVNW5pj5zJtgvSHwwel6H1rUrgqUiAAAAAHgNWCoCAAAAPAByFbkHDBcAAADAA0BV5B5YKgIAAACA14AZFwAAAMADYMbFPXzGcDFWG4WxtmGCac6mi8i+5Lgi5bnpPWnOkx1lCaS8M4fmCAkOqSHleDP19g7+LWdSI/3CjpNymB89f2X+QFIuLKce+v7+1IN/dDxVSVXYT6gnkkPpsyYFFJPyu/vPIuXScqaI6ntImXeJw/MwcTKs/ZV5obaVJ5Hy8PCjyuvx51lRmtpqW7TUHrytz43bS8r5NVT5MTCEKsSWF6Qo80zx3EKcZZahpGz2UysOeO6lF/dPVh7v/DzWukBl239dTPPBxAVSlQo/X6+vM6sSXHo2Tl5thHI/f2/2V0STciXr+7FR+5V9NyTymPL5+PPwsTMy+ggpTwjfRcrPFY4k5YPWnsrvBQ4/PibIquwv3t7LyyPa3JYc3vd6+d44PGcZP/5obZRL7x1/7/n5nElhNC9XlpMaT+Yqoj3bccBwcQ8sFQEAAADAa/CZGRcAAACgK4EZF/eA4QIAAAB4ABn2rn1JFn0TGC4AAACAB8CMi3vAxwUAAAAAXoPPzLg4TA7hcDRMrNmr6GPvz49Wqoz+s+pMUk4aRD3a43tSNUZplVo5kmOh3vxVdn9lfXh9eydRtUFUEM05sj6vT6uqpoxDfcm+yHB67lnxVGlR0IPmP9lTQvPZHPWnuXGSwkpJOUNQ1dDqvGRSvqzvFqVyhKuIluQOEyp4W/C2TjSXKZUgnE9+oiqrxFPyleoGriLiqqbCaqoIK66mqq2847S+V56yiZQzjtP+EzT9TLOxxxVmS48Oafo9Kpi2VUGQWanC0YMrpsrqQpRqPK6a4aomrvLpE1ZCyqGmGqVqho8dPrb0xtLmot60PkcGKdWCVTb6HhdU0/Z8Iu9CUp6clKn8Hsgs7aV8/hBTrbI9PtuVRso3nbqalCvsga2qkLgi63g1zSvVM4jmGgpldXlj97mkHBlcrWyrzf69ld8jfCxydeDy6hRl/bh6cFFZWqvvVYhfoLiQfk11GJhxcQ+fMVwAAACArgQMF/fAUhEAAAAAvAbMuAAAAAAeADMuXjjj8uCDD4oNGzaI8vJykZ+fLxYtWiQGDx5MjgkMDBSvv/66KCoqEhaLRXzxxRciNpYt7AMAAABehsNhaPfmi3jUcBk3bpyYP3++GDNmjDj//POFv7+/+P7770VIyAmnvnnz5omLLrpIXH755drxCQkJ4ssvv/RktQEAAADgIQxdKYZNdHS0KCwsFOeee6745ZdfRHh4uFa++uqrxcKFC7VjUlJSRFZWlmbsrF+/XveaZrNZm9FJe3K+qKhp8Hwf/Lt9LuUE4TlKeB4MrlbgeTfSg9U5XFwlo6q/8vqWeqruMBtPePSbjTRPEmd5BZ3xmhC6m17LQIdLto3mEEnxL1fuz6qhOUqmhWUrj+eUs2dLDSik16+lqidOuFNbtAVX78f3W+qpeiKrlj5/ookqRRJMFpeeh5NoomqMHKccLHroPRtvO+dx1RJ6Y00PvfuPCqSqqOVV9L1MD6SKLwv775T3DX9vcuw9SHlCMM3TlVETq2x7vfeUt09GNVUDpgbkKa+n924ur+qrvJ7qedODDivbited35u3NSfXblaOpRT/emXf8rHAv3f4/flY4n3l3BZ+hlAxrt9m7e+PnOXvCBr/Lk1Z8bCorFPnhVIR4hcovhv/ZIfWtSvSpZxzIyIaDIDi4oaEWWlpaSIgIEAsW7as6Zjs7Gxx6NAhMXbsWI/VEwAAADhZPi7t2XyRLuOcazAYxMsvvyxWrVoldu5syNzZq1cvUVNTI8rKaHwH6Q8j97WENHSkX4yzZQsAAACA7kGXmXGRvi7Dhg0TV111VbuuM3v2bG0KrnHLyck5aXUEAAAAThZwzvViw+W1114TF154oTjvvPOIoXHs2DFt9qRxCamRuLg4bV9LPPPMM9p6X+OWmJjY4fUHAAAAXAVLRV66VCSNlunTp4vx48eLgwcPkn2bNm0StbW1YuLEiU1KIimX7tu3r1i7loZWb0QeLzcVPLR2mB91jjojdJ/SEYyHNp8evVXpeMZJ8KP1izfRMPArqoxKh1Ye2pzDHd2cHem4k52eAyF3GOTOpLxu3LlU34HT5JKT3uKKHi45cHIHS1cdUDl6Tn6D/Wlo9I8tPV1ykOT9w+vD25ePNX69CcEN/mItsbhCbdS76tzKxzXvW062zah0+OR1z62rY2Wh86z0/hnMwZP3HXfw1HP45Oc3qz9znm3eXn5CBe/LP4XvUz4/d2znY42/S0JUtvq8vO8WV9P3nDvv8u8wi61Cx7m3Wjl2sm0Bro1FVubOwnpjybnvjOzcjqS9kmYHfFw8szwkFUPTpk3TPKLlTIpE+rRUV1drSz3vvvuumDt3ruawK8vS0FmzZk2bFEUAAAAA6F54dMZl1qxZ2s+ff/6ZfH7dddeJBQsWaL/ffffdor6+XpNDy2WjpUuXNp0HAAAAeCuOdiqDHJhx8YySSA+pKrrtttu0DQAAAOguyEUpRztWphzCN+kSzrkAAAAAAF7hnAsAAAD4IvXCoG3tOd8X8RnDpT7YIer8HC2qinaUJZByxnEaKrtPGFXSDAyhHu43Zf2JlM+N20vK+yui6f0KafC80fHUQ39m7E+kvMnSj5RDTVQFlelH62+tOxGATzIhfFfT7xsqBpB9Q4JzlSqjsroQut/av9VrtwQPcc/hobwzq6nSJcOPKh8S/EtcUgFxBRhX4fD77a2kYdzTzAeViq5FZbQ9MwKKlcfz9sisSlAq2nj9hgTluKSi4mWzsUq0Fa5S0Ut/wI/nyhG9kPq8brk6z8YVbovKaV+MDqFtyeF9kcBC+ufWBShVQzydAle+8PP5829kkd71wuxzFRhPPZLExh4f+5b6PGV/WuqDRWvwvuFqwwz2Gk4IttLzmWqIp0tYZlWPc7OxUJmapFnaE15/h63NijgDVEVdHiwVAQAAAMBr8JkZFwAAAKAr0d58Q/VQFQEAAACgs5CKonapihzCJ8FSEQAAAAC8BiwVAQAAAB4AIf/dw2cMl9o4m6i1Uc/y1hgS2XICx9b4W/JS5X7u7X9uj91K5Q5XO1wTvVapBuDKE36/XNsJNcatUfRaH5SNUJ7L861wNQGneY4QqtRYbE1R1p0rQXi+GH5+Is+txFRRWVXxSoUWV4jd1+t74UquIq4C4vlrXMW5r1pShvD2mh6+1aXcUM7KFq4KchW9PE98HHMVDK87V3zpqYh43qZJYTuVuXmybVylJJT5bvTGNu9rrpTRU3zpqYh4/h7Bcg/ptQdvz69KR5JyajC93rSw7DYrorgCaVooVQFtrAlX1o23XXpEgbItOVxduMw61KWx1VxRdaKv/Ayhgmr9Og4YLu7hM4YLAAAA0JWAc657wMcFAAAAAF4DZlwAAAAADwBVkXvAcAEAAAA8Zri0Jzu08EmwVAQAAAAAr8F3ZlxsxoZNCJF3PILsGplyhJSXZA8j5fED9pDyWmsyKVsiqIf6yvyBpJwURj3oh4cfpffLpfebmrBDqcZYW0zvPyyC5hvaVp5Ez7eeyKmyKZKqajj82h/Yx5JycRVVQE1OylSqXrgqhrdNVFClMldQhZ2qG0JNtUqVED++kpV5nip+PK8vz2MVE0RzsOjBVUv8+jyvVJgfS2DDWF6QomwvDn8+Z0Xb28fGkX3JoUVKxRRHL88Tvzcf93OOXkjKx6tDSfnWPstJeX3lAOX9eA6vSyI3K1U1f45aQ8qLyk9XvpfBJqpKTO95SDlW+FjjOc9WiFRSXp9HFXvDYqi6cWr0dpe+F/qFHRcqvisc1qq6kY+z6fFblNd6OP9s4Qqr82hdo4Lp98CE2BMKJ8n8wxOU+/l79cKx3ynHBsd5LBgNnfdnEaoi9/AdwwUAAADoQsiVnvas9jiEb4KlIgAAAAB4DZhxAQAAADwAlorcA4YLAAAA4AmwVuQWWCoCAAAAPIHD0DTr4s4m3JRSz5o1Sxw4cEBUVVWJdevWifT0dOXxERER4vXXXxe5ubmiurpaZGdni9///vfCU/jkjMvUlB1KJUdyXJEyVxDPObKilKoDRkZTlVJ62AGlGuDcuL3KfD1cDcFVRDN6rCPlXHPreTl4jhCeg4TfKz6gTJnLiD8LVzRxpQpXTHH4sy+z0BwkZr9qpZrAHKLePz1ikzLHSYQfVTeckaDORcTz8aSyfDI8d9KQIJrTZXn5KS7lPhoSTPuew8fiVbHrW8+fQ4dxM3iuHZ7fhecG4n3H3xOzsUp5PL8+vz/PPyPC1bmT+P0nhO9S9h0f2/9K/YiUPygZQ8qTzDuVfcPHHs+vs6GCqqRmDV6pzBPG8+00a88k9bvD6ytOiA2bMSl5p3Ic87pxUgPpe8Dh34k8bxPvy6SkYpeODzdXu5THyfn5/I0hIk10X6644goxd+5cMXPmTLF+/Xpx1113iaVLl4qUlBRRWNg8f5m/v7/44YcfREFBgbjssstETk6O6Nu3rygtbV9etvbgk4YLAAAA4IuRc++55x7xzjvviH//+99aWRowU6dOFTfccIN47rnnmh0vP4+KihJnnnmmsNsbMpMeOkRDAXQ2WCoCAAAAPEB7lokcjctFcvbNbCZbQACNoeQ8e5KWliaWLVvmVAeHVh47lsbsauTiiy8Wa9euFfPnzxfHjh0Tv/76q5g9e7YwGj1nPsBwAQAAALyYnJwcUV5e3rRJw6IloqOjhclkEvn5+eRzWe7Vq1eL5yQnJ2tLRH5+fuKCCy4QTzzxhLj33nvFww8/LDwFlooAAAAAT9AOB1uN385NTEwUFssJP56aGnWkYFeQMyvSv+Xmm28W9fX1YvPmzdr97rvvPvH4448LT+AzhktAsZ8IqPXTfq+w0zDrHB5qnMOd7rjzLifFv5yUs00lSscx7mjGHdm4U97yisFKB1ZnRzbulMbrxh0YuYMkd3jkDpN6DpecXFsP5fHcmZaT4EdTAGTbqMdmVg11wDQbbUpn3GlhLJQ4+1JJ8POj++tpX3L49TJqYpVh6c2svTmJbOzw9no8fqnyfs5h87mjcHogTU/AMRtpW3EWV/RQOlAO9qch/VdUGZWOyNwhlL8nlnp/5flClCrHCu9bHvJ/QvAhpXMrr4/etyt3fOd9z98t/nx8bPDjUwOoY+WtUfR7yWykFdpYE6K8nsrZltdNz5GYj1P+HcaP52Mxt44ufZgNDuXxfNyLBteMVnGuv9EQJrzNx8VisRDDpTWKioo0P5W4uDjyuSzLZaCWyMvLEzabTTNaGsnMzBTx8fHa0pPc19lgqQgAAADwAWw2m9i0aZOYOHFi02cGg0ErSz+Wlli9erUYOHCgdlwjgwcP1qTRnjBaJDBcAAAAAE8GoGvP5iJSCv2Xv/xFzJgxQ6Smpoo333xThIaGivfff1/bv2DBAvH00083HS/3S1XRK6+8IgYNGqT5uTz00EOas66n8JmlIgAAAMDXQ/5//vnnIiYmRvNPkQ65W7duFVOmTNH8WCR9+vQhy0JHjx4VkydPFvPmzRPbt2/XHIGlEdOSdLqzgOECAAAA+BDz589vdcbkvPPOa/aZjK7bmly6rfTu3VsLXBcSEqIFutu5c6eoraV+Z20FhgsAAADgKdrhnNvVkYbKLbfcIq666iqRlJRE/GSk0fLLL7+It99+WyxcuFCLJ9NWDN272RoC80hd+9CP5gmrrcG6M5ZTe23Cmb+S8tbCRFK2VlEVUkos9WAfG7WflPdWUo/2VYeTSfnSQVSJ89+Dw0g53ky9w/uEUSVJXCBVAlnraP02F/VuNQUBD+G/vCBFqAg2Ueery3ttJOX/OzaKlGOCrKRcWE099ENM1MKeGr2dlJcUnaasDz8+sypB2Rb8ebmKiKcs4CH3vy4eQcoXRW0hZUt9sPJ6enBlT2Y1HXucvNoIZboKHna+mXrDScXF1Weu1p2HyOdqOz34/fj1sqrilYq3TwtGK9MbvLh/sjKE/xtF45TX5yH591dEk3JskEXZF3wschUR5+Mi+h/t+MgsZTqHNPNBUub9yd8NPjb49ZzVkTxdAD83w0oVX7Oif1aqhLhiideN9z2Hp0vgzD88gZRnJK1V1leVhiXAGCzuHbJQhIeHt0mp056/S8M+ndv0d8kdwvwDxI6r7unQurqLXE669tprtXQCX3/9tdiwYYPm0CvzI0mfmWHDholzzjlHM2rq6urE9ddfLzZupH9fWgMzLgAAAIAn6MbZoSsqKrTgdcXFzY1SuVT0008/aZv0tZE+NHIpCYYLAAAAADyCVB61FTkr4wqQQwMAAAAewXAStq7Pjz/+KCIi6DJ345KZ3Ocqbhkuck2qNZ5//nl3LgkAAAD4Fh6I4+IJxo8f32Lix6CgIM3PxVXc8nGRAWlKS0vFd9991yywjTRq7r//fncuCwAAAIBuwqmnntr0+ymnnEL8XWTSRhk/RsaF6RTD5ZprrhGffPKJuPDCC7VwwJJXX31V/OEPf2hRA94VCDwaIOy/OW+POD9Tqfq5LnWdUiUUaqLqgS8OUeXJ6TG0I8KC6fE7yqhHfaCpTll3riLi8NxLzioiyUFrzxN1iaB1ybNQ7/9Zg1eS8qK8EUo1AFdUcXUAV45w5QlXER2vpvlsquw0J4qlh1q5UlBtVio9OFz5wVVEvO250oSfnxpMc7qkB1P1whOHLyLlvDC1Sohfn/e1Sh3Rkgops/REBtgJsdnKcT4whKrntpUnkbIllPbFyvyBynHI68oVXFwlxFU7XCUUFUQVYu/l0v/cpibsIOX7D/5BqZDjCrH8Gpr3KpQp4nhfcAUbh+cq4mOFw1U/fCxusvRj9atRjiX+7lbYA1pV/nCFElfl8Gefc/RCUh4eflSpnss43peUrZHqcc1VQ1ztqKci4n3Dc345fy/5d6YDRTd2zpXI4HZS5iy35cub5wCUCqPbb79ddIrh8s0334hZs2aJ//73v+L8888XN954o5g2bZpmtOzZs8edSwIAAAC+xUnKDt1V6d+/vxa7Zf/+/eKMM87Q1ETOcVxktF7nKL1txW05tJxxiYyM1GZcZGXGjRsn9u2j/0EBAAAAwDc5fPhw07LQyaTNhstLL73U4ufSaNm8ebM2A9PIvffee3JqBwAAAHRTZLBYFwLGtni+N/Dggw+K/Pz8pkSOjcigczJvkquinjYbLiNG0LX/Rvbu3atF7Wvc70rYXgAAAMBn6eY+Lo389a9/FVdffbXgyHxFn376accZLhMmUOcoAAAAAAA9ZBbqvLy8Flds4uNpao9Oy1Ukg8hIwyYrK0tkZ1OlgqdpzAkx/IsXhPU3WdHQxDylMoZ7wIcbqYc9p7w+qNV8MJIJobtJOaO6DymnBzWsA7bGYH+qtNltq1DmBUkwWVrdPyqQKjGybdSFPsceScqJplJStrBnNbO2MRupt7/ZQIfXB2V05m56OM3bxOHn59ZRJUSCnzrPR7YtXFlfTlZtvLJvLPX+yudN0FnL3VgTQsq8Pyz1dmX9+fG5dWpFGh8bzufzuvBxnBpwwpGupb7gWJijIB/nqQH0vUsLpH25ooqOxRT/cmXf87ZvVh/WV3ysuDqWMmpile95amCe8j3k7Wc20v8bF1ckKpUvPN8PH5tZtTHKd1cP53c/PbBA+ewTgouV41Cv7fXgY0kP/t7x7zU+VpZXDCblaWEn/m4ZDGEiIXFPp+QqGrrglXbnKtp57Z1dMleRM7t37xaPPfaY+Pjjj8nnf/rTn7TPBwygas0Occ797LPPxMqVK7W02DKAjMwv0K9fP817WMZx+fLLL925LAAAAOAzSFtW5/8B3fO9gXfeeUe8/PLLwt/fv0kWPXHiRG2JqDX/2ZNuuJx77rniqaee0n6fPn26ZrBIhZHMBPnwww/DcAEAAAD08BEflxdeeEH07NlTvPHGG00RdKurq8Vzzz0nnn32WZev51aoHZlzoDECnox8t3DhQi2QzJIlS8SgQYPcuSQAAAAAuikPPvigpiAaM2aMGD58uIiKihJPPPGEW9dyy3A5cuSIGDt2rAgJCdEMl++//177vEePHpoV1VZmzpwptm3bJsrKyrRtzZo12vUaCQwMFK+//rooKirS1u+++OILERtL11oBAAAArw5A157Ny5x0pcEiY77JAHTu4tZSkVyrkk42VqtVHDp0SKxYsaJpCenXX39t83WOHj2qWWEy2q5cbpJLTYsXL9ak1bt27RLz5s0TU6dOFZdffrlm2EgjRvrPnH322S7Xua4kUNTZGjo5258aP/tLaJj0eHMKKaf3PKS8Ng+PvbyAnp8Vqfaa5qG491dEk/LU6O2knGEdpQxzz0OlO5PDQmmbjVXKsOk8LDoPpc3vzcOi8zDlPCUAd+Dk9eEh+NPMB0k5q8o1j3QeZp2fz0ONf1AyhpQnmXeSckYVbY+yuhBlGP2LoraQ8t05Y5Vh2y+J3EzKH5VTJ7YEf+rAyeEOmvx81bV43/C+1wtZz9MPcGfShwvSlG3LHbn5ezUk8piyPs3bplTpiP3EMfpe3ZDwC71/+SnKsbLMMlSoGBKcq9zP02HkiB7K/dwBVk9EsKgsTfm95fxucudYPo64Y/f6ygHKuqruJfnnwXNJ+a/9Viodu3nf8bHGBRa632tOzscmQ6ig38gdiI8sFUVFRYnPP/9ci64vQ6bIlZkDBw6Id999V5SUlIi//e1vHT/jIpMsyumeG264QTMiGmO3yLC+0selrfzvf/8T3377rRYLRhov8lxpDMlrSy9pmUrgnnvuET/99JMW5E4GqznrrLPE6NE0pwkAAAAAuiZyEsJms4k+ffqIyspKIvRxXmXp8JD/0pCQG89h5C5Go1GbWQkNDRVr164VaWlpmhPPsmXLmo6RUms5wyOXqdavX9/ideQ5conJWXYGAAAAdDl8ZMbld7/7nZg8eXKzTNBywqJvX5pws0MNl8TERHHxxRdrFlSjl7A7If+HDRumGSpSVi1nW6RKKTMzU5x++umipqZGWyJyRoYNlutkrTF79mwxZ84cN54IAAAA6ER8xHAJDQ0lMy3OS0jy73ynGC4y2JzMDC2XhlJTU8WOHTua4rjwWRg95CyKNFKkUumyyy4TCxYs0BI2usszzzwj5s6dS2ZcuJUHAAAAgM7hl19+ETNmzBCPPPKIVpbuJdJeuP/++zVXkE4xXKRx8OKLL2ozGzL636WXXqqlp5YOu999951L15LrXo1ZpaXRk56eLu68805t7Usu+UiDxnnWJS4uThw7Rp3ynJGeyu3xVgYAAAA6hfYqgxzeoSqSBsqPP/4oRo0apa3QyMBzQ4cO1WZcpN9qpxguQ4YMEX/84x+13+12uwgODhYVFRWaNSVVQW+99ZZoj6+LNFg2bdqkGSAyul5jJN7Bgwdr62FyaclVDHaDMPymKvL3p2HVJ/TeQ8rxAXR5alt5Eimf22O3Ur0wul+DIdaaxz33qOeqouHhR5VKGw5XHfFQ4Vk18a165/MQ/lNidijVAVzlwsOQ64Up59fjShMeint8ZJayLXiYdT14yH/nUN8thdhPNJe41JecmbE/KVMqXBOtHsvOfSdJDz6g7D+eEmB5VVSrz7vYmqITIp6WzeFVyuP1Qurz9ANnhO5T9g1PB8GVIjwlAVdB8fpxJQrnH32+Vj5PeKRatZMakafsa15fHqZeL91DSnC5TsoA9bvG21ulQtJT0/F0Brf2UKtJ9ULwJw5czPZXK8c5/57h36H82e5K+kFZf+ex6WdQp+04mfhK5NydO3dqf79vu+02LbRJWFiY9nddRt9XTUScVMNFGimNfi0ycZLMMyDly5LoaCrlVfH0009rqqLDhw9rSzoye+T48eM1Jx45kyOlUnLZRwa7k+XXXntNi/XSmmMuAAAAALoOJpNJW4mRcdvk3/yTck13Tlq3bp0mg5ZJFaWSSOYaOPXUU8Uf/vAHbV9bkcHkPvjgAy07pFwO2r59u2a0NCqJ7r77blFfX69F5pWzMEuXLhWzZs1yp8oAAABA18IHnHPtdrs47bTTTuo13TJcZGwVOdUjefTRR7Xfr7zySk3aJPe1lZtuukm5X3oby6kluQEAAADA+/joo4+0uGxS9esxw0VGvGtESpxuueWWk1IZAAAAwFeQXpft8nER3rNcJAPWTpo0SfNfle4m7oZQ0a7nTiWkCkiqfxoTLTYiFUBSGSR9XgAAAAAAhg0b1hQqRTrpOtMYed9Vg83ls+rq6rQgcIWFhc18VqSjrQwm11WQTr/SsTftyfmioqZBJVAdX0eOaVQbNWKMox7p6X1prqJ1+2jOFgfzmB/cj3pJ9wyi1uWekhhSrrFTL/Z4c+u5hrTzc2j+mzEDqNLkqJWqGapsNKeJM8eLG5b8GhmUWKCsO2dLLlVcpcTS86vs/sr8Mqvzkkk50UwVXSEs99GOwl5KRdiS7GGkbPKvU9aPX5/neVp+hGY7T+5RrDxfrz348XwslJaHKMeeKg+VZOn+IaQ8OTmz1dxSfJxwooKoQmls1H5lHiaeZymzlPbV/vxol56twn4iAnZbKKymYznHEkHKk5NoW/xnezopX31aBikvPUrbMtjfpmwfzra9vUnZFGxXjs0RCVRNyPtnZPQRl3KUbS6i95+aQBWDXxwa0er30MX9dijbgmOtClSO+35hx5V1SworVSorOXzsZZfGKq/H20bVdkHGYPH88Pe0tDNSAdORf5dOe/N1YW1H+I6wgACx/ZbbOrSu7UUqhaXkWeYxLC3lykX3cGnG5aKLLmr6XTrROsdX8fPz06TLBw/SJHgAAAAA8E3n3Pr6evH9999rYVQ8Yrh89dVXTVM7MsItDyQnjRZX16oAAAAA0H3ZsWOHSE5OPmkTGy4ZLnJWRSJD/Usfl+PH6fQfAAAAANqID8y4SB5++GEt2v4//vGPFp1zXV3mcss5V1pOAAAAAHAfX4mc+80332g/ZY5DZ2dcma9IlqXqqFOyQ8tEizJAnFy3ksiMzi+//LKWjwAAAAAAQHLeeeeJk4lbqiIZt+WVV14RX3zxRVPeoDFjxmjZnaUx88Ybb4iuQqP39rB3XhVW22/e2+FUHZAUR/NeuEpKZIFS3cDVGHm1EUoPe64e4OoKrt7gpIcdaDWPh9mPKqYi/KgyYmXJYJe8+/mzpAbTfC1Ha6OUuX14nqdcG823UlYXolQTxAWy/C06z8fvZ6kPVuY84fWdELpbmdOF54P5tGC0Ut3A+4rnl9FrH96+/P78+VT34vC25Pfibcv7ytXcQjyPVkZVf5fagu9fXn6KMs8WzzvF68vbjufJ0hs7Q4JzXXoXeH/w4611gcqxw+vHn39C+C7lfuccbXptofcsvC4bKgYon4XXLbM6Uahwdezy+vEcaTRXUagY129zp6iKhr/WflXRttu7tqqoI3BrxuWhhx7SDBSZIKkRmUdo9erV2r6uZLgAAAAAXRIf8XFpjPMmo+c2rtLIxIvvvfeeZsC5Cg1A0kYiIyO1pEkcKXmSlQMAAAAAkKSlpWmBa+WER1RUlLbJ9EDysxEjaDyhDjNcpIPN9OnTm30+bdo08b///c+dSwIAAAA+6Zzbns0bmDdvnmY39OvXT1x66aXa1r9/f81ekL6xHbZUdPvttzf9vmvXLvH3v/9djB8/nvi4yOh4MlM0AAAAAHRwGBo2d3F4R7aiUaNGib/85S9a1P1G5O/PP/+82LhxY8cZLnKKx5mSkhJxyimnaFsjMiqeTKT01FNPuVwRAAAAwKfwER+X8vJy0adPH5GdnU0+7927t1tOxW6piryJRu/toe+/0qQqGnsqzW8TyvLHjI/MUnrIpwdSFZGFWb1mNn+XbQsn5RT/cpf28+s7e8BLRgVSdcfyKurxn2g6EWbZUh+kvJfZSG3ZXCcLuSWyamOUyhFLPc1VpHf/3LoAUk7wq1W2VTm7nvOzSsxGW7v6hsPrx58nwWRx6fm5smV6+Fbl+XrtodeeqmvFm6gabtNvub1ag7ctr6se/Hw+liYEFyvHIr9fjj1S+Z7ytuJ9lfBbgM0T17e71Nb83eHnuzp29NAby2ZjtUvvgvP3jN645XXl1+LPqjdWeN/x95iPVb3vKV4fTkZNbKtjxWAIEwmJezpFVXT6vPntVhVtvfvWLq8qkipk6V7yt7/9TaxZs0b7TK7QvPDCC2LhwoXNJkY6LI4LAAAAANzHVwLQ/e1vf9MCzX3wwQdNweZkmqA333xTPPjggy5fzy3D5d1331Xul5InAAAAACjwkaUim80m7rrrLjF79mwxYEDDLLNUFFVV0dWMDjVcevSggZ/8/f3FsGHDNJn08uXL3aoIAAAAALof4eHhWq5D6RsrEy462xJ2u71zchX94Q9/aPaZzDkgp32kFQUAAAAAHdoraXZ4Rwt/+umn4uuvv9ZsBGeuuOIKcfHFF4upU6d6zjl38ODBYsWKFSIhgYa+7hLOuR/Na3LO7Z1Es1pHBVHn1v0l1Lk13kytwenxW0g5qyqelAuqqfNscmgRKe8oo+0TwpyDz+1Bw8pvsvQj5Qp7gPL6PJy2cyhvHvqa8/KeiaR8WV/6rGuL1Qk2+4WpM4bzMOVLik4j5anR24Ur8DDxbxWoc2KkmQ8q+04vZQEPJc5Dj0+P2ETKHxafqayPXjoH3l4rSlNJ+aKoLS6lTHAO08+fhV+bjzPeN/zZ+fU4vC31ztdL18DDwvMw9Xrw8yeF7STlZdahyvqkBtKx8nHRWFI+bKV9MSOpIXREa+3N+975vZWMDqH/FObYe7Qr5QBvf+fvDX5v3jb8PeOChkRTibKuHL10Bfw79eZePyuv72pKAOf7mwyh4sLkNZ3inDvihfmioh3OuaEBAWLLfV3fOff48eOaM25WFh0nKSkpWsT96Ojojg9A1xpy7crVLI8AAAAA6L4EBga2aBtIN5Pg4NbzqbWGW1YGDzInl4ni4+O16Z4FCxa4c0kAAADAt/AR59wNGzaIm2++Wdxxxx3k85kzZ4pNm+gsdYcZLjy3QH19vSgsLBT33nuvljQJAAAAAGp8RQ798MMPi2XLlonhw4eLH3/8Ufts4sSJIj09Xfzud7/rHMNFzqzIWZbKyoY13759+4pLLrlEHDp0iIT0BQAAAIBvs2bNGjF27Fhx3333aQ65Uga9fft2LXTK3r17O8dw+eqrr8SXX34p/vnPf2rZoNetW6fptKWDjcz4+NZbb7lzWQAAAAB0Q7Zt2yb+9Kc/nZRruaUqkstC48aN05ItSotJJmCUy0cy4+Pjjz9O8hd5mibv7ZdebwqtfO4kqo4YGEJDg3O4moArNfTUCFzJw5UwXHnCPfr1lCtZtfFKD31LfbDb3v4cfj4P/b28YjAp/ymcKiEezj+blC+J3KwMo768qq+yLbgqiMOvz8OgLypLUyqyJoTvcimlQEZ1H2V9eXtsrKFjieNq2Ha9sPLO1+PjRq9veaoJV0PU87bh45S3Le+bSeadLt1fL6w8T0/B25KHlc+2qbUMroTUb6k9+bvI+4PD00XMiNji0v342HIeDxOCDynTCXD00h/wtuNjjzMtNEeZPoGH7OdjJ6Oqv1IBphrbfoZQMa7f5k5RFY18tv2qos0Pdk1VUUhISNOqzMk+3i1VkbxBYyPJ9Sk5+yLD+cqZF7lsBAAAAIC2+bi0Z+uqyCWgBx54QPTq1Ut53KRJk8Q333zTzHH3pC8VyQpJn5ZFixaJyZMni3nz5mmfx8bGalYkAAAAAHyX8ePHi6efflrMmTNHWybauHGjyM3NFdXV1VrEXLkyI/1eZOTcZ555RnM96VDDRS4H/ec//9EMFukhLGdaGmdftmyh05UAAAAAaIUuPGvSHnbv3i0uu+wy0bt3b3H55ZeLc845R5x55pla3JaioiLNVvjLX/4ivv32W02Z7ApuGS4yDXWfPn202C3SkmpEGjFyFgYAAAAAOvhAHJcjR46IuXPnatvJwu3Iufn5+WLr1q2ab0sjGRkZIjs7+2TVDQAAAADdgBtuuEH8+uuv2lKR3OTvUtzjDj4Tn98WXi9stvoWc4jEBVK/nPyacKXqiOcM4WoCriJqpoRhHvU8Hw1XE7x89HxlDhJOemBBq0oTrqzg9ypnKhSuvMiqjSHlnGq1KmlxRaIyFxBXRiSEb3Upnw1X/ejVlzOjxzqXlCB610sPOqxU0iyvilL2FVdR8etx1ZYq54oePHdNhpUqMWZF03wweqodrgLi6jeV2k2SQ4UjzVREXAXD25a3FX/PuJqPw5UqermMmr9LVNmSpbOfq4ia5cXSaa/p/F1hY1VPxcXbU6Vi4u/prT1+JeVsW4BS7cffY553ij9bLosHlmsPd2nscBVRVk28UgXlKXwlAN1jjz2mhUp57bXXxNq1DTm7pH+LdDeRqzePPvqoS9fzGcMFAAAA6FL4wFKR5JZbbtH8WWSW6EZktmgZhE4aM64aLic1ySIAAAAAAE+mKFVFHJmnyJ3EzDBcAAAAAA/QneO4OPPhhx9qsy4cmXjx448/Fq4CwwUAAADw5FJRezY3mDVrljhw4ICWM0iGM5HJDtvClVdeqQly3FEPS0dc6ZD7zjvvaJtcJpLLR1IK/dJLLzVtbQE+LgAAAICPcMUVV2jS5JkzZ4r169eLu+66SyxdulSkpKRo6XxaQ0bFf/HFF8XKlStdvuewYcPE5s0N6VcGDGhw9JaxXOQm9zXirFI+6bmKvImmnBCLnxUV9oacEDVVVA3hqKT2myGEuqg7WJ4Ngz8NltMzyqqsQ/EeqhYwVVLvf3sI7YKApApSri6n+XNMRbT+dfE1pBy2lXrwW4aeyIURFE6P5W1xWl+aI2R/Ca279Sj17jfY6LNEDaKKKk5RPj2f18e+P4yU60JZYKJwquDi+JnUgYzs5VT9YO5F83vU7KRKEFsEvZ4jmKodDFV+yvs1q18FHUv2aPXz8OsnDaIqpLzjEaQcHELb01oe3OpY1hsL/L3gmMJpjpU6O5vALfdXtx17j/h7xuvn78+kI4yqSvqecOJ70hxgR472VNYnLJyqcOwZVAVU1Vtdn6BjtP2qe9P2MgWrzzceoH0XOJSqkioO0L4P7V+mbA/eP4HBNuX3jCuYe9LvLMvxUOU4Diyi5ZpkqnDyP0LrYmTfM9W97MqxmN6X5lpat4Wq8Rwm+p079tQ9Tb8H+wWJ9894tVNyFaU/Nl9U1LQjV1FggMh41LVcRXKGRYYukTkGJQaDQYu1Ip1kn3vuuRbPMRqNmsHy3nvvaYHkIiMjxfTp04WnwFIRAAAA4MU+LmazmWwBAfQfNGcn2bS0NLFs2TIyyyHLUp7cGo888ogoKCjQDJeuAAwXAAAAwIt9XHJycrQZnMZt9uzZLd4uOjpaU/HIALLOyHJryRDPOusszT9F+qN0FeDjAgAAAHgxiYmJZKmopoYus7pLWFiYpgiSRsvx48dFVwGGCwAAAODFAegsFkubfFykM6zMxhwXF0c+l+Vjx441O1460vbv318LFufs7yKx2WyaQ+/+/ftFZ+MzhktYcK0w2BusULuNOoalOzlmSW7u9bMyDD4P3c3hocannU4dXi311LEs20YdVhNMdADm2s0u7RdniVaP52HArzFTK3q3jTnZ9aEOluYRamdSPXKHmJVhz9PPoGHb9Ujw81OGCuch/HlbNwv9PZIWF1tTaP2CDyjTPTTrCx142HV+PR5Wn+/n8OPVx9JxPSqwkpSzmbMsh4e854SzZ+PjVg+9vhsfTJ1p/1sRokynwEPii1R126UwZ13LSLvyenws8vbjfcefj6d7mHYu/d5oxij1bv49w3mucDwpPxm3qtX3iKe6uDiUjhVrPe1rjl5bNEtPMLZKOZb4WN1YE6J8r3MTWvb5aLGvDVQg0J1C/ttsNi3o28SJE8XixYsbrmEwaOXXX3+92fFZWVlE9SN58sknNT+aO++8U3Pq9QQ+Y7gAAAAAvs7cuXPFggULtEi2GzZs0OTQoaGh4v3339f2y33SZ+ahhx7Slpx27qQ5ukpLG/5x5593JjBcAAAAAB/JVfT555+LmJgY8fjjj2sOuVu3bhVTpkzRVEMSmfRQBoXrysBwAQAAAHwoO/T8+fO1rSXOO+885bnXX3+98DSQQwMAAADAa+gyhssDDzygBcKZN29e02eBgYGaw5D0hJYe01988YWIjY31aD0BAAAAb85V5O10iaWiUaNGib/+9a9i27Zt5HNpxEydOlVcfvnloqysTDNivvzyS3H22We7fI/jBWZhtTWEkZ40LJPsK6ymXuTLLEOV10oKoGHtj9ZGKfcvrkgk5URTiVJZw5UmfH8zJU4QVeIsKj+91fqYjVVKFRFXxXBFFVdqcCUEf7avSqlMJz2MqnJSA/KU6oXUgNZzZ7TUtvz5OFwRllsXoFQ7JPiXKJU4GVX9XVId8efLqqEKtNTAvHbt1xuLzs/D24KrUHLs9J+EDRUNOUYamdFjnfLZ+DjmY0tvbPCxxOFKltSACqUKiY9lSz0NqZ9hpX2ZGkzb+rtCqq4YG0VloEOCqAqIty9XzvCxz+FKGQ7/njL70faYFLZTORb58y2vimpVxcPbKs9OvwcyatT/UPLrcUUa72veV7z8UXm88j3NZuI7vb631J84388QLMaJ7uvj0h3w+IyL9GaWaa1lgJuSkhODR+ZekNH67rnnHvHTTz9pCZrk2pqM4jd69GiP1hkAAAAAPmq4SAehJUuWiB9//JF8LvMpyHwLzjkVsrOzxaFDh5Q5FeQ5PG8DAAAA0NUwnITNF/HoUtGVV14pRo4cKdLT05vtkzItqSGXS0RtzakgkTka5syZ0yH1BQAAAE4aWCryrhmXpKQk8corr4hrrrnmpOVVkDzzzDPaMlPjJnM4AAAAAN01O7Sv4THDRS4FyfwI0ndFhiGW2/jx48Udd9yh/S5nVqSqKCIiok05FRqpra1tytvQ1vwNAAAAAPAOPLZUJH1aeA4EGXJY5kZ47rnntBwI0giRORSkkkgyePBg0bdvX7F27VqX72e0mISxtiEa4Ip9g8i+oYnUu/6zXWnK/SurB5Ly0Xyq8hkzgKojKu1UuVJlpzlR+oRRj/jMwAR6v3z1/QYlUg//YBN1qe8XdsL4C/Ojs1vzD09Qnru/hKpUkntQlQonx0INzbPiqfLi/47RBCvF1VQ5MW/wZ6T8QckYWp+KaFIONdWS8qrDyaTs729X1p/fn5MUps5LddRK1RH/EWeQ8t+Sl5LypwXUsTw2yKJUrmQXULXGiISjpHy8OlRZv/wwqqz5T+mJ+v2130qyb1EVHXc7ymh5WEQuKS+vGKyse0yQlZQvitpCynwsZrL7Z9RRlc/mot6kPDJanSelwt6gImxkfR5V9UzoTXOUHbT2pPUppUvSxVV0rHxhGUHKieZk5fNnl9K+PDduLylb62h9V9hpMqXDVvre9wyqUL4LS3KHKccy/15yftcjg6kKKCqI5gZaYjpNqOB1CTXVKPuSf+9Mj6djZZOln1IJ2i/suLIvQ1h9+HubEnniOzTIGCTG0dt1HFgq8i7DxWq1Nst1UFFRoaXObvz83Xff1fIqFBcXi/LycvHaa6+JNWvWiPXr13uo1gAAAMBJxEeXe7w+jktr3H333VrOhIULF2rLRkuXLhWzZs3ydLUAAAAA4CG6lOHCcyRIp93bbrtN2wAAAIDuhKdyFXk7XcpwAQAAAHwG+Lh4ZwA6AAAAAIC2IgPvdevJJhk5Vzr2jnjpdWGtbfAsDxxKvevjzRalyod7xHM1RLN7spwhPF8MV9ZMidlBymV1VL0Q4VepvD7HUkfzcmRVncjrMSv6Z3psvb8yh4gePOeHXq4cXjf+LHr5YiaE7lbmf+F5m/TywzTPmULHxqIyqjA7I3SfMn8Phx+v117bypOUyo8bEn4h5cxqGqdodAi9H8c5t5HeOOLwtuN5mjg8bxPP86SqW8t5ooJdyvnF29bV94iPJa6i4kqXgSEFLvUFzzU0JJiqtjj83eHtu8yqzrGm9/zO7cnzSMUHlCmvxfuKj8sZEVuUOc74s/Hr8ZxlvC+mhWUr81TxvFlZtXSsOeNvDBFXDViuxQHrqHAajX+Xzr53vqiopoonVwgNChCrXrq1Q+vaFcFSEQAAAOAJsFTkFlgqAgAAAIDXgBkXAAAAwANAVeQeMFwAAAAAT4ClIreA4QIAAAB4AhgubuEzhkttnE3U2hryYdQeD1WqiiqYkoOTHka9+TnNVUOVShUR9+7nOV94Hg4OVzlNj9jUqod+rt2sVHKsLKHe+sPDaW4cDlcNcczGKqXSgyuoOPz4D2rHKO/PVUQcrmzhKiKuMuJ9w5UtekoQrjriKqO8Wprb6eZeVPVVzuqba6PKmUlhO5UqqElmuj81MK9V5QgfR/k1VJlhMQe5pH7jbcnbbkLwIXZ8D2Xbuaqm42NDTyXk3DYt7efvxrk9diuVMPzd4oo4/p5ylRZv32ZjnR0/JCiHlL8uprmU4gLLlddz/mswIXyXsu/4e81VRPzazxWOJ+VLIjeTclZdvHKcc3hfLbamKPtifeUAZVs5j7VAI31W0PXwGcMFAAAA6ErAx8U9YLgAAAAAngBLRW4BOTQAAAAAvAbMuAAAAAAewOBwaFt7zvdFfMdwsRkbNiFEwHE/sqsqiYa9zzhEw1FzDsdRx7HdexJIuXd/Gp76jd3nKp2BDxfT68WEW0l5fwl1UB0dz5wMjwwi5R09aH1CTLVtdrYNdTq2JefRg9aepLz90DmkHBjc4ADdyNl99pPy+rw+yraostO+qLLRclQwdQDNELSvegZVkHJyaBEpL6k4Tag4aqUOpUcOxJBydBJ15j09hjr5HbbSviyuog6WK/0HknJheRgpZ0b1IuVgk63VvpQsyhuhbL/9FdGkvDbrhBPitNO3Kh2Nd5TRcbTSTp1Tp0ZvJ+UPjo5V1mVk9BGlE3txtdpRe2rCDuX5/H4TYmkY+CVF6r7/zk6d4mOC6Hu4o5D2DSc2iI7lzUW9SXmRifYVh6caGR+Zpaw/f1fLQkKUIoMMK31X9gfRsfEf6xlNvyeFlSqfjX/ncPh7zd9L7iz7xSHaNjcmryblTwtGK1Nh8L7n7w0fW3nRES6lcekwsFTkFlgqAgAAAIDX4DszLgAAAEAXAqoi94DhAgAAAHgCLBW5BZaKAAAAAOA1YMYFAAAA8ABYKnIPw2+TVd0Ws9ksysvLxfAvXhBWe4MXfnpfGmqcc1XselION9JQ42ZW5mHW9UKTjw7Zp/Sw56HTeahwjlmOfieybTRUuwp+bx6qm4dRTw9WpzvIqo1XhnXnob95aHG9EPw89HhqAA39zeHn8+vzFAA87DwPE8/hKRR4iP7UgELl8c3r28Ol59N7Xh46fVrYCaVNRk2ssm0TTSXKuvH9CSaLMv0CPz7Fn4agtzjk19EJFpWfrnxvOPz+vK35e8vHKg9j72p78PP14N8remHp+fE8pYBz37bUnpZ6/za/q7l1VLVjNlKVTlZtjHKc83vx8/nY4OOcj2P+7Hpjh9+fw9975/fWZAgVFyavEeHh4cJioWPqZP9dOu+vr4uKaqoOc4XQoADx0z9v69C6dkUw4wIAAAB4AMy4uAd8XAAAAADgNWDGBQAAAPAEUBW5BQwXAAAAwEMwF0XQBrBUBAAAAACvwWdmXOyWAGG3tZyLKDmO5rN5L/ccZc4SngOE58PZW0nVGpy1xcmk3C/sOCkvL00h5ZVBg5Wqpw0VVI1grQsk5VnRP7dZqcGVCq6qdDKs/ZVKi9RgtUomo6q/UqF1tJbmbeJkVtH8OmeE7lMqKbhqapOlH70gfdxm9+cqLH5/rupJDaTP/3ERze9zUdQWpWJtknknKT9z8AJSXpjyBSl/xO7vrCTKrE5Uqlg4vC+5qoYrqvSO52OtrE6dq4grSRZbU5T79VROvO85XOnClTH8eS8OpWrA/1aon4c/P1cTcnj7JfhTlRNXAukp8vhYznDqL64S0lMBcQUXrytva/4eJPhRZc0ya6KybXjbc9WR3v35s0+P2NT0u9FgF52GTJLYnkSJDt+crvEZwwUAAADoSkBV5B5YKgIAAACA14AZFwAAAMATQFXkFjBcAAAAAA9gqG/Y2nO+L4KlIgAAAAB4DT4z4xKYbxL22gbz1L8XVRvkWahHvLWcet/fP2opKX9XOIyU91dEK+991MqkKYyxUftJebO9NykPDz9KyvMPT1Ber2dQBSnPOXqhaCt5tRGkXGGnCqWjgdQbP79GnReJK7Q4XLG1Po+qF6oq6f3je5aRclQQVRvkWGj9RZJQ1vewleUm6nlIqUbgirCYoFil4kyPUFONsr244myZZaiyrxdXJCrVE86qqTTzQaUCyqKj6NpWzhqXwdV2/D3h45q3dcbxvjptb1Wqkri6j/f1kMhjpHzQ2pOUq+z+yrHByaym7bW8gKqeJsRmK5+Xj82ykBClgo2PlRsSflGqiPj9uIrMWWX2dfEIsm9gSIFSPcfhakD+vcK/QznDInKVY62SvWfP9/tS+Z7wsXdvAv1OX2Y9cXyAMVhQLV8HgqUit/AZwwUAAADoSkBV5B4wXAAAAABPgDgubgEfFwAAAAB4DZhxAQAAADwAlorcw/Cbe1C3xWw2i/LycjHsnVeF1fZbWOlwGro7MJiW63eHkXJtL7rfWE7tvfpgqkkzM+df61HqdJc0iDq6HTlKnQKj42jo8kQzdUjNLqBOhymxBcr9zpzdhzoC/5hNHQhP60sd9n7dTEPwh/andbEco47Nw4dQB8b9JVFKx2c/E207e5Xaljb40+MvHrpd6WDJ7z86/rDSGdhmo/cPC6bOs1HB1Bl4954El54/0FRHytYq6nzs768ON87rzx1ODxf3UF7Pcjz0RF0HHiH7Qky1SqdyPk6DwmnbjEigzrZ7SmJI+Xgxfa96RlmVbbs/P1qZmkOP4qoQ5XtUXE335x2nDqTBIfT5IoOpw+nI6CPKscffwz5RJUrn3yobLRcdpe0/9tQ9yvYtyg9X9g+/P2/foYknwvDvzIlXtj13Cg9lY4ePS06wyaYce9z5lr9Hw2KOKduCc9egH0n54VXTW22rUFOA2DztQREeHi4sFvpdfrL/Lv3umldFZRV9dlcICQ4Q3398R4fWtSuCpSIAAAAAeA1YKgIAAAA8AJaK3AOGCwAAAOAJoCpyCywVAQAAAMBrwIwLAAAA4AGwVOQePmO4BBz3E4G1ftrv1SYqpEphSpricKp2OJpPPeQDkiqUaorj1SeUG5LpE1aS8hu7zyXlmWf8TMpLctXhsCcnZyrVDDGs/s4e/DzEfFIcVRpc3msjvdlIoQwrvqHfAFK21gUq1QLDB6jDvPPzV+fRMO+DehSScpgffZ4pMTtIeaVpMCnzMPe8Pfj1hgTT0ONmYxWtf1KwMiw+D13Ow7rz+xdUU5XWuT12CxXjI7NIObOnOhT7jh4JrfY1D+POQ/ZnMCUIV8XwuvJyVny8sq15iP/xA6iK5protaScY6fv5YrSVKVyhacI4OkUDrL0EXys8zD4HH79san7lSkILoraQsobKui7lJRMQ/ynBp5Q/UjWh9Pjh6TkKK/Hx/KKsNRW01VMTaHvUWZpL1KODaIKltRgWjcOTxnQLP0AqxvfXxYVokwBMDkpU/me8bHNFXXO3xv+RnmvB0WngJD/boGlIgAAAAB4DT4z4wIAAAB0JbBU5B4wXAAAAABPUO9o2Npzvg/i0aWiRx99VDgcDrJlZp5YqwwMDBSvv/66KCoq0qICfvHFFyI2tvWosAAAAIDX4DgJmw/icR+XHTt2iF69ejVtZ599dtO+efPmiYsuukhcfvnlYty4cSIhIUF8+eWXHq0vAAAAAHx4qchut4v8/Pxmn8vcCzfeeKO4+uqrxU8//aR9dv3114usrCwxevRosX79epfu428Rwv83EcOI89U5P7hyhecwuXTQVlLeXxGtVFssyhuhzLORV0uvH8XUDXpw5c6wOOqhnxRwQp1g9qtWqlhSA6g6YGwUVUbk2nq0eu2WqLAHKtUCeudPSNlFypnViaQ8OmQfKS+zDCXl4eFUxZTgT1VUK0uo6qjCFKhUO3D480T4qftueuwmUv6w+ExlfTlldSFKFRNvT368s5KIK6TOCN2nVKX0CStRqmISTaWkvMw6VKki4vD8Nxzet1yB5qyKaUnRxduGvwvpYQeUz8+VMXzsfVU6UjkWuILMUk8VaRxeP359ruRZXn6Kcv+00Bzl2M2qOqH6ig+geZ3CetYo68bhz8q/4/j1OXxc8/vx92RIEH225XWnKPs+Pyi81e8Fk8H93EHuJAuUfi7tOd8X8fiMy6BBg0ROTo7Yt2+f+Oijj0Tv3r21z9PS0kRAQIBYtmxZ07HZ2dni0KFDYuzYsR6sMQAAAHASI+e2Z/NBPDrjImdNrrvuOs0giY+P13xefvnlFzFs2DBt2aimpkaUlVHLXM7OyH2tIY0d6RvjnIUTAAAAAN0Dj864fPfdd5rD7a+//iq+//57ccEFF4jIyEhxxRVXuH3N2bNna+nCGzc5mwMAAAB0VTl0ezZ3mDVrljhw4ICoqqoS69atE+np6a0ee9NNN4mVK1eK4uJibfvhhx+Ux/vEUpEzcnZl9+7dYuDAgeLYsWPazElEBF0bjYuL0/a1xjPPPKP5xzRuiYnUJwIAAADwVVXRFVdcIebOnSsee+wxMXLkSLFt2zaxdOlSERNDfT0bGT9+vPjkk0/Eeeedp7lpHDlyRJtokGIZT9GlDJfQ0FAxYMAAkZeXJzZt2iRqa2vFxIkTm/YPHjxY9O3bV6xdS0N/OyPPkdJp5w0AAAAAQtxzzz3inXfeEf/+97+18CMzZ84UlZWV4oYbbmixef70pz+JN998UzNwpFuHnIExGo3kb7NP+bi88MIL4uuvv9YcbqX1Ji3Auro6zbqTyzzvvvuuZhnK6SlZfu2118SaNWtcVhRJaqMcoqa2wTxdt68/2dcziuUmskaS8py0r0l5SdFpynvxHCnpPQ8pVUg8H09UMFUjTI/folQp8etznNUCXGnAvfO5yoWrjqZGb1d6//N8LFzpYWWqHQ6/Hlf98PryfDVcGcOVFlxdcG/CUlJ+4vBFyvrowZUkywtSlPefEE5VUxyuopoUtlOp3OFjY0JsNilnWPu3qvjiKiGuqJpkpvf+uGisS3mXeN9xVQuH55VyHsctqYAyRH+XlC+JphKXnodfr7xeXf/vCocpcx9xuEqK59fh7cnh/cnH7uKKamXuI5UabUdZglI5OSTymLIuvC05zuOyLaojnquIv1d6Cjae48tZEWc02EVnYXA4tK0957fkyyn9Q+U/8Rx/f39N+CJXJhqR8dOkCKatopeQkBDtOvLvsk8aLklJSZqR0rNnT1FYWChWrVolxowZowWck9x9992ivr5eLFy4UFs2ktNZcm0OAAAA8Hrqf9vac74QzXw558yZo00EcKKjo4XJZGoWgkSWU1Np0s3WeO6550Rubi5R/PqU4fLHP/5RuV9ajbfddpu2AQAAAKA50pfT2S1C/u3sCB544AFx1VVXaX4vHXUPrwhABwAAAPgiJ2upyNJGf065miGDvkqRiyuiF8m9994rHnzwQTFp0iRNCexJupRzLgAAAOAzdLKqyGazacIXZ8dag8GglVWil/vuu0/84x//EFOmTNHO9zSYcQEAAAA8QXuj3zpcP1cKXhYsWCA2btwoNmzYIO666y5N0fv+++9r++U+6TPz0EMPaeX7779fPP7441r6nYMHDzbN1litVlFRoU7T0VH4jOFisBmE0daQ2SEpjqoJqmzUQz4lskDp8c6JDaJTdMmhDc7FrakF+PGhMbUuqSm4ymiTpR8pxwWWt1mNwFVGgoqAXM7Nw+8tmIiItwVXaujlk2m2n+Xb4flluDqhWQ4Udv5dST8o8+NwZU1WTbxSjcH7it+ftx/PpcT3v1VwnnKscBURP39b9Qk1xrk9divzUE0Ipfs/KBmjVCHx87myRC8vlV7fcwWWXq4f/uz8erzvuPJF7348NxN/l3g53FitHFsHrT2VKiSu8lpRqnam5GM1wUS/dyz19HtPpQ50znHV0jieHk7zt2VU91F+b/DvLK7y0VOA8bGilwONK6i4GjHHfkJJajKEiu7M559/rsVskcaIjEK/detWbSaloKDh716fPn00UUwjt9xyiyaOkSKZtjgAdwY+Y7gAAAAAXYn2RL+VuHvu/Pnzta0lZKA5Z/r3V//j7glguAAAAAA+slTUHYBzLgAAAAC8Bsy4AAAAAB7AUN+wted8X8RnDBd/ixD+NS0743K2FtIw6zV2P1KON1uUzrY8pD8Pdc6JYCH+eajwYRG5Ssc47hDL7++cwmBHYS+yb7WJphu4MXl1q86cLTkQcnIsNCnm5KRMpcPiPw+eS8pTE3Yonex4GHQOd/7Nrwkn5YEhBcqQ+nph6HlYeH497hCq54TI78cdQLlDKXfG5QwJylE+X6VTCgY+zqbE0LZ/o2ic0tH5vdxzlA6chdVhyr6b0WMdKd++90qlozFPn8BTXfAUAPx+fGzwsPB8bHLn2xwWCT6rVu2YnVcboXS8zjjel5R7BlUonZ1dHQscVxxmr4mm0ti3j41Tpv5YVH660rmXvyf8O4sLIPj3DB9bqQF5ytQX/HtjfeUA5Xvq/D0U4hcoLqRfix0HlorcAktFAAAAAPAafGbGBQAAAOhSuBFEjuCbvrkwXAAAAABvDvnva2CpCAAAAABeA5aKAAAAAE8A51y38BnDxVTlEKbqhmm148VU7SDKqcpozAga6nxPSQwpF1dR9cBme29STgqjaoRt5UmtKjskMUFWZZkrY1Ydpi7vlw6i4baPV4e2msIgLq5ceW2uWAo11SoVVDydwFnx+0l5RxlVduQH0ftFBVUqvf3/79goUi6upm0/MvqIMsw8h6sdKlhfOCuwJHnHqTIkve8hpdIl2GRT9iVvX14fHnaePw9XZ6wtTlYq0LgSxbk+/F5cFcPvnScilM/GVTy8LlzttsjvdJfSFXDVDVeOLCk6Tfme6ZEUQ6/3Uu5kpTqQt30Ie1f48S/up9d7fOBiZQoCPlY4/z3I1IcxNLvvJlM/ZYoGruRxHg88HQFXEX1wlKrr+oRRxdSP2fS9CB1Kxxons7SXsq/52OJ9zdOs6KXW4GPd+Xso2K8TNcbyT1J7bucQPonPGC4AAABAVwI+Lu4BHxcAAAAAeA2YcQEAAAA8JoduT64i4ZPAcAEAAAA8AZxz3QJLRQAAAADwGgzdfbLJbDaL8vJyMfqbp0SFvcGz3VpO88H45VH1RF0odfP2i6Ie8fZyqlYwVlH7z+FPm9QRXKeso6GK5kIaNITmm8n5nuYYqRxarVRF8frW55/ISRKQRL31Y8KtSlXMnhyqeuEMSqQql90HqTrAFEwTvESGU+/+0nLq3Z8cR9UBu/dQNUF0ElVsWTdSpUp1b6rsEDbaN5NG7FQqtDh9okpcej4+Nnh9uaItLLyKlKsqA5UqpnVbBtMKhtP+8j9Czw8cSu9vs52YZA0LpuMk0UxzEW3LpLl0zL2ooqwqmyqw7BF1ymfnfR3fk96vcC1V1Yih9H68vpyio7Q+HFN4rXKscQ6uo2rBy6euUuYayrNQhR3HtpXmHooZS/Pt5G2lYyv+9GNKhVudnX3vsLE+uB89v8pOvyeO7qHvdtKgE+9yzq44si/xlHxSLiyn49huo99h4gj9jrVH25TvDR8L/Fk5Jn/1d2rtUaqsjBpUrByLxgMn6hsWECC23HubCA8PFxYLHYMn++/S9LOfFpUV6nGtIiQ0UCxa9VCH1rUrgqUiAAAAwANAVeQeWCoCAAAAgNeAGRcAAADAE8A51y1guAAAAACeAIaLW2CpCAAAAABeg8+oik598zVhrW1QFTh6UnVBzyiqrDk9Jsel/DCcfmHHSTk+oEx5Ps/5UlhNPfbHRu13Kb8NxznnzPjILGUOEJ7bxlJ3QpHUEvz4vFq1GoDnv+F1nxC+i5Tfyz2HlO9K+sGl/C7WOnq/SyI3kzLPycKfh+fDMRupCmh5+SnK+mdWJ5LykCA6tsKN9H4fF9EcMDNjfxIqFpWlkfIZofuU91f1FR+nk8KoAiujiua24fC2433Bn53XbXQIrfv6ygHK+uTY1SoiS32wS30X5qd+jyaZdyrHXoJ/iUt9z/fzd42PPU568AF6fn2QS+/GkODcVvfzvsix91DWlV+bj0MOb/v0MPosqQF5ynHO687rw/si0UQVbsusQ1vtG5MhVFyYvKZTVEV/GPN4u1VFX657BKoiAAAAAHQC9e1MslgvfBL4uAAAAAAeAHJo94CPCwAAAAC8Bsy4AAAAAJ4AqiK3gOECAAAAeIJ6R8PWnvN9EJ8xXPzLjCKgtmFlLGUk9e4fFkE91FfmD1QqX0JMLB8Og6sztpUnKc+PCywn5TTzQVIuqwtRqpy4OmRzEc2x4sxFUVuUdefXOmjtScqX99qoVCXxZ+dsq6ZtUWGnuX2Wi1OUiiquuuHwtuRKEa6O4Plmbu2znJQ3VAxQqhn483IlC+97rijjz8fH2ku5k0l5avR2pfKE319PmaJSq/Fz9RRbvK35+V8Xj1COY66C4fWJ8KN5rr4rHEbKU2J2kPImSz/l2H8gZgUpP1c4Xtm3XOWkpxLi9f20YDQpDw8/qmyv1MA85f25yot/T/D7640FZ2UOv5eeupCriHhf83E9K/pnUs6qjSHlmTv/RMqTkzKV98+qileWeV/zvnN+b/yN6mcFnsdnDBcAAACgS4GlIreA4QIAAAB4BEeD8dKe830QqIoAAAAA4DVgxgUAAADwBFgqcgufDPk/8DTqFNcnrMQl59fU4DyXQp8nmuj1U/ypA+nyqr5KJ0i9sPM8bDy/fm5dQKth0lMDCkk5o7qPsu4JJovSqS7X1sOlFALTwrKVbcGflcOdUTkTgg+RcrYtXHm8mbUlD6POnXu5c7JeyH0eSl3vfry9ef+kBx1m5/uTcoo/Da25sSak1Wsn+PmRcm5dnXL/s0XpSsdlPnbK2bOlB9L3LKMmVhmmPcGvtl19ydG7Hq+vXgoB/h7y9uV9w/ta7368r/m7x9vT+b1vCbPR1mr9eN34dwrvK35vjsVhUNadtx1/z6aF5ijHZq7drOx7/r3H6+tcP6MhTAxO2t0pIf8vPe3votLajpD/YYFi4fanfC7kP5aKAAAAAOA1YKkIAAAA8ASO+oatPef7IDBcAAAAAE8AHxe3gOECAAAAeAJEznUL+LgAAAAAwGvwmRmXgONGEVjTYKflWagHenrPQ8qw7FV2qgYoqKbncypZGHt+PlcxFVaHkXK/sOPK0Oc8fDYP8T8y+kir9Y0Nop7nmSysud69OPE65/OQ/smhRaR8ZeafSbnK5q8M9c1D9PcMqlDW72h4lFIhxsPU8zD2POVBTJBVqUDjKQL49ZbVDVXWlyvIeIoD3p6ZoQk6KQDyWr2ennpOL4R/fk248lkz/WjdOFw1s6I0VZn6YkLobqUKhyu4eH359fXeo8cHLibl93LPUaYYyGQh95v1BVPU8RD9fP/0iE2kvKj8dOXxvD25qksvZYHz+RlWmk7gksjNShXQ/OKxSjUhT33BuSp2vfLZlldFKdWL7+4/i5QH9ShUpsrg9XVWxPkbQ8Rg0UlgqcgtfMZwAQAAALoUMhhJeyLnOoRPgqUiAAAAAHgNmHEBAAAAPAGWirxzxiUhIUF8+OGHoqioSFRWVort27eLtLQ0csxjjz0mcnNztf0//PCDGDhwoMfqCwAAAJwU6uvbv/kgHjVcIiMjxerVq4XNZhO///3vxSmnnCLuvfdeUVJywqns/vvvF3fccYeYOXOmGD16tKioqBBLly4VgYHUERAAAAAA3R+P5ip65plnxFlnnSXOPffcVo+RMy0vvfSStklkTob8/Hxx3XXXic8++6zNOSGGvfOqsNoacpMExlWSYy4dtFWcTHi+Gq404TldeM4Tro6I8Kt0KRcSVw84e+hPMu8k+7Jq4lt9jrbciys7eH6ZRWVpymfn6oX0sAOt1l3bH8z2s/vzZ+fKjtSAPGUOE66W4M+nt58//zIrVRFNCmPtXxuvzH3E68+VKHw/R5Una7E1RdnXfFwuLz9FqTTh+WV433F4X/K2mhGxRZnHiuevcc7D1NJY4HmiOHp5uDi8r/lY0svbpZeHi8O/F6aHb1XmseLtn+BfosxT9kHJmNYVTew95t9xruZJ4vD3gI9bPrb4e5xRRb9HUgPzXMpd5NyXMldRWp+dnZOraOA9otKqzqmlIiQsSCzcOxe5ijqTiy++WGzcuFF8/vnnmjGyefNmcdNNNzXt79+/v4iPjxfLli1r+kx29vr168XYsVTOBgAAAHilj0t7Nh/Eo0tFycnJ4pZbbhF79uwRkydPFm+++aZ49dVXxYwZM7T9vXr10n5Ko8YZWW7cxwkICNCsWecNAAAAAN0Dj6qKjEajNuPy97//XStv3bpVDBs2TPNn+eCDD9y65uzZs8WcOXNOck0BAACAkwxC/nvfjEteXp7YtWsX+SwzM1P06dOwVnvs2DHtZ1xcHDlGlhv3teQ3I9cmG7fERLouDAAAAHQFHI76dm++iEcNF6koSkmhDoKDBw8Whw41hOA/cOCAZtxMnDixab9c+pHqorVr17Z4zdraWs2hynkDAAAAuhzSR6W+HZvDN31cPLpUNG/ePLFmzRpteUc66J5xxhni5ptv1rZGXn75ZfHwww9rfjDSkHniiSc0pdFXX33l0r38S4wioLbBThswjObLKbdT7/sKO5VaxwWeUGJIEgOpx3uZnaoZQo00B0p8AFUf7Kyks0CXRm4k5dRw6u2/q5bOOOUwtUKz+zH1QLxT+p+dNeoZqNTAXGX+kzpNiHaCHVU0v0t9MLWFBwdR7/71FpoH6tqeq0k5xZ/+B7G+JpSUE/xq6X57lPLZufpgZ02C8vnOD80i5dLaEKU6YVQgVXy9WjyclEeH7lXef0zwIaVSJreujpR/qKD5dg7VRCvvx+trcZzov12VtC4TImheqHVWGi9pUHC+cizwti5lbRupo6IJY6obrkzh43xZFX32cqaiSWFjr7Se9yWtzxdlI0n5jqhtpGypt5PyLhvN7VTP/g/kuZV43/ViqqT1FbS9L4vYrFTuOPdlS+1vNtpI+Yg9XPm94vyu8nNvjWr5H8WmutdQn8NTAvKV9+bvHW8LZ/VbS2Xe9lyhxr8nvrQOIeUxwVQV5fy8RgN9dtD18KjhIv1bpk+fri3vPPLII5phctddd4n//Oc/Tcc8//zzIjQ0VLz99tta3JdVq1aJKVOmiJoadfI/AAAAoEuDyLneGfJ/yZIl2qbi0Ucf1TYAAACg29De6Lf18HEBAAAAAOjSeHzGBQAAAPBJsFTkFj5juNQHClH3my/bvkLq1DfQTJ1hB4fmK0Nn59XScNHWOurMu7EyWRlqvLf/cWWocw4P+b+6hDrxJYcWKcPAO4cat7Jn4dfmdef738wbT8pPJ3+pDKWdxxyJs8uoQ+AiEw0lnl9DnfguiqJh3zNqYml9K/or+2Ioczb2M1AvfN4elnonT2YpyWdOgJFG2h7zS2hY+WHBR0i5Qg48xf2XVwwm5aO1Ucq+HBpInXfL/Wn93z1G02dMjd7eqkPqpIidSofJMWF7lfv9WLYQvbDwx9jY4M6k3DE6106DR14SaiXljy096fkhB0k520bHEoena5hs/pWUF1ckKsPQ/2Q5Rfm8PAQ/77uvSqkz8Kzon5X15WOfpxzgYe/5WOLpPoyivtX2447RFp0Q/elBh5V138OcdzmnsO9c/qw8fQIP6c+dcTmR7HuMH+88VvwMoYK+lR2Ho75e29pzvi/i8ezQAAAAAABtxWdmXAAAAIAuBZaK3AKGCwAAAOAJEPLfLbBUBAAAAACvATMuAAAAgMeWitrhYOtAyP9ujcliEP41DbKi6HCqTkgPo+GiM6toKHQO987n6oTMaqpGWF85QKkUmR6+ValG4KomrhThcPVDgsnSaphzPWWCsyJJcmuf5bRu7Nn59TJFovL81ACq6MqqjVHu523DlRzhPMQ9qx+HK764WqKsjoaJ5wwJylEqb7jagquIpoVlK5UwfOxk1cQrQ53f3OvnVvu+pfZTpRvQU9Xwaw8JznWp77iyY3lVX+X9NtXUKlUz2ex4nu6A9y1XNaUFUiVNjr1KeT3+HvOxLwQt8zD6T8atIuXlVTHKscxD/nPlj95Y4t9TfKw6H8/7NsHPT9k2vG+bpR9g3yO8b/l73+w9Zufz9yIlgqoPObw+vG2cn9fIlH8diaPeoW3tOd8XwVIRAAAA4AnkbEt7NzeYNWuWlmKnqqpKrFu3TqSnpyuPv+yyy0RmZqZ2/Pbt28Xvf/974UlguAAAAAA+whVXXCHmzp0rHnvsMTFy5Eixbds2sXTpUhETQ2e9Ghk7dqz45JNPxLvvvitGjBihJTiW29Ch6vhjHQkMFwAAAMADNC4VtWdzlXvuuUe888474t///rc2izJz5kxRWVkpbrjhhhaPv/POO8V3330nXnzxRZGVlaUlRN68ebO47bbbhKeA4QIAAAD4wFKRv7+/SEtLE8uWLTtRBYdDK8uZlZaQnzsfL5EzNK0d3xn4jKooNOBEKPcQPxqG3d9IHTADjdRpjSNDQjtjMlCntwCd8/n9jIYw5X5/B72+v1Ftb/oZqBOjs7OZidXdaLCr783uZTLQsp+BOu0ZDSZlWzS/f5VL+3n99OrD4efztuL7ef31+t7fGORS3xrYfn59fn9/1vX8+n4GOra5oyG/P62Muq6qcdXS8a4+u/791GOLtx0/Xq9+wkCdXU2GYJfelWbXYxgN1DlXsLHKxz4fywYD/SNlZPU1sPZydaw6t3czB1Wduro67nnf8rrxZ9d7L/lY4vC2Ur0nRvZsHUlIePBJOd9spukxampqRG1t8zQI0dHRwmQyifx8mmJBllNTU1u8R69evVo8Xn7uKbq94dLYoSvvv7nT7nlhO8/vyDwZetem2WbaT9pJrl9n5RDpKPTqz/Vs4zr5/s5cdZKvPfgk3y+tg4+/sJPfFVe/NxLaub8z63qy28pVEtz822Gx8CxNJwdpVOTl5YlPjvyz3deyWCwiJ4cqAufMmaP5sHRXur3hkpubKxITG2SdsnPl7x01GLsr8gVG26H9MPa8C7y37Ws7+bejo5AzIv379xcBAQEddv2WKCoqEna7XcTF0WS3snzs2LEWz5Gfu3J8Z9DtDReJHICNMy/SaIHh4h5ou/aB9kPbeQKMO/farKORxkVrBkZHYbPZxKZNm8TEiRPF4sWLtc8MBoNWfv3111s8Z+3atdr+V155pemz888/X/vckzh8YTObzQ6J/OnpunjbhrZD+2Hsef49xHvr+TbtDtsVV1zhqKqqcsyYMcORmprqeOuttxzFxcWO2NhYbf+CBQscTz/9dNPxY8eOddTW1jruueceR0pKiuPRRx911NTUOIYOHeqxZ/CJGRcAAAAACPH5559rMVsef/xxzcF269atYsqUKaKgoCEyc58+fUR9/QlHcDmzcvXVV4snn3xSPP3002LPnj3ikksuETt30gjynY3DF7aAgADNUpQ/PV0Xb9vQdmg/jD3Pv4d4bz3fpthEl2gDw2+/AAAAAAB0eRCADgAAAABeAwwXAAAAAHgNMFwAAAAA4DXAcAEAAACA1+AThsusWbPEgQMHRFVVlVi3bp1IT0/3dJW6HA8++KDYsGGDKC8v1/JQLFq0SAweTIO0BwYGakGKZPRFGaDpiy++ELGxsR6rc1fmgQce0JKXzZs3r+kztF/rJCQkiA8//FAbWzJT7fbt27VkcM7IEOYymKTc/8MPP4iBAwd2YA96D0ajUZO27t+/X2ubvXv3iocffrjZcWg/0J1wdPdgO9XV1Y7rrrvOMWTIEMc///lPLdhOTEyMx+vWlbZvv/3Wce211zpOOeUUx2mnneb43//+5zh48KAjJCSk6Zg33njDcejQIcd5553nGDlypGPNmjWOVatWebzuXW0bNWqUY//+/Y6tW7c65s2bh/bTaa/IyEjHgQMHHO+9954jPT3d0a9fP8f555/vSE5Objrm/vvvd5SUlDguvvhix6mnnur46quvHPv27XMEBgZ6vL89vc2ePdtRWFjouOCCCxx9+/Z1XHrppY7y8nLH7bffjvbrAv2DTXREG3Tvhl23bp3jtddeayobDAbH0aNHHQ888IDH69aVt+joaC3S8DnnnKOVw8PDtWiJ8kux8RgZRVEyevRoj9e3q2yhoaGO7Oxsx8SJEx0//fRTk+GC9mu9zZ555hnHypUrle2am5vruPfee5vKsj1l9M8rr7zS433u6e3rr792/Otf/yKfffHFF44PP/wQ7dcF+gebOOlt0K2Xivz9/bXp5mXLljV9JqfvZXns2LEerVtXJyIiQvtZXFys/ZTtKBOCObdldna2OHToENrSifnz54slS5aIH3/8kbQn2q91Lr74YrFx40Ytoqdcpty8ebO46aabmvbLZHTx8fFk7MklzfXr12PsCSHWrFmj5ZIZNGiQ1jannXaaOPvss8W3336L9gPdkm4d8j86OlqYTCbty9AZWU5NTfVYvbo6MunWyy+/LFatWtUU1lmGhpYJwcrKypq1pdwHhLjyyivFyJEjW/ShQvu1TnJysrjlllvE3LlztZDisv1effVVUVtbKz744IOm8dXSe4yxJ8Szzz4rwsPDRVZWlqirqxN+fn7i73//u/jPf/7TNPbQfqA70a0NF+D+rMGwYcO0/9pA20hKStKyp8qsqZ2d8bU7OJfKGRf5x1Yic6fI8Tdz5kzNcAFqrrjiCnHNNddo+WTkPxqnn3669o+HdGRG+4HuSLdeKpIKBbvdLuLi4sjnsnzs2DGP1asr89prr4kLL7xQnHfeeSInJ6fpc9leUhXTuITUCNryxFKQbAu5zCFTx8tt/Pjx4o477tB+l7MDaL+WycvLE7t27SKfZWZmasneGsde41jD2GvOCy+8oM26fPbZZ2LHjh3io48+0tRss2fPRvuBbkm3NlzkH4xNmzZp67/OyyCyLDNeguZGy/Tp08WECRPEwYMHyT7ZjnLq3rktpVy6b9++aEshNJ8WOUsg/9tt3DIyMsTHH3+s/S5nFNB+LbN69WqRkpJCPpNjS/pPSWQoA2ncOI89s9ksRo8ejbEnhAgJCSHZfCVyyUjOZKH9QHel28uhpfpgxowZjtTUVMdbb72lyaFjY2M9XreutM2fP1+Tm5577rmOuLi4pi0oKIjIoaVEevz48ZocevXq1drm6bp31c1ZVYT2U8vHa2trNVnvgAEDHH/84x8dVqvVcfXVVxM5tHxvL7roIsewYcMcixYtghz6t7Z5//33HUeOHGmSQ19yySWOgoICx7PPPov26wLfA9hER7RB92/YW2+9VfuDK+O5SHn0GWec4fE6dbWtNWRsl8ZjZMyM119/3XH8+HHtD8vChQs148bTdfcWwwXt13pbTZ061bF9+3btn4xdu3Y5brrppmbHPPbYY468vDztmB9++MExaNAgj/dxV9jCwsK0cSa/4yorKx179+51PPHEEw5/f3+0XxfoH2zipLeB4bdfAAAAAAC6PN3axwUAAAAA3QsYLgAAAADwGmC4AAAAAMBrgOECAAAAAK8BhgsAAAAAvAYYLgAAAADwGmC4AAAAAMBrgOECgI/x6KOPii1btrh0jsPhENOmTeuwOgEAQFuB4QJAN+Gnn37Skuvp8eKLL5K8PwAA4E2YPF0BAEDn4efnJyoqKrQNAAC8Ecy4ANANeP/998X48ePFXXfdpS3ryO3aa6/Vfk6ZMkXLTl1TUyPOPvvsZktFo0aNEt9//70oLCwUpaWlYsWKFWLEiBEefR4AAGgNGC4AdAPuvPNOsWbNGvH222+LXr16aduRI0e0fc8++6x48MEHxZAhQ8T27dubnWs2m8WCBQs0o2bMmDFiz5494ptvvhFhYWEeeBIAAFCDpSIAugHl5eWitrZWVFZWivz8fO2z1NRU7ecjjzwili1bpvSNcebmm2/WZl7GjRsnlixZ0sE1BwAA18CMCwDdHLlMpCI2Nlabqdm9e7dmsEgjSM629OnTp9PqCAAAbQUzLgB0c/QcceUyUc+ePbXlpkOHDmm+MGvXrhUBAQGdVkcAAGgrMFwA6CbIpSKpGnKVs846S8yaNUt8++23WjkpKUnExMR0QA0BAKD9wHABoJtw8OBBMXr0aNG3b19htVqF0di2lWDpjPvnP/9ZW1IKDw8XL7zwguYrAwAAXRH4uADQTZCB5erq6sSuXbtEUVFRm31UbrzxRtGjRw+xefNm8eGHH4pXX31VFBQUdHh9AQDAHQwymrdbZwIAAAAAdDKYcQEAAACA1wDDBQAAAABeAwwXAAAAAHgNMFwAAAAA4DXAcAEAAACA1wDDBQAAAABeAwwXAAAAAHgNMFwAAAAA4DXAcAEAAACA1wDDBQAAAABeAwwXAAAAAHgNMFwAAAAAILyF/weCbspF9sZxYQAAAABJRU5ErkJggg==" }, "metadata": {}, - "output_type": "display_data" + "output_type": "display_data", + "jetTransient": { + "display_id": null + } } ], "execution_count": 3 @@ -93,8 +96,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-01-27T18:11:57.460173Z", - "start_time": "2025-01-27T18:11:57.343196Z" + "end_time": "2026-03-26T22:23:28.055608Z", + "start_time": "2026-03-26T22:23:27.905949Z" } }, "cell_type": "code", @@ -121,10 +124,13 @@ "text/plain": [ "
" ], - "image/png": "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" + "image/png": "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" }, "metadata": {}, - "output_type": "display_data" + "output_type": "display_data", + "jetTransient": { + "display_id": null + } } ], "execution_count": 4 diff --git a/examples/view_experiment2_behavior.ipynb b/examples/view_experiment2_behavior.ipynb index 9a9666c..20ac169 100644 --- a/examples/view_experiment2_behavior.ipynb +++ b/examples/view_experiment2_behavior.ipynb @@ -9,8 +9,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-01-27T18:11:58.286738Z", - "start_time": "2025-01-27T18:11:58.063475Z" + "end_time": "2026-03-26T22:23:36.412Z", + "start_time": "2026-03-26T22:23:36.407827Z" } }, "cell_type": "code", @@ -25,13 +25,13 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-01-27T18:11:58.914027Z", - "start_time": "2025-01-27T18:11:58.295149Z" + "end_time": "2026-03-26T22:23:39.053698Z", + "start_time": "2026-03-26T22:23:36.412905Z" } }, "cell_type": "code", "source": [ - "from hobj.benchmarks import MutatorOneshotBenchmark\n", + "from hobj import MutatorOneshotBenchmark\n", "benchmark2 = MutatorOneshotBenchmark()\n", "target_statistics = benchmark2.target_statistics\n", "print(target_statistics)" @@ -50,10 +50,10 @@ " transformation_level (transformation) float64 288B 0.1 0.2154 ... 0.5 1.5\n", "Dimensions without coordinates: boot_iter\n", "Data variables:\n", - " phat (transformation) float64 288B 1.0 1.0 ... 0.952 1.0\n", - " varhat_phat (transformation) float64 288B 0.0003555 ... 0.0003867\n", - " boot_phat (boot_iter, transformation) float64 288kB 0.991 ......\n", - " boot_varhat_phat (boot_iter, transformation) float64 288kB 0.0004516...\n" + " phat (transformation) float64 288B 0.9969 1.0 ... 0.945 1.0\n", + " varhat_phat (transformation) float64 288B 0.0003446 ... 0.0003748\n", + " boot_phat (boot_iter, transformation) float64 288kB 0.9797 .....\n", + " boot_varhat_phat (boot_iter, transformation) float64 288kB 0.0004078...\n" ] } ], @@ -62,8 +62,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-01-27T18:11:59.312918Z", - "start_time": "2025-01-27T18:11:58.914641Z" + "end_time": "2026-03-26T22:23:39.471935Z", + "start_time": "2026-03-26T22:23:39.087799Z" } }, "cell_type": "code", @@ -100,10 +100,13 @@ "text/plain": [ "
" ], - "image/png": "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" + "image/png": "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" }, "metadata": {}, - "output_type": "display_data" + "output_type": "display_data", + "jetTransient": { + "display_id": null + } } ], "execution_count": 3 diff --git a/hobj/__init__.py b/hobj/__init__.py index d70fc75..c6dc39a 100644 --- a/hobj/__init__.py +++ b/hobj/__init__.py @@ -1,2 +1,28 @@ -import hobj.benchmarks as benchmarks -import hobj.learning_models as learning_models +from hobj.benchmarks.mut_oneshot_benchmark import MutatorOneshotBenchmark +from hobj.benchmarks.mut_highvar_benchmark import MutatorHighVarBenchmark + +from hobj.data_loaders.behavior import load_highvar_behavior, load_oneshot_behavior + +from hobj.data_loaders.images import ( + load_image, + load_imageset_meta_highvar, + load_imageset_meta_oneshot, + load_imageset_meta_warmup, + load_imageset_meta_catch, +) + +__all__ = [ + # Raw behavior loaders + "load_highvar_behavior", + "load_oneshot_behavior", + # Image meta loaders: + "load_imageset_meta_highvar", + "load_imageset_meta_oneshot", + "load_imageset_meta_warmup", + "load_imageset_meta_catch", + # Image loader: + "load_image", + # Benchmarks: + "MutatorHighVarBenchmark", + "MutatorOneshotBenchmark", +] diff --git a/hobj/benchmarks/__init__.py b/hobj/benchmarks/__init__.py index 17797ed..e69de29 100644 --- a/hobj/benchmarks/__init__.py +++ b/hobj/benchmarks/__init__.py @@ -1,2 +0,0 @@ -from hobj.benchmarks.mut_highvar_benchmark import MutatorHighVarBenchmark -from hobj.benchmarks.mut_oneshot_benchmark import MutatorOneshotBenchmark diff --git a/hobj/benchmarks/binary_classification/benchmark.py b/hobj/benchmarks/binary_classification/benchmark.py index 90820a6..97b9303 100644 --- a/hobj/benchmarks/binary_classification/benchmark.py +++ b/hobj/benchmarks/binary_classification/benchmark.py @@ -7,7 +7,10 @@ from tqdm import tqdm from hobj.benchmarks.binary_classification.estimator import LearningCurveStatistics -from hobj.benchmarks.binary_classification.simulation import BinaryClassificationSubtask, BinaryClassificationSubtaskResult +from hobj.benchmarks.binary_classification.simulation import ( + BinaryClassificationSubtask, + BinaryClassificationSubtaskResult, +) from hobj.learning_models import BinaryLearningModel from hobj.stats.ci import estimate_basic_bootstrap_CI @@ -15,42 +18,50 @@ # %% Models for configuring a LearningCurveBenchmark: class TargetSubtaskData(pydantic.BaseModel): subtask: BinaryClassificationSubtask # The subtask which generated the associated results - results: List[BinaryClassificationSubtaskResult] # [session, trial] boolean matrix of performance + results: List[ + BinaryClassificationSubtaskResult + ] # [session, trial] boolean matrix of performance - model_config = dict( - arbitrary_types_allowed=True - ) + model_config = dict(arbitrary_types_allowed=True) - @pydantic.model_validator(mode='after') - def validate_results(self) -> 'TargetSubtaskData': + @pydantic.model_validator(mode="after") + def validate_results(self) -> "TargetSubtaskData": # Check shape for result in self.results: if self.subtask.ntrials != len(result.perf_seq): - raise ValueError(f"Expected {self.subtask.ntrials} trials, but got {result.perf_seq} trials") + raise ValueError( + f"Expected {self.subtask.ntrials} trials, but got {result.perf_seq} trials" + ) return self class LearningCurveBenchmarkConfig(pydantic.BaseModel): - subtask_name_to_data: Dict[str, 'TargetSubtaskData'] = pydantic.Field(default_factory=dict, description="A dictionary of subtask_name -> TargetSubtaskConfig") + subtask_name_to_data: Dict[str, "TargetSubtaskData"] = pydantic.Field( + default_factory=dict, + description="A dictionary of subtask_name -> TargetSubtaskConfig", + ) num_simulations_per_subtask: int = pydantic.Field(ge=2) num_bootstrap_samples: int = pydantic.Field(ge=2) bootstrap_by_worker: bool ntrials: Optional[int] = pydantic.Field(default=None) - @pydantic.model_validator(mode='after') - def ensure_rectangular(self) -> 'LearningCurveBenchmarkConfig': - + @pydantic.model_validator(mode="after") + def ensure_rectangular(self) -> "LearningCurveBenchmarkConfig": ntrials_observed = set() for name, data in self.subtask_name_to_data.items(): ntrials_observed.add(data.subtask.ntrials) if not len(ntrials_observed) == 1: - raise ValueError(f"Expected all subtasks to have the same number of trials, but got {ntrials_observed}") + raise ValueError( + f"Expected all subtasks to have the same number of trials, but got {ntrials_observed}" + ) if self.ntrials is not None: if self.ntrials != ntrials_observed.pop(): - raise ValueError(f"Expected ntrials to be {ntrials_observed.pop()}, but got {self.ntrials}") + raise ValueError( + f"Expected ntrials to be {ntrials_observed.pop()}, but got {self.ntrials}" + ) else: self.ntrials = ntrials_observed.pop() return self @@ -58,20 +69,22 @@ def ensure_rectangular(self) -> 'LearningCurveBenchmarkConfig': # %% class LearningCurveBenchmark: - def __init__( - self, - config: LearningCurveBenchmarkConfig, + self, + config: LearningCurveBenchmarkConfig, ): self.config = config # Attach properties self.subtask_names = sorted(config.subtask_name_to_data.keys()) self.subtask_name_to_subtask: Dict[str, BinaryClassificationSubtask] = { - name: config.subtask_name_to_data[name].subtask for name in self.subtask_names + name: config.subtask_name_to_data[name].subtask + for name in self.subtask_names } - self.subtask_name_to_results: Dict[str, List[BinaryClassificationSubtaskResult]] = {} + self.subtask_name_to_results: Dict[ + str, List[BinaryClassificationSubtaskResult] + ] = {} self._target_data = {} for name in self.subtask_names: @@ -82,8 +95,12 @@ def __init__( for result in results: worker_id = result.worker_id if worker_id in self._target_data[name]: - raise ValueError(f"Worker {worker_id} has already been seen for subtask {name}") - self._target_data[name][result.worker_id] = list([bool(v) for v in result.perf_seq]) + raise ValueError( + f"Worker {worker_id} has already been seen for subtask {name}" + ) + self._target_data[name][result.worker_id] = list( + [bool(v) for v in result.perf_seq] + ) self._target_statistics = LearningCurveStatistics( subtask_name_to_results=self.subtask_name_to_results, @@ -95,7 +112,6 @@ def __init__( def target_data(self) -> Dict[str, Dict[str, List[bool]]]: return self._target_data - @property def target_statistics(self) -> LearningCurveStatistics: """ @@ -115,9 +131,7 @@ class LearningCurveBenchmarkResult: model_statistics: LearningCurveStatistics def __call__( - self, - learner: BinaryLearningModel, - show_pbar: bool = False + self, learner: BinaryLearningModel, show_pbar: bool = False ) -> LearningCurveBenchmarkResult: """ :param learner: LearningModel @@ -125,8 +139,12 @@ def __call__( """ # Get model learning curve statistics: - subtask_name_to_model_results: Dict[str, List[BinaryClassificationSubtaskResult]] = {} - for i_subtask, subtask_name in enumerate(tqdm(self.subtask_names, desc='Subtask simulations:', disable=not show_pbar)): + subtask_name_to_model_results: Dict[ + str, List[BinaryClassificationSubtaskResult] + ] = {} + for i_subtask, subtask_name in enumerate( + tqdm(self.subtask_names, desc="Subtask simulations:", disable=not show_pbar) + ): # Get [simulation, trial] boolean performance matrix for the model subtask_results = self.simulate_model_behavior( subtask=self.subtask_name_to_subtask[subtask_name], @@ -149,7 +167,7 @@ def __call__( model_varhat_phat=model_statistics.varhat_phat, target_phat=self.target_statistics.phat, target_varhat_phat=self.target_statistics.varhat_phat, - condition_dims=('subtask', 'trial'), + condition_dims=("subtask", "trial"), fit_lapse_rate=True, ) @@ -159,7 +177,7 @@ def __call__( model_varhat_phat=model_statistics.boot_varhat_phat, target_phat=self.target_statistics.boot_phat, target_varhat_phat=self.target_statistics.boot_varhat_phat, - condition_dims=('subtask', 'trial'), + condition_dims=("subtask", "trial"), fit_lapse_rate=True, ) @@ -182,9 +200,9 @@ def __call__( @staticmethod def simulate_model_behavior( - subtask: BinaryClassificationSubtask, - learner: BinaryLearningModel, - nsimulations: int, + subtask: BinaryClassificationSubtask, + learner: BinaryLearningModel, + nsimulations: int, ) -> List[BinaryClassificationSubtaskResult]: """ Returns a [nsimulations, ntrials] matrix of model performance on the subtask. @@ -213,34 +231,33 @@ def simulate_model_behavior( @classmethod def _compare_learning_curves( - cls, - model_phat: xr.DataArray, - model_varhat_phat: xr.DataArray, - target_phat: xr.DataArray, - target_varhat_phat: xr.DataArray, - condition_dims: Tuple[str, ...], - fit_lapse_rate: bool + cls, + model_phat: xr.DataArray, + model_varhat_phat: xr.DataArray, + target_phat: xr.DataArray, + target_varhat_phat: xr.DataArray, + condition_dims: Tuple[str, ...], + fit_lapse_rate: bool, ) -> Tuple[Union[np.ndarray, np.generic], Union[xr.DataArray, None]]: - if fit_lapse_rate: lapse_rate = cls._fit_lapse_rate( - pmodel=model_phat, - ptarget=target_phat, - condition_dims=condition_dims + pmodel=model_phat, ptarget=target_phat, condition_dims=condition_dims ) model_phat = model_phat * (1 - lapse_rate) + 0.5 * lapse_rate model_varhat_phat = model_varhat_phat * (1 - lapse_rate) ** 2 else: lapse_rate = None - msen = np.square(model_phat - target_phat).mean(condition_dims) - model_varhat_phat.mean(condition_dims) - target_varhat_phat.mean(condition_dims) + msen = ( + np.square(model_phat - target_phat).mean(condition_dims) + - model_varhat_phat.mean(condition_dims) + - target_varhat_phat.mean(condition_dims) + ) return msen, lapse_rate @staticmethod def _fit_lapse_rate( - pmodel: xr.DataArray, - ptarget: xr.DataArray, - condition_dims: Tuple[str, ...] + pmodel: xr.DataArray, ptarget: xr.DataArray, condition_dims: Tuple[str, ...] ) -> Union[np.ndarray, np.generic]: """ Fits a "lapse rate" parameter (gamma), which takes on values between [0, 1]. It may be interpreted @@ -257,8 +274,15 @@ def _fit_lapse_rate( """ nway = 2 - numerator = -(2 * pmodel / nway - 2 * np.square(pmodel) + 2 * pmodel * ptarget - 2 * ptarget / nway).sum(dim=condition_dims) - denominator = (2 / (nway ** 2) - 4 * pmodel / nway + 2 * (pmodel ** 2)).sum(dim=condition_dims) + numerator = -( + 2 * pmodel / nway + - 2 * np.square(pmodel) + + 2 * pmodel * ptarget + - 2 * ptarget / nway + ).sum(dim=condition_dims) + denominator = (2 / (nway**2) - 4 * pmodel / nway + 2 * (pmodel**2)).sum( + dim=condition_dims + ) gamma_star = numerator / denominator gamma_star = np.clip(gamma_star, 0, 1) return gamma_star diff --git a/hobj/benchmarks/binary_classification/estimator.py b/hobj/benchmarks/binary_classification/estimator.py index 0b80cb7..5419532 100644 --- a/hobj/benchmarks/binary_classification/estimator.py +++ b/hobj/benchmarks/binary_classification/estimator.py @@ -4,7 +4,9 @@ import numpy as np import xarray as xr -from hobj.benchmarks.binary_classification.simulation import BinaryClassificationSubtaskResult +from hobj.benchmarks.binary_classification.simulation import ( + BinaryClassificationSubtaskResult, +) from hobj.stats import binomial as binomial_funcs @@ -13,10 +15,10 @@ class LearningCurveStatistics(xr.Dataset): __slots__ = () def __init__( - self, - subtask_name_to_results: Dict[str, List[BinaryClassificationSubtaskResult]], - nbootstrap_samples: int, - bootstrap_by_worker: bool, # versus by session + self, + subtask_name_to_results: Dict[str, List[BinaryClassificationSubtaskResult]], + nbootstrap_samples: int, + bootstrap_by_worker: bool, # versus by session ): # Get canonical order of subtask names subtask_names = sorted(subtask_name_to_results.keys()) @@ -34,7 +36,9 @@ def __init__( all_workers.add(r.worker_id) if not len(ntrials_observed) == 1: - raise ValueError(f"Expected all subtasks to have the same number of trials, but got {ntrials_observed}") + raise ValueError( + f"Expected all subtasks to have the same number of trials, but got {ntrials_observed}" + ) ntrials = ntrials_observed.pop() all_workers = sorted(all_workers) worker_to_i = {worker: i for i, worker in enumerate(all_workers)} @@ -68,14 +72,14 @@ def __init__( if bootstrap_by_worker: bootstrap_resamples = self._get_bootstrap_resamples_by_worker( perf_mat=perf_mat, - i_subtasks = i_subtasks, - i_workers = i_workers, + i_subtasks=i_subtasks, + i_workers=i_workers, nbootstrap_samples=nbootstrap_samples, ) else: bootstrap_resamples = self._get_bootstrap_resamples_by_session( perf_mat=perf_mat, - i_subtasks = i_subtasks, + i_subtasks=i_subtasks, nbootstrap_samples=nbootstrap_samples, ) @@ -87,23 +91,25 @@ def __init__( super().__init__( data_vars=dict( - phat=(['subtask', 'trial'], phat), - varhat_phat=(['subtask', 'trial'], varhat_phat), - boot_phat=(['boot_iter', 'subtask', 'trial'], boot_phat), - boot_varhat_phat=(['boot_iter', 'subtask', 'trial'], boot_varhat_phat), + phat=(["subtask", "trial"], phat), + varhat_phat=(["subtask", "trial"], varhat_phat), + boot_phat=(["boot_iter", "subtask", "trial"], boot_phat), + boot_varhat_phat=(["boot_iter", "subtask", "trial"], boot_varhat_phat), ), coords=dict( subtask=subtask_names, - ) + ), ) @staticmethod def get_point_estimates( - k: np.ndarray, - n: np.ndarray, + k: np.ndarray, + n: np.ndarray, ) -> Tuple[np.ndarray, np.ndarray]: phat = k / n - varhat_phat = binomial_funcs.estimate_variance_of_binomial_proportion(kvec=k, nvec=n) + varhat_phat = binomial_funcs.estimate_variance_of_binomial_proportion( + kvec=k, nvec=n + ) return phat, varhat_phat @dataclass @@ -113,24 +119,29 @@ class BootstrapSamples: @staticmethod def _get_bootstrap_resamples_by_worker( - perf_mat: np.ndarray, # [session, trial] - i_subtasks: List[int], # [session] - i_workers: List[int], # [session] - nbootstrap_samples: int, + perf_mat: np.ndarray, # [session, trial] + i_subtasks: List[int], # [session] + i_workers: List[int], # [session] + nbootstrap_samples: int, ) -> BootstrapSamples: - if not perf_mat.dtype == np.bool: - raise ValueError(f"Expected perf_mat to have dtype bool, but got {perf_mat.dtype}") + raise ValueError( + f"Expected perf_mat to have dtype bool, but got {perf_mat.dtype}" + ) ntrials = perf_mat.shape[1] nworkers = max(i_workers) + 1 nsubtasks = max(i_subtasks) + 1 if not len(set(i_subtasks)) == nsubtasks: - raise ValueError(f"Expected i_subtasks to be a contiguous range, but got {set(i_subtasks)}") + raise ValueError( + f"Expected i_subtasks to be a contiguous range, but got {set(i_subtasks)}" + ) if not len(set(i_workers)) == nworkers: - raise ValueError(f"Expected i_workers to be a contiguous range, but got {set(i_workers)}") + raise ValueError( + f"Expected i_workers to be a contiguous range, but got {set(i_workers)}" + ) # Reshape data perf_table = np.zeros(shape=(nworkers, nsubtasks, ntrials), dtype=np.bool) @@ -157,9 +168,9 @@ def _get_bootstrap_resamples_by_worker( @staticmethod def _get_bootstrap_resamples_by_session( - perf_mat: np.ndarray, # [session, trial] - i_subtasks: List[int], # [session] - nbootstrap_samples: int, + perf_mat: np.ndarray, # [session, trial] + i_subtasks: List[int], # [session] + nbootstrap_samples: int, ) -> BootstrapSamples: # Bootstrap by session, within each subtask @@ -167,7 +178,9 @@ def _get_bootstrap_resamples_by_session( nsubtasks = max(i_subtasks) + 1 if not len(set(i_subtasks)) == nsubtasks: - raise ValueError(f"Expected i_subtasks to be a contiguous range, but got {set(i_subtasks)}") + raise ValueError( + f"Expected i_subtasks to be a contiguous range, but got {set(i_subtasks)}" + ) # Reshape data to {i_subtask: [session, trial]} i_subtask_to_perf_data = {} @@ -178,7 +191,9 @@ def _get_bootstrap_resamples_by_session( # Cast to np arrays for i_subtask in i_subtask_to_perf_data: - i_subtask_to_perf_data[i_subtask] = np.array(i_subtask_to_perf_data[i_subtask], dtype = np.bool) + i_subtask_to_perf_data[i_subtask] = np.array( + i_subtask_to_perf_data[i_subtask], dtype=np.bool + ) # Perform bootstrapping gen = np.random.default_rng() @@ -187,8 +202,12 @@ def _get_bootstrap_resamples_by_session( for i_bootstrap in range(nbootstrap_samples): for i_subtask in range(nsubtasks): nsessions_for_subtask = len(i_subtask_to_perf_data[i_subtask]) - i_sessions = gen.integers(low=0, high=nsessions_for_subtask, size=nsessions_for_subtask) - boot_k[i_bootstrap, i_subtask] = i_subtask_to_perf_data[i_subtask][i_sessions].sum(axis=0) + i_sessions = gen.integers( + low=0, high=nsessions_for_subtask, size=nsessions_for_subtask + ) + boot_k[i_bootstrap, i_subtask] = i_subtask_to_perf_data[i_subtask][ + i_sessions + ].sum(axis=0) boot_n[i_bootstrap, i_subtask] = len(i_sessions) return LearningCurveStatistics.BootstrapSamples( diff --git a/hobj/benchmarks/binary_classification/simulation.py b/hobj/benchmarks/binary_classification/simulation.py index ad35f89..39b3300 100644 --- a/hobj/benchmarks/binary_classification/simulation.py +++ b/hobj/benchmarks/binary_classification/simulation.py @@ -8,9 +8,7 @@ # %% class BinaryClassificationSubtaskResult(pydantic.BaseModel): - model_config = dict( - arbitrary_types_allowed=True - ) + model_config = dict(arbitrary_types_allowed=True) perf_seq: np.ndarray worker_id: Optional[str] = pydantic.Field(default="NO_WORKER") @@ -22,30 +20,34 @@ class BinaryClassificationSubtask(pydantic.BaseModel): Feedback consists of +1 or -1 rewards, depending on the class of the image. """ - model_config = dict( - frozen=True - ) + model_config = dict(frozen=True) classA: List[ImageId] classB: List[ImageId] - ntrials: int = pydantic.Field(description='The number of trials in the subtask.', gt=0) - replace: bool = pydantic.Field(description='Whether to show stimulus images with replacement or not.') + ntrials: int = pydantic.Field( + description="The number of trials in the subtask.", gt=0 + ) + replace: bool = pydantic.Field( + description="Whether to show stimulus images with replacement or not." + ) - @pydantic.field_validator('classA', 'classB', mode='after') + @pydantic.field_validator("classA", "classB", mode="after") @classmethod def sort_image_refs(cls, value: List[ImageId]) -> List[ImageId]: return sorted(value) - @pydantic.model_validator(mode='after') - def validate_image_refs(self) -> 'BinaryClassificationSubtask': + @pydantic.model_validator(mode="after") + def validate_image_refs(self) -> "BinaryClassificationSubtask": if not self.replace and len(self.classA) + len(self.classB) < self.ntrials: - raise ValueError(f"Specified replace=False, but only {len(self.classA) + len(self.classB)} images available. (len(classA)={len(self.classA)}; len(classB)={len(self.classB)}") + raise ValueError( + f"Specified replace=False, but only {len(self.classA) + len(self.classB)} images available. (len(classA)={len(self.classA)}; len(classB)={len(self.classB)}" + ) return self def simulate_session( - self, - learner: BinaryLearningModel, - seed: Union[int, None], + self, + learner: BinaryLearningModel, + seed: Union[int, None], ) -> BinaryClassificationSubtaskResult: """ Convenience method to simulate a session of the binary classification task on a given BinaryLearningModel. @@ -66,7 +68,7 @@ def simulate_session( if self.replace: i_image_seq = gen.integers(n_all_images, size=self.ntrials) else: - i_image_seq = gen.permutation(n_all_images)[:self.ntrials] + i_image_seq = gen.permutation(n_all_images)[: self.ntrials] # Randomly sample the reward contingency classA_correct_action = 0 if gen.random() < 0.5 else 1 @@ -76,14 +78,20 @@ def simulate_session( i_trial = 0 for i_image in i_image_seq: # Retrieve trial information - image_ref_cur = self.classA[i_image] if i_image < num_classA else self.classB[i_image - num_classA] - correct_action_cur = classA_correct_action if i_image < num_classA else classB_correct_action + image_ref_cur = ( + self.classA[i_image] + if i_image < num_classA + else self.classB[i_image - num_classA] + ) + correct_action_cur = ( + classA_correct_action if i_image < num_classA else classB_correct_action + ) # Get response from learner a = learner.get_response(image=image_ref_cur) # Calculate feedback based on response - feedback = 1. if a == correct_action_cur else -1. + feedback = 1.0 if a == correct_action_cur else -1.0 # Deliver feedback to learner learner.give_feedback(feedback) diff --git a/hobj/benchmarks/generalization/benchmark.py b/hobj/benchmarks/generalization/benchmark.py index 69266ac..29ba34a 100644 --- a/hobj/benchmarks/generalization/benchmark.py +++ b/hobj/benchmarks/generalization/benchmark.py @@ -7,7 +7,10 @@ from tqdm import tqdm from hobj.benchmarks.generalization.estimator import GeneralizationStatistics -from hobj.benchmarks.generalization.simulator import GeneralizationSessionResult, GeneralizationSubtask +from hobj.benchmarks.generalization.simulator import ( + GeneralizationSessionResult, + GeneralizationSubtask, +) from hobj.learning_models import BinaryLearningModel from hobj.stats.ci import estimate_basic_bootstrap_CI @@ -23,10 +26,9 @@ class GeneralizationBenchmarkConfig(pydantic.BaseModel): # %% class GeneralizationBenchmark: - def __init__( - self, - config: GeneralizationBenchmarkConfig, + self, + config: GeneralizationBenchmarkConfig, ): self.config = config self._generalization_statistics = GeneralizationStatistics( @@ -52,9 +54,7 @@ class GeneralizationBenchmarkResult: model_statistics: GeneralizationStatistics def __call__( - self, - learner: BinaryLearningModel, - show_pbar: bool = False + self, learner: BinaryLearningModel, show_pbar: bool = False ) -> GeneralizationBenchmarkResult: """ :param learner: LearningModel @@ -63,7 +63,9 @@ def __call__( # Get model generalization behaviors: results: List[GeneralizationSessionResult] = [] - for subtask in tqdm(self.config.subtasks, desc='Subtask simulations:', disable=not show_pbar): + for subtask in tqdm( + self.config.subtasks, desc="Subtask simulations:", disable=not show_pbar + ): # Get [simulation, trial] boolean performance matrix for the model subtask_results = self.simulate_model_behavior( subtask=subtask, @@ -77,11 +79,13 @@ def __call__( results=results, perform_lapse_rate_correction=False, n_bootstrap_iterations=self.config.num_bootstrap_samples, - bootstrap_by_worker=False, # bootstrap simulations + bootstrap_by_worker=False, # bootstrap simulations ) # Get target transformation - model_statistics = model_statistics.sel(transformation = self.target_statistics.transformation) + model_statistics = model_statistics.sel( + transformation=self.target_statistics.transformation + ) # Calculate comparison statistics between target and model learning curves: msen_point = self._compare_generalization_patterns( @@ -89,7 +93,7 @@ def __call__( model_varhat_phat=model_statistics.varhat_phat, target_phat=self.target_statistics.phat, target_varhat_phat=self.target_statistics.varhat_phat, - condition_dims=('transformation',), + condition_dims=("transformation",), ) # Calculate bootstrap replicates: @@ -98,7 +102,7 @@ def __call__( model_varhat_phat=model_statistics.boot_varhat_phat, target_phat=self.target_statistics.boot_phat, target_varhat_phat=self.target_statistics.boot_varhat_phat, - condition_dims=('transformation',), + condition_dims=("transformation",), ) msen_sigma = np.std(msen_boot, ddof=1) @@ -118,9 +122,9 @@ def __call__( @staticmethod def simulate_model_behavior( - subtask: GeneralizationSubtask, - learner: BinaryLearningModel, - nsimulations: int, + subtask: GeneralizationSubtask, + learner: BinaryLearningModel, + nsimulations: int, ) -> List[GeneralizationSessionResult]: """ Returns a [nsimulations, ntrials] matrix of model performance on the subtask. @@ -138,19 +142,27 @@ def simulate_model_behavior( learner.reset_state(seed=None) # Simulate session: - results.append(subtask.simulate_session(learner=learner, seed=None, )) + results.append( + subtask.simulate_session( + learner=learner, + seed=None, + ) + ) return results @classmethod def _compare_generalization_patterns( - cls, - model_phat: xr.DataArray, - model_varhat_phat: xr.DataArray, - target_phat: xr.DataArray, - target_varhat_phat: xr.DataArray, - condition_dims: Tuple[str, ...], + cls, + model_phat: xr.DataArray, + model_varhat_phat: xr.DataArray, + target_phat: xr.DataArray, + target_varhat_phat: xr.DataArray, + condition_dims: Tuple[str, ...], ): - - msen = np.square(model_phat - target_phat).mean(condition_dims) - model_varhat_phat.mean(condition_dims) - target_varhat_phat.mean(condition_dims) + msen = ( + np.square(model_phat - target_phat).mean(condition_dims) + - model_varhat_phat.mean(condition_dims) + - target_varhat_phat.mean(condition_dims) + ) return msen diff --git a/hobj/benchmarks/generalization/estimator.py b/hobj/benchmarks/generalization/estimator.py index 6dbd337..e3e57b2 100644 --- a/hobj/benchmarks/generalization/estimator.py +++ b/hobj/benchmarks/generalization/estimator.py @@ -12,20 +12,21 @@ class GeneralizationStatistics(xr.Dataset): __slots__ = () def __init__( - self, - results: List[GeneralizationSessionResult], - perform_lapse_rate_correction: bool, - n_bootstrap_iterations: int, - bootstrap_by_worker: bool, # versus by session + self, + results: List[GeneralizationSessionResult], + perform_lapse_rate_correction: bool, + n_bootstrap_iterations: int, + bootstrap_by_worker: bool, # versus by session ): - # Get all transformations all_transformations = set() for result in results: all_transformations.update(result.transformation_to_kn.keys()) all_transformations = sorted(all_transformations) - transformation_to_i = {transformation: i for i, transformation in enumerate(all_transformations)} + transformation_to_i = { + transformation: i for i, transformation in enumerate(all_transformations) + } # Get all workers all_workers = sorted({result.worker_id for result in results}) @@ -38,9 +39,13 @@ def __init__( if bootstrap_by_worker: if nworkers == 1: - raise ValueError(f"Only one worker {all_workers}, cannot perform valid bootstrap by worker.") + raise ValueError( + f"Only one worker {all_workers}, cannot perform valid bootstrap by worker." + ) elif nworkers < 20: - warnings.warn(f"Only {nworkers} unique workers, which is less than 20. Bootstrapping by worker may not be reliable.") + warnings.warn( + f"Only {nworkers} unique workers, which is less than 20. Bootstrapping by worker may not be reliable." + ) kmat = np.zeros(shape=(nworkers, ntransformations)) nmat = np.zeros(shape=(nworkers, ntransformations)) @@ -78,7 +83,6 @@ def __init__( boot_varhat_phat = np.zeros(shape=(n_bootstrap_iterations, ntransformations)) for i_boot_iter in range(n_bootstrap_iterations): - if bootstrap_by_worker: # Resample by worker i_boot = gen.integers(low=0, high=nworkers, size=nworkers) @@ -105,27 +109,26 @@ def __init__( super().__init__( data_vars=dict( - phat=(['transformation'], phat), - varhat_phat=(['transformation'], varhat_phat), - boot_phat=(['boot_iter', 'transformation'], boot_phat), - boot_varhat_phat=(['boot_iter', 'transformation'], boot_varhat_phat), + phat=(["transformation"], phat), + varhat_phat=(["transformation"], varhat_phat), + boot_phat=(["boot_iter", "transformation"], boot_phat), + boot_varhat_phat=(["boot_iter", "transformation"], boot_varhat_phat), ), - coords=dict( - transformation=all_transformations - ) + coords=dict(transformation=all_transformations), ) @staticmethod def _get_point_estimates( - k: np.ndarray, # [transformation] - n: np.ndarray, # [transformation] - kcatch: np.ndarray, # () - ncatch: np.ndarray, # () - perform_lapse_rate_correction: bool, + k: np.ndarray, # [transformation] + n: np.ndarray, # [transformation] + kcatch: np.ndarray, # () + ncatch: np.ndarray, # () + perform_lapse_rate_correction: bool, ): - phat = k / n - varhat_phat = binomial_funcs.estimate_variance_of_binomial_proportion(kvec=k, nvec=n) + varhat_phat = binomial_funcs.estimate_variance_of_binomial_proportion( + kvec=k, nvec=n + ) if perform_lapse_rate_correction: # Return an estimate of the performance that would be expected if the system had a lapse rate of 0. diff --git a/hobj/benchmarks/generalization/simulator.py b/hobj/benchmarks/generalization/simulator.py index 9bddd95..8b9c2ae 100644 --- a/hobj/benchmarks/generalization/simulator.py +++ b/hobj/benchmarks/generalization/simulator.py @@ -7,6 +7,7 @@ from hobj.learning_models import BinaryLearningModel from hobj.types import ImageId + # %% class GeneralizationSessionResult(pydantic.BaseModel): transformation_to_kn: Dict[str, List[int]] @@ -14,15 +15,19 @@ class GeneralizationSessionResult(pydantic.BaseModel): ncatch: int worker_id: Optional[str] = pydantic.Field(default="NO_WORKER") - @pydantic.model_validator(mode='after') - def validate_results(self) -> 'GeneralizationSessionResult': + @pydantic.model_validator(mode="after") + def validate_results(self) -> "GeneralizationSessionResult": for transformation in self.transformation_to_kn: k, n = self.transformation_to_kn[transformation] if k < 0 or n < 0 or k > n: - raise ValueError(f"Got invalid Binomial parameters k={k}, n={n} for transformation {transformation}") + raise ValueError( + f"Got invalid Binomial parameters k={k}, n={n} for transformation {transformation}" + ) if self.kcatch < 0 or self.ncatch < 0 or self.kcatch > self.ncatch: - raise ValueError(f"Got invalid Binomial parameters k={self.kcatch}, n={self.ncatch} for catch trials") + raise ValueError( + f"Got invalid Binomial parameters k={self.kcatch}, n={self.ncatch} for catch trials" + ) return self @@ -32,9 +37,7 @@ class GeneralizationSubtask(pydantic.BaseModel): A simulator for a single session of the specific "one-shot" task used in Lee and DiCarlo 2023. """ - model_config = dict( - frozen=True - ) + model_config = dict(frozen=True) support_imageA: ImageId support_imageB: ImageId @@ -42,24 +45,25 @@ class GeneralizationSubtask(pydantic.BaseModel): test_imagesB: List[ImageId] image_ref_to_transformation: Dict[ImageId, str] - @pydantic.field_validator('test_imagesA', 'test_imagesB', mode='after') + @pydantic.field_validator("test_imagesA", "test_imagesB", mode="after") @classmethod def sort_image_refs(cls, value: List[ImageId]) -> List[ImageId]: return sorted(value) - @pydantic.model_validator(mode='after') - def validate_model(self) -> 'GeneralizationSubtask': - + @pydantic.model_validator(mode="after") + def validate_model(self) -> "GeneralizationSubtask": for ref in self.test_imagesA + self.test_imagesB: if ref not in self.image_ref_to_transformation: - raise ValueError(f"Expected all test images to have an associated transformation, but {ref} was missing.") + raise ValueError( + f"Expected all test images to have an associated transformation, but {ref} was missing." + ) return self def simulate_session( - self, - learner: BinaryLearningModel, - seed: Union[int, None], + self, + learner: BinaryLearningModel, + seed: Union[int, None], ) -> GeneralizationSessionResult: """ Convenience method to simulate a session of the one-shot task on a given BinaryLearningModel. @@ -84,7 +88,9 @@ def simulate_session( # An initial phase of 10 support trials, with classes sampled in equal number (5 each) support_sequence = [True] * 5 + [False] * 5 - support_sequence = [support_sequence[i] for i in gen.permutation(len(support_sequence))] + support_sequence = [ + support_sequence[i] for i in gen.permutation(len(support_sequence)) + ] stimulus_category_is_A_seq.extend(support_sequence) # A testing phase of 8 test trials with 2 catch trials, where classes are sampled i.i.d. @@ -104,11 +110,19 @@ def simulate_session( for i_trial in range(ntrials): # Retrieve trial information stimulus_category_is_A = stimulus_category_is_A_seq[i_trial] - correct_action_cur = classA_correct_action if stimulus_category_is_A else classB_correct_action + correct_action_cur = ( + classA_correct_action + if stimulus_category_is_A + else classB_correct_action + ) if i_trial in support_trials or i_trial in catch_trials: # Supply a support image - image_ref_cur = self.support_imageA if stimulus_category_is_A else self.support_imageB + image_ref_cur = ( + self.support_imageA + if stimulus_category_is_A + else self.support_imageB + ) else: # Sample a test image without replacement @@ -123,7 +137,7 @@ def simulate_session( # Calculate feedback based on response correct = a == correct_action_cur - feedback = 1. if correct else -1. + feedback = 1.0 if correct else -1.0 # Deliver feedback to learner learner.give_feedback(feedback) @@ -140,7 +154,5 @@ def simulate_session( transformation_to_kn[transformation_cur][1] += 1 return GeneralizationSessionResult( - transformation_to_kn=transformation_to_kn, - kcatch=kcatch, - ncatch=ncatch + transformation_to_kn=transformation_to_kn, kcatch=kcatch, ncatch=ncatch ) diff --git a/hobj/benchmarks/make_model.py b/hobj/benchmarks/make_model.py index 0593021..e90caac 100644 --- a/hobj/benchmarks/make_model.py +++ b/hobj/benchmarks/make_model.py @@ -1,6 +1,7 @@ """ This module provides an alternative interface for instantiating a linear learning model. """ + from functools import lru_cache from typing import Literal @@ -18,24 +19,26 @@ def _get_calibration_image_ids() -> list[ImageId]: Returns the ImageIds of the warmup images that are used for calibrating the features of the linear learner. Caches the result to avoid redundant computation. """ - raise NotImplementedError + from hobj.data_loaders.images import load_imageset_meta_warmup + + images_df = load_imageset_meta_warmup() + return sorted(images_df["image_id"].tolist()) # %% def make_linear_learner_from_features( - features: np.ndarray, - image_ids: list[ImageId], - update_rule_name: Literal[ - 'Prototype', - 'Square', - 'Perceptron', - 'Hinge', - 'MAE', - 'Exponential', - 'CE', - 'REINFORCE' - ] = 'Square', - alpha: float = 1, + ref_to_features: dict[ImageId, np.ndarray], + update_rule_name: Literal[ + "Prototype", + "Square", + "Perceptron", + "Hinge", + "MAE", + "Exponential", + "CE", + "REINFORCE", + ] = "Square", + alpha: float = 1, ) -> LinearLearner: """ Instantiates a linear learning model from precomputed features. @@ -45,8 +48,9 @@ def make_linear_learner_from_features( :return: LinearLearner """ - ref_to_features = {ref: features[i] for i, ref in enumerate(image_ids)} - f_calibration = np.array([ref_to_features[ref] for ref in _get_calibration_image_ids()]) + f_calibration = np.array( + [ref_to_features[ref] for ref in _get_calibration_image_ids()] + ) mu_calibration = np.mean(f_calibration, axis=0) norms_calibration = np.linalg.norm(f_calibration - mu_calibration, axis=1) norm_cutoff = np.quantile(norms_calibration, 0.999) # Will clip the rest @@ -66,5 +70,5 @@ def make_linear_learner_from_features( representational_model=RepresentationalModel.from_precomputed_features( image_ref_to_features=ref_to_calibrated_features ), - update_rule=update_rule_name(alpha=alpha) + update_rule=update_rule_name(alpha=alpha), ) diff --git a/hobj/benchmarks/mut_highvar_benchmark.py b/hobj/benchmarks/mut_highvar_benchmark.py index 5068538..d600050 100644 --- a/hobj/benchmarks/mut_highvar_benchmark.py +++ b/hobj/benchmarks/mut_highvar_benchmark.py @@ -2,53 +2,66 @@ import numpy as np -from hobj.benchmarks.binary_classification.benchmark import LearningCurveBenchmark, LearningCurveBenchmarkConfig, TargetSubtaskData -from hobj.benchmarks.binary_classification.simulation import BinaryClassificationSubtask, BinaryClassificationSubtaskResult +from hobj.benchmarks.binary_classification.benchmark import ( + LearningCurveBenchmark, + LearningCurveBenchmarkConfig, + TargetSubtaskData, +) +from hobj.benchmarks.binary_classification.simulation import ( + BinaryClassificationSubtask, + BinaryClassificationSubtaskResult, +) from hobj.data_loaders.behavior import load_highvar_behavior -from hobj.data_loaders.images import MutatorHighVarImageset +from hobj.data_loaders.images import load_imageset_meta_highvar # %% class MutatorHighVarBenchmark(LearningCurveBenchmark): - def __init__(self): # Load data into format expected by benchmark - # Load imageset: - imageset = MutatorHighVarImageset() + # Load image manifest: + images_df = load_imageset_meta_highvar() # Load raw human session data for benchmark: sessions = load_highvar_behavior(remove_probe_trials=True) # Normalize data for benchmark: - sha256_to_category = { - ref.sha256: imageset.get_annotation(image_id=ref).category for ref in imageset.image_ids - } + image_id_to_category = dict( + zip(images_df["image_id"], images_df["category"], strict=True) + ) + category_to_image_ids = ( + images_df.groupby("category", sort=False)["image_id"] + .apply(lambda image_ids: sorted(image_ids.tolist())) + .to_dict() + ) subtask_name_to_results = {} subtask_name_to_subtask = {} # Iterate over worker sessions: - for session in sessions: - + for assignment_id, session in sessions.groupby("assignment_id", sort=False): categories = set() perf_seq: List[bool] = [] # Iterate over trials: - for i_trial, (reward, sha256) in enumerate(zip(session.reward_seq, session.stimulus_sha256_seq)): - categories.add(sha256_to_category[sha256]) - perf_seq.append(reward > 0) + session = session.sort_values("trial") + for reward, image_id in zip(session.perf, session.image_id): + categories.add(image_id_to_category[image_id]) + perf_seq.append(bool(reward)) # Infer subtask from the categories observed in the session: - assert len(categories) == 2, f"Expected two categories, but got {categories}" - subtask_name = ','.join(sorted(categories)) + assert ( + len(categories) == 2 + ), f"Expected two categories, but got {categories}" + subtask_name = ",".join(sorted(categories)) cat0, cat1 = sorted(categories) # Instantiate the subtask if it does not exist: if subtask_name not in subtask_name_to_subtask: subtask = BinaryClassificationSubtask( - classA=imageset.category_to_image_ids[cat0], - classB=imageset.category_to_image_ids[cat1], + classA=category_to_image_ids[cat0], + classB=category_to_image_ids[cat1], ntrials=100, replace=False, ) @@ -57,20 +70,21 @@ def __init__(self): subtask_name_to_results[subtask_name].append( BinaryClassificationSubtaskResult( - perf_seq = np.array(perf_seq), - worker_id = session.worker_id + perf_seq=np.array(perf_seq), worker_id=session.worker_id.iloc[0] ) ) # Cast as numpy for name in subtask_name_to_results: - subtask_name_to_results[name] = np.array(subtask_name_to_results[name]) # [session, trial] + subtask_name_to_results[name] = np.array( + subtask_name_to_results[name] + ) # [session, trial] subtask_name_to_data: Dict[str, TargetSubtaskData] = {} for name in subtask_name_to_results: subtask_name_to_data[name] = TargetSubtaskData( subtask=subtask_name_to_subtask[name], - results=subtask_name_to_results[name] + results=subtask_name_to_results[name], ) # Instantiate benchmark config object @@ -79,13 +93,13 @@ def __init__(self): num_simulations_per_subtask=500, num_bootstrap_samples=1000, bootstrap_by_worker=False, - ntrials = 100 + ntrials=100, ) - super().__init__( - config=config - ) + super().__init__(config=config) + -if __name__ == '__main__': +# %% +if __name__ == "__main__": experiment = MutatorHighVarBenchmark() print(sorted(experiment.config.subtask_name_to_data.keys())) diff --git a/hobj/benchmarks/mut_oneshot_benchmark.py b/hobj/benchmarks/mut_oneshot_benchmark.py index 71851d3..07b3345 100644 --- a/hobj/benchmarks/mut_oneshot_benchmark.py +++ b/hobj/benchmarks/mut_oneshot_benchmark.py @@ -1,124 +1,133 @@ import collections -# Coercing human data from typing import Dict, List -from hobj.benchmarks.generalization.benchmark import GeneralizationBenchmark, GeneralizationBenchmarkConfig, GeneralizationSessionResult +from hobj.benchmarks.generalization.benchmark import ( + GeneralizationBenchmark, + GeneralizationBenchmarkConfig, + GeneralizationSessionResult, +) from hobj.benchmarks.generalization.estimator import GeneralizationStatistics from hobj.benchmarks.generalization.simulator import GeneralizationSubtask from hobj.data_loaders.behavior import load_oneshot_behavior -from hobj.data_loaders.images import MutatorOneShotImageset +from hobj.data_loaders.images import load_imageset_meta_oneshot from hobj.types import ImageId + # %% -class MutatorOneshotBenchmark(GeneralizationBenchmark): +class MutatorOneshotBenchmark(GeneralizationBenchmark): subtask_names = [ - 'MutatorB2000_2292,MutatorB2000_2444', - 'MutatorB2000_138,MutatorB2000_2344', - 'MutatorB2000_1251,MutatorB2000_953', - 'MutatorB2000_3043,MutatorB2000_694', - 'MutatorB2000_3496,MutatorB2000_496', - 'MutatorB2000_1219,MutatorB2000_296', - 'MutatorB2000_1825,MutatorB2000_2757', - 'MutatorB2000_3077,MutatorB2000_4703', - 'MutatorB2000_270,MutatorB2000_3615', - 'MutatorB2000_3066,MutatorB2000_3585', - 'MutatorB2000_2139,MutatorB2000_746', - 'MutatorB2000_116,MutatorB2000_2365', - 'MutatorB2000_2130,MutatorB2000_4628', - 'MutatorB2000_462,MutatorB2000_926', - 'MutatorB2000_2304,MutatorB2000_3733', - 'MutatorB2000_1363,MutatorB2000_3278', - 'MutatorB2000_4049,MutatorB2000_663', - 'MutatorB2000_2722,MutatorB2000_3527', - 'MutatorB2000_2832,MutatorB2000_801', - 'MutatorB2000_1258,MutatorB2000_3123', - 'MutatorB2000_1865,MutatorB2000_613', - 'MutatorB2000_1164,MutatorB2000_2106', - 'MutatorB2000_1229,MutatorB2000_1280', - 'MutatorB2000_1767,MutatorB2000_2122', - 'MutatorB2000_2198,MutatorB2000_701', - 'MutatorB2000_3636,MutatorB2000_4305', - 'MutatorB2000_3035,MutatorB2000_46', - 'MutatorB2000_3601,MutatorB2000_4792', - 'MutatorB2000_2092,MutatorB2000_288', - 'MutatorB2000_1424,MutatorB2000_2314', - 'MutatorB2000_3308,MutatorB2000_3525', - 'MutatorB2000_2909,MutatorB2000_4256' + "MutatorOneshotObject00,MutatorOneshotObject43", + "MutatorOneshotObject01,MutatorOneshotObject37", + "MutatorOneshotObject02,MutatorOneshotObject36", + "MutatorOneshotObject03,MutatorOneshotObject55", + "MutatorOneshotObject04,MutatorOneshotObject27", + "MutatorOneshotObject05,MutatorOneshotObject17", + "MutatorOneshotObject06,MutatorOneshotObject14", + "MutatorOneshotObject07,MutatorOneshotObject50", + "MutatorOneshotObject08,MutatorOneshotObject26", + "MutatorOneshotObject09,MutatorOneshotObject58", + "MutatorOneshotObject10,MutatorOneshotObject44", + "MutatorOneshotObject11,MutatorOneshotObject32", + "MutatorOneshotObject12,MutatorOneshotObject31", + "MutatorOneshotObject13,MutatorOneshotObject41", + "MutatorOneshotObject15,MutatorOneshotObject19", + "MutatorOneshotObject16,MutatorOneshotObject28", + "MutatorOneshotObject18,MutatorOneshotObject21", + "MutatorOneshotObject20,MutatorOneshotObject47", + "MutatorOneshotObject22,MutatorOneshotObject48", + "MutatorOneshotObject23,MutatorOneshotObject35", + "MutatorOneshotObject24,MutatorOneshotObject29", + "MutatorOneshotObject25,MutatorOneshotObject40", + "MutatorOneshotObject30,MutatorOneshotObject61", + "MutatorOneshotObject33,MutatorOneshotObject38", + "MutatorOneshotObject34,MutatorOneshotObject57", + "MutatorOneshotObject39,MutatorOneshotObject52", + "MutatorOneshotObject42,MutatorOneshotObject59", + "MutatorOneshotObject45,MutatorOneshotObject53", + "MutatorOneshotObject46,MutatorOneshotObject62", + "MutatorOneshotObject49,MutatorOneshotObject51", + "MutatorOneshotObject54,MutatorOneshotObject63", + "MutatorOneshotObject56,MutatorOneshotObject60", ] transformation_ids = [ - 'backgrounds | 0.1', - 'backgrounds | 0.215443', - 'backgrounds | 0.464159', - 'backgrounds | 1.0', - 'blur | 0.007812', - 'blur | 0.015625', - 'blur | 0.03125', - 'blur | 0.0625', - 'contrast | -0.4', - 'contrast | -0.8', - 'contrast | 0.4', - 'contrast | 0.8', - 'delpixels | 0.25', - 'delpixels | 0.5', - 'delpixels | 0.75', - 'delpixels | 0.95', - 'inplanerotation | 135.0', - 'inplanerotation | 180.0', - 'inplanerotation | 45.0', - 'inplanerotation | 90.0', - 'inplanetranslation | 0.125', - 'inplanetranslation | 0.25', - 'inplanetranslation | 0.5', - 'inplanetranslation | 0.75', - 'noise | 0.125', - 'noise | 0.25', - 'noise | 0.375', - 'noise | 0.5', - 'outplanerotation | 135.0', - 'outplanerotation | 180.0', - 'outplanerotation | 45.0', - 'outplanerotation | 90.0', - 'scale | 0.125', - 'scale | 0.25', - 'scale | 0.5', - 'scale | 1.5' + "backgrounds | 0.1", + "backgrounds | 0.215443", + "backgrounds | 0.464159", + "backgrounds | 1.0", + "blur | 0.007812", + "blur | 0.015625", + "blur | 0.03125", + "blur | 0.0625", + "contrast | -0.4", + "contrast | -0.8", + "contrast | 0.4", + "contrast | 0.8", + "delpixels | 0.25", + "delpixels | 0.5", + "delpixels | 0.75", + "delpixels | 0.95", + "inplanerotation | 135.0", + "inplanerotation | 180.0", + "inplanerotation | 45.0", + "inplanerotation | 90.0", + "inplanetranslation | 0.125", + "inplanetranslation | 0.25", + "inplanetranslation | 0.5", + "inplanetranslation | 0.75", + "noise | 0.125", + "noise | 0.25", + "noise | 0.375", + "noise | 0.5", + "outplanerotation | 135.0", + "outplanerotation | 180.0", + "outplanerotation | 45.0", + "outplanerotation | 90.0", + "scale | 0.125", + "scale | 0.25", + "scale | 0.5", + "scale | 1.5", ] def __init__(self): support_trials = {0, 1, 2, 3, 4, 5, 6, 7, 8} catch_trials = {9, 14, 19} - # Load images - imageset = MutatorOneShotImageset() + # Load image manifest + images_df = load_imageset_meta_oneshot() + image_id_to_row = images_df.set_index("image_id") # Map image refs to transformation ids - image_ref_to_transformation_id = {} + image_ref_to_transformation_id: Dict[ImageId, str] = {} cat_to_support_image: Dict[str, ImageId] = {} cat_to_test_images: Dict[str, List[ImageId]] = {} - for image_id in imageset.image_ids: - annotation = imageset.get_annotation(image_id=image_id) - transformation_id = f"{annotation.transformation} | {annotation.transformation_level}" + for row in images_df.to_dict(orient="records"): + image_id = row["image_id"] + transformation_id = ( + f"{row['transformation']} | {row['transformation_level']}" + ) image_ref_to_transformation_id[image_id] = transformation_id - if annotation.transformation == 'original': - if annotation.category not in cat_to_support_image: - cat_to_support_image[annotation.category] = image_id + if row["transformation"] == "original": + if row["category"] not in cat_to_support_image: + cat_to_support_image[row["category"]] = image_id else: - raise ValueError(f"Multiple support images for category {annotation.category}") + raise ValueError( + f"Multiple support images for category {row['category']}" + ) else: - if annotation.category not in cat_to_test_images: - cat_to_test_images[annotation.category] = [] + if row["category"] not in cat_to_test_images: + cat_to_test_images[row["category"]] = [] - cat_to_test_images[annotation.category].append(image_id) + cat_to_test_images[row["category"]].append(image_id) # Assemble subtask simulators subtasks = [] for subtask_name in self.subtask_names: - catA, catB = sorted(subtask_name.split(',')) + catA, catB = sorted(subtask_name.split(",")) support_imageA = cat_to_support_image[catA] support_imageB = cat_to_support_image[catB] @@ -131,41 +140,39 @@ def __init__(self): support_imageB=support_imageB, test_imagesA=test_imagesA, test_imagesB=test_imagesB, - image_ref_to_transformation=image_ref_to_transformation_id + image_ref_to_transformation=image_ref_to_transformation_id, ) subtasks.append(subtask) # Package human data into format expected by benchmark - oneshot_sessions = load_oneshot_behavior() + oneshot_df = load_oneshot_behavior() results = [] - for session in oneshot_sessions: - # Parse raw data by worker + for session, session_df in oneshot_df.groupby( + ["assignment_id", "slot"], sort=False + ): + session_df = session_df.sort_values("trial") transformation_to_kn = collections.defaultdict(lambda: [0, 0]) kcatch = 0 ncatch = 0 - observed_categories = set() + observed_categories = set(session_df["subtask"].iloc[0].split(",")) - for i_trial, sha in enumerate(session.stimulus_sha256_seq): - image_id = sha - annotation = imageset.get_annotation(image_id=image_id) - - # Add stimulus category to observed categories - observed_categories.add(annotation.category) - - # Calculate performance - perf = session.reward_seq[i_trial] > 0 + for _, row in session_df.iterrows(): + i_trial = int(row["trial"]) + image_id = row["image_id"] + annotation = image_id_to_row.loc[image_id] + perf = bool(row["perf"]) # Record performance in relevant slot if i_trial in support_trials: - assert annotation.transformation == 'original' + assert annotation["transformation"] == "original" elif i_trial in catch_trials: - assert annotation.transformation == 'original' + assert annotation["transformation"] == "original" kcatch += perf ncatch += 1 else: - assert annotation.transformation != 'original' + assert annotation["transformation"] != "original" transformation_id = image_ref_to_transformation_id[image_id] # Keep only benchmarked transformations @@ -175,7 +182,7 @@ def __init__(self): # Infer subtask name from observed categories assert len(observed_categories) == 2 - subtask_name = ','.join(sorted(observed_categories)) + subtask_name = ",".join(sorted(observed_categories)) if subtask_name not in self.subtask_names: raise ValueError(f"Unexpected subtask name: {subtask_name}") @@ -184,7 +191,7 @@ def __init__(self): transformation_to_kn=transformation_to_kn, kcatch=kcatch, ncatch=ncatch, - worker_id=session.worker_id + worker_id=session_df["worker_id"].iloc[0], ) results.append(result) @@ -201,14 +208,24 @@ def __init__(self): @property def target_statistics(self) -> GeneralizationStatistics: - - gen_statistics: GeneralizationStatistics = self._generalization_statistics + gen_statistics: GeneralizationStatistics = self._generalization_statistics return gen_statistics.assign_coords( - transformation_type=(['transformation'], [transformation.split(' | ')[0] for transformation in gen_statistics.transformation.values]), - transformation_level=(['transformation'], [float(transformation.split(' | ')[1]) for transformation in gen_statistics.transformation.values]) + transformation_type=( + ["transformation"], + [ + transformation.split(" | ")[0] + for transformation in gen_statistics.transformation.values + ], + ), + transformation_level=( + ["transformation"], + [ + float(transformation.split(" | ")[1]) + for transformation in gen_statistics.transformation.values + ], + ), ) -if __name__ == '__main__': +if __name__ == "__main__": benchmark = MutatorOneshotBenchmark() - diff --git a/hobj/config.py b/hobj/config.py deleted file mode 100644 index 07bc6e0..0000000 --- a/hobj/config.py +++ /dev/null @@ -1,3 +0,0 @@ -from pathlib import Path - -cachedir: Path = Path.home() / 'hobj_cache' diff --git a/hobj/data_loaders/behavior.py b/hobj/data_loaders/behavior.py index 3452ce7..c13641e 100644 --- a/hobj/data_loaders/behavior.py +++ b/hobj/data_loaders/behavior.py @@ -1,143 +1,120 @@ -import datetime -import json from pathlib import Path -from typing import List, Literal -import pydantic +import pandas as pd -from hobj.utils.file_io import download_json +from typing import Literal -__all__ = ['load_highvar_behavior', 'load_oneshot_behavior'] - - -class HumanLearningSession(pydantic.BaseModel): - """ - A representation of the "raw" data collected from a human learning session. - """ - model_config = dict( - frozen=True - ) - - worker_id: str = pydantic.Field( - description='The anonymized worker ID of the participant.' - ) - - stimulus_sha256_seq: List[str] = pydantic.Field( - description='The SHA256 hash of the image (in np.uint8 format and RGBA mode) shown to the participant.', - ) - - stimulus_duration_msec_seq: List[int] = pydantic.Field( - description='The duration of the stimulus presentation in milliseconds.', - ) - - action_seq: List[Literal[0, 1, None]] = pydantic.Field(description='The action taken by the participant. 0 maps to "F" (left) and 1 maps to "J" (right). None maps to no action taken.') - reward_seq: List[Literal[-1, 1]] = pydantic.Field(description='The reward received by the participant following their action.') - timestamp_start_seq: List[datetime.datetime] = pydantic.Field(description='The timestamp of the start of the trial.') - - @pydantic.field_serializer('timestamp_start_seq') - def serialize_timestamp_start(self, v: List[datetime.datetime], _info) -> List[float]: - # Serializes datetime objects into Unix timestamps (seconds) - return [entry.timestamp() for entry in v] - - @pydantic.model_validator(mode='after') - def validate_lengths(self) -> 'HumanLearningSession': - stimulus_len = len(self.stimulus_sha256_seq) - duration_len = len(self.stimulus_duration_msec_seq) - action_len = len(self.action_seq) - reward_len = len(self.reward_seq) - timestamp_len = len(self.timestamp_start_seq) - - if not stimulus_len == duration_len == action_len == reward_len == timestamp_len: - raise ValueError(f'All lists must be of the same length. Got: {stimulus_len, duration_len, action_len, reward_len, timestamp_len}') - - return self # %% -def _load_learning_sessions( - dataset_url: str, - cache_filename: str, - cachedir: Path | None = None, - redownload: bool = False, -) -> List[HumanLearningSession]: - repo_root = Path(__file__).resolve().parents[2] - cache_root = (cachedir if cachedir is not None else repo_root / 'data').resolve() - behavior_dir = cache_root / 'behavior' - behavior_dir.mkdir(parents=True, exist_ok=True) - dataset_path = behavior_dir / cache_filename - - if redownload or not dataset_path.exists(): - json_data = download_json(dataset_url) - dataset_path.write_text(json.dumps(json_data, indent=2)) - else: - json_data = json.loads(dataset_path.read_text()) - - class LearningSessionDataset(pydantic.BaseModel): - sessions: List[HumanLearningSession] +def load_human_behavior( + experiment: Literal["highvar", "oneshot"] = "highvar", +) -> pd.DataFrame: + if experiment not in {"highvar", "oneshot"}: + raise ValueError( + f"Invalid experiment name: {experiment}. Provide either 'highvar' or 'oneshot'." + ) - learning_dataset = LearningSessionDataset(**json_data) - return learning_dataset.sessions + if experiment == "highvar": + return load_highvar_behavior() + else: + return load_oneshot_behavior() # %% Data loaders def load_highvar_behavior( - remove_probe_trials: bool = True, - cachedir: Path | None = None, - redownload: bool = False, -) -> List[HumanLearningSession]: - """ - Load the "raw" human learning data from Experiment 1 of Lee and DiCarlo 2023. - :return: + remove_probe_trials: bool = True, + cachedir: Path | None = None, +) -> pd.DataFrame: + """Load trial-level human learning data from Experiment 1. + + Args: + remove_probe_trials: Whether to exclude probe trials and renumber the + remaining trial index within each assignment. + cachedir: Optional root directory containing the packaged ``data`` tree. + + Returns: + A DataFrame containing the high-variance behavior dataset with + ``stimulus_id`` normalized to ``image_id``. """ + repo_root = Path(__file__).resolve().parents[2] + cache_root = (cachedir if cachedir is not None else repo_root / "data").resolve() + dataset_path = cache_root / "behavior" / "human-behavior-highvar-subtasks.csv" + if not dataset_path.exists(): + raise FileNotFoundError( + "Expected cached highvar behavior CSV to already exist at:\n" + f" - {dataset_path}" + ) - sessions = _load_learning_sessions( - dataset_url='https://hlbdatasets.s3.us-east-1.amazonaws.com/behavior/mutator-highvar-human-learning-data.json', - cache_filename='mutator-highvar-human-learning-data.json', - cachedir=cachedir, - redownload=redownload, - ) - - if not remove_probe_trials: - return sessions - - def filter(vals: list): - probe_trials = {25, 51, 77, 103} - return [vals[i] for i in range(len(vals)) if i not in probe_trials] - - filtered_sessions = [] - for session in sessions: - # Filter out indices in probe_trials - filtered_session = HumanLearningSession( - worker_id=session.worker_id, - stimulus_sha256_seq=filter(session.stimulus_sha256_seq), - stimulus_duration_msec_seq=filter(session.stimulus_duration_msec_seq), - action_seq=filter(session.action_seq), - reward_seq=filter(session.reward_seq), - timestamp_start_seq=filter(session.timestamp_start_seq) + df = pd.read_csv(dataset_path) + + required_columns = { + "trial", + "assignment_id", + "worker_id", + "subtask", + "image_id", + "trial_type", + "stimulus_duration_msec", + "reaction_time_msec", + "timed_out", + "perf", + "timestamp_start", + } + missing_columns = required_columns - set(df.columns) + if missing_columns: + raise ValueError( + f"Highvar behavior CSV missing required columns: {sorted(missing_columns)}" ) - filtered_sessions.append(filtered_session) + if remove_probe_trials: + df = df.loc[df["trial_type"] != "probe"].copy() + df = df.sort_values(["assignment_id", "trial"]).copy() + df["trial"] = df.groupby("assignment_id").cumcount() - return filtered_sessions + return df def load_oneshot_behavior( - cachedir: Path | None = None, - redownload: bool = False, -) -> List[HumanLearningSession]: - """ - Load the "raw" human learning data from Experiment 2 of Lee and DiCarlo 2023. - :return: - """ + cachedir: Path | None = None, +) -> pd.DataFrame: + """Load trial-level human learning data from Experiment 2. - sessions = _load_learning_sessions( - dataset_url='https://hlbdatasets.s3.us-east-1.amazonaws.com/behavior/mutator-oneshot-human-learning-data.json', - cache_filename='mutator-oneshot-human-learning-data.json', - cachedir=cachedir, - redownload=redownload - ) + Args: + cachedir: Optional root directory containing the packaged ``data`` tree. - return sessions + Returns: + A DataFrame containing the one-shot behavior dataset with + ``stimulus_id`` normalized to ``image_id``. + """ + repo_root = Path(__file__).resolve().parents[2] + cache_root = (cachedir if cachedir is not None else repo_root / "data").resolve() + dataset_path = cache_root / "behavior" / "human-behavior-oneshot-subtasks.csv" + if not dataset_path.exists(): + raise FileNotFoundError( + "Expected cached oneshot behavior CSV to already exist at:\n" + f" - {dataset_path}" + ) + df = pd.read_csv(dataset_path) + + required_columns = { + "trial", + "assignment_id", + "slot", + "worker_id", + "subtask", + "image_id", + "trial_type", + "stimulus_duration_msec", + "reaction_time_msec", + "timed_out", + "perf", + "timestamp_start", + } + missing_columns = required_columns - set(df.columns) + if missing_columns: + raise ValueError( + f"Oneshot behavior CSV missing required columns: {sorted(missing_columns)}" + ) -if __name__ == '__main__': - sessions = load_highvar_behavior() + return df diff --git a/hobj/data_loaders/download.py b/hobj/data_loaders/download.py new file mode 100644 index 0000000..90a453b --- /dev/null +++ b/hobj/data_loaders/download.py @@ -0,0 +1,159 @@ +"""Download packaged HOBJ datasets into the repository ``data`` directory.""" + +from __future__ import annotations + +import argparse +import tarfile +from pathlib import Path +from urllib.parse import urlparse + +import requests +from tqdm import tqdm + + +DATA_ARCHIVE_URL = ( + "https://hlbdatasets.s3.us-east-1.amazonaws.com/" + "lee-dicarlo-2023-learning-data.tar.gz" +) +EXPECTED_DATA_PATHS = ( + Path("data/meta-MutatorHighVarImageset.csv"), + Path("data/meta-MutatorOneShotImageset.csv"), + Path("data/meta-MutatorWarmupImageset.csv"), + Path("data/meta-CatchImageset.csv"), + Path("data/behavior/human-behavior-highvar-subtasks.csv"), + Path("data/behavior/human-behavior-oneshot-subtasks.csv"), +) +_DOWNLOAD_CHUNK_SIZE_BYTES = 1024 * 1024 + + +def _get_repo_root() -> Path: + """Return the repository root for this package.""" + return Path(__file__).resolve().parents[2] + + +def _get_missing_expected_paths(repo_root: Path) -> list[Path]: + """Return expected packaged data paths that are currently missing.""" + return [ + relpath for relpath in EXPECTED_DATA_PATHS if not (repo_root / relpath).exists() + ] + + +def _derive_archive_path(repo_root: Path, url: str) -> Path: + """Return the on-disk path for the downloaded archive.""" + archive_name = Path(urlparse(url).path).name + if not archive_name: + raise ValueError(f"Could not derive archive filename from URL: {url}") + return repo_root / archive_name + + +def _download_archive(url: str, archive_path: Path) -> None: + """Download an archive to disk atomically.""" + archive_path.parent.mkdir(parents=True, exist_ok=True) + temp_path = archive_path.with_suffix(f"{archive_path.suffix}.part") + + with requests.get(url, stream=True, timeout=(10, 300)) as response: + response.raise_for_status() + total_bytes = int(response.headers.get("content-length", 0)) + with temp_path.open("wb") as handle: + with tqdm( + total=total_bytes or None, + unit="B", + unit_scale=True, + unit_divisor=1024, + desc=f"Downloading {archive_path.name}", + ) as progress_bar: + for chunk in response.iter_content( + chunk_size=_DOWNLOAD_CHUNK_SIZE_BYTES + ): + if chunk: + handle.write(chunk) + progress_bar.update(len(chunk)) + + temp_path.replace(archive_path) + + +def _safe_extract_tarball(archive_path: Path, destination: Path) -> None: + """Extract a tarball while preventing path traversal.""" + destination = destination.resolve() + + with tarfile.open(archive_path, mode="r:gz") as tar: + for member in tar.getmembers(): + member_path = (destination / member.name).resolve() + member_path.relative_to(destination) + tar.extractall(destination) + + +def download_data( + *, + url: str = DATA_ARCHIVE_URL, + repo_root: Path | None = None, + force_download: bool = False, +) -> Path: + """Download and extract the packaged learning dataset into the repo root. + + The function is idempotent: if the expected packaged files already exist + under ``data/``, it returns immediately without downloading or extracting. + Otherwise it downloads the archive if needed and extracts it into the + repository root. + + Args: + url: Archive URL containing the packaged ``data`` tree. + repo_root: Repository root where the archive should be stored and + extracted. + force_download: Whether to redownload the archive even if it is already + present on disk. + + Returns: + The absolute path to the extracted ``data`` directory. + + Raises: + requests.HTTPError: If the archive download fails. + tarfile.TarError: If the archive cannot be unpacked. + ValueError: If the archive path is invalid or extraction would escape + the repository root. + FileNotFoundError: If extraction completes but the expected dataset + files are still missing. + """ + resolved_repo_root = ( + repo_root if repo_root is not None else _get_repo_root() + ).resolve() + data_root = resolved_repo_root / "data" + missing_paths = _get_missing_expected_paths(resolved_repo_root) + if not missing_paths: + return data_root + + archive_path = _derive_archive_path(resolved_repo_root, url) + if force_download or not archive_path.exists(): + _download_archive(url=url, archive_path=archive_path) + + _safe_extract_tarball(archive_path=archive_path, destination=resolved_repo_root) + + missing_paths = _get_missing_expected_paths(resolved_repo_root) + if missing_paths: + missing_str = "\n".join(f" - {path}" for path in missing_paths) + raise FileNotFoundError( + "Packaged dataset archive was extracted, but expected files are still " + f"missing:\n{missing_str}" + ) + + return data_root + + +def main() -> None: + """Download packaged dataset files into the repository data directory.""" + parser = argparse.ArgumentParser( + description="Download and extract the packaged HOBJ dataset archive." + ) + parser.add_argument( + "--force-download", + action="store_true", + help="Redownload the archive even if it already exists locally.", + ) + args = parser.parse_args() + + data_root = download_data(force_download=args.force_download) + print(data_root) + + +if __name__ == "__main__": + main() diff --git a/hobj/data_loaders/images.py b/hobj/data_loaders/images.py new file mode 100644 index 0000000..8f6b1fa --- /dev/null +++ b/hobj/data_loaders/images.py @@ -0,0 +1,145 @@ +"""Load packaged image manifests and images.""" + +from pathlib import Path + +import pandas as pd +from hobj.types import ImageId +from PIL import Image +from functools import lru_cache + + +@lru_cache(maxsize=1) +def _image_id_to_local_path_table() -> dict[ImageId, Path]: + """Build a mapping from image_id to absolute local path for all packaged images.""" + repo_root = Path(__file__).resolve().parents[2] + cache_root = repo_root / "data" + manifest_paths = list(cache_root.glob("meta-*.csv")) + table = {} + for manifest_path in manifest_paths: + manifest_df = pd.read_csv(manifest_path) + for _, row in manifest_df.iterrows(): + image_id = row["image_id"] + relpath = row["relpath"] + abs_path = cache_root / relpath + table[image_id] = abs_path + return table + + +def load_image(image_id: ImageId) -> Image.Image: + """Load an image by ``image_id`` from the packaged dataset.""" + path = _image_id_to_local_path_table().get(image_id) + if path is None: + raise ValueError(f"Image ID not found in any manifest: {image_id}") + if not path.exists(): + raise FileNotFoundError(f"Expected image file to already exist at: {path}") + return Image.open(path) + + +def _load_image_manifest( + *, + dataset_name: str, + required_columns: set[str], + cachedir: Path | None = None, +) -> pd.DataFrame: + """Load a packaged image manifest after validating packaged image files. + + Args: + dataset_name: Name of the packaged manifest. + required_columns: Columns that must exist in the manifest. + cachedir: Optional root directory containing the packaged ``data`` tree. + + Returns: + A copy of the manifest as a DataFrame. + + Raises: + ValueError: If required columns are missing. + FileNotFoundError: If the packaged manifest or images are missing. + """ + repo_root = Path(__file__).resolve().parents[2] + cache_root = (cachedir if cachedir is not None else repo_root / "data").resolve() + manifest_path = cache_root / f"meta-{dataset_name}.csv" + + if not manifest_path.exists(): + raise FileNotFoundError( + f"Expected cached image manifest to already exist at: {manifest_path}" + ) + + manifest_df = pd.read_csv(manifest_path) + missing_columns = required_columns - set(manifest_df.columns) + if missing_columns: + raise ValueError( + f"{dataset_name} manifest.csv missing required columns: " + f"{sorted(missing_columns)}" + ) + + manifest_df = manifest_df.copy() + missing_paths = manifest_df.loc[ + ~manifest_df["relpath"].map(lambda p: Path.exists(cache_root / p)), "relpath" + ] + if not missing_paths.empty: + raise FileNotFoundError( + "Expected packaged images to already exist under:\n" + f"First missing path: {missing_paths.iloc[0]}" + ) + + return manifest_df + + +def load_imageset_meta_highvar( + cachedir: Path | None = None, +) -> pd.DataFrame: + """Load the high-variance image manifest.""" + manifest_df = _load_image_manifest( + dataset_name="MutatorHighVarImageset", + required_columns={"image_id", "category", "sha256", "relpath"}, + cachedir=cachedir, + ) + return manifest_df.sort_values("image_id").reset_index(drop=True) + + +def load_imageset_meta_oneshot( + cachedir: Path | None = None, +) -> pd.DataFrame: + """Load the one-shot image manifest.""" + manifest_df = _load_image_manifest( + dataset_name="MutatorOneShotImageset", + required_columns={ + "image_id", + "category", + "transformation", + "transformation_level", + "base_image_id", + "sha256", + "relpath", + }, + cachedir=cachedir, + ) + return manifest_df.sort_values("image_id").reset_index(drop=True) + + +def load_imageset_meta_warmup( + cachedir: Path | None = None, +) -> pd.DataFrame: + """Load the warmup image manifest.""" + manifest_df = _load_image_manifest( + dataset_name="MutatorWarmupImageset", + required_columns={"image_id", "category", "sha256", "relpath"}, + cachedir=cachedir, + ) + return manifest_df.sort_values("image_id").reset_index(drop=True) + + +def load_imageset_meta_catch( + cachedir: Path | None = None, +) -> pd.DataFrame: + """Load the probe image manifest.""" + manifest_df = _load_image_manifest( + dataset_name="CatchImageset", + required_columns={"image_id", "sha256", "relpath"}, + cachedir=cachedir, + ) + return manifest_df.sort_values("image_id").reset_index(drop=True) + + +if __name__ == "__main__": + df = load_imageset_meta_oneshot() diff --git a/hobj/data_loaders/images/__init__.py b/hobj/data_loaders/images/__init__.py deleted file mode 100644 index 1e11a53..0000000 --- a/hobj/data_loaders/images/__init__.py +++ /dev/null @@ -1,5 +0,0 @@ -from hobj.data_loaders.images.highvar import MutatorHighVarImageset -from hobj.data_loaders.images.oneshot import MutatorOneShotImageset -from hobj.data_loaders.images.probe import ProbeImageset -from hobj.data_loaders.images.warmup import MutatorWarmupImageset - diff --git a/hobj/data_loaders/images/highvar.py b/hobj/data_loaders/images/highvar.py deleted file mode 100644 index ea98517..0000000 --- a/hobj/data_loaders/images/highvar.py +++ /dev/null @@ -1,47 +0,0 @@ -from pathlib import Path -import pydantic - -from hobj.data_loaders.images.template import Imageset - -from hobj.types import ImageId - -# %% - -class MutatorHighVarAnnotation(pydantic.BaseModel): - category: str = pydantic.Field( - examples=[ - 'MutatorB2000_4872', - 'MutatorB2000_419', - ], - pattern=r'^MutatorB2000_\d+$' - ) - - -class MutatorHighVarImageset(Imageset[MutatorHighVarAnnotation]): - manifest_url = 'https://hlbdatasets.s3.us-east-1.amazonaws.com/imagesets/mutator-highvar/mutator-highvar-manifest.json' - zipped_images_url = 'https://hlbdatasets.s3.us-east-1.amazonaws.com/imagesets/mutator-highvar/MutatorB2000_Subset128_FullVar_Train.zip' - annotation_schema = MutatorHighVarAnnotation - - def __init__(self, cachedir: Path | None = None, redownload: bool = False): - super().__init__(cachedir=cachedir, redownload=redownload) - - self._category_to_image_ids: dict[str, list[ImageId]] = {} - - for ref in self.image_ids: - annotation = self.get_annotation(image_id=ref) - category = annotation.category - if category not in self._category_to_image_ids: - self._category_to_image_ids[category] = [] - self._category_to_image_ids[category].append(ref) - - for category in self._category_to_image_ids: - self._category_to_image_ids[category] = sorted(self._category_to_image_ids[category]) - - @property - def category_to_image_ids(self) -> dict[str, list[ImageId]]: - return self._category_to_image_ids - - -if __name__ == '__main__': - - imageset = MutatorHighVarImageset() diff --git a/hobj/data_loaders/images/oneshot.py b/hobj/data_loaders/images/oneshot.py deleted file mode 100644 index 15c58fd..0000000 --- a/hobj/data_loaders/images/oneshot.py +++ /dev/null @@ -1,56 +0,0 @@ -from pathlib import Path -from typing import Literal - -import pydantic - -from hobj.data_loaders.images.template import Imageset - - -class MutatorOneShotAnnotation(pydantic.BaseModel): - category: str = pydantic.Field( - examples=[ - 'MutatorB2000_2444', - 'MutatorB2000_288', - ], - pattern=r'^MutatorB2000_\d+$', - description='The name for the object model associated with this image.' - ) - - transformation: Literal[ - 'combinednat', - 'blur', - 'inplanetranslation', - 'scale', - 'outplanerotation', - 'noise', - 'backgrounds', - 'inplanerotation', - 'delpixels', - 'contrast', - 'original' - ] = pydantic.Field(description = 'The type of transformation applied to the image. "original" indicates no transformation.') - - transformation_level: float = pydantic.Field( - description='The extent of transformation applied to the image. The interpretation of this number varies by transformation.' - ) - - base_image_id: str = pydantic.Field( - description = 'An image ID for the "original" image associated with this one.', - examples = [ - 'MutatorB2000_2444_rx0.00000_ry0.00000_rz0.00000.png', - 'MutatorB2000_4792_rx0.00000_ry0.00000_rz0.00000.png' - ] - ) - - -class MutatorOneShotImageset(Imageset[MutatorOneShotAnnotation]): - manifest_url = 'https://hlbdatasets.s3.us-east-1.amazonaws.com/imagesets/mutator-oneshot/mutator-oneshot-manifest.json' - zipped_images_url = 'https://hlbdatasets.s3.us-east-1.amazonaws.com/imagesets/mutator-oneshot/MutatorB2000_Oneshot64.zip' - annotation_schema = MutatorOneShotAnnotation - - def __init__(self, cachedir: Path | None = None, redownload: bool = False): - super().__init__(cachedir=cachedir, redownload=redownload) - - -if __name__ == '__main__': - imageset = MutatorOneShotImageset() diff --git a/hobj/data_loaders/images/probe.py b/hobj/data_loaders/images/probe.py deleted file mode 100644 index 473ce35..0000000 --- a/hobj/data_loaders/images/probe.py +++ /dev/null @@ -1,24 +0,0 @@ - -from typing import Literal - -import pydantic - -from hobj.data_loaders.images.template import Imageset - - -class ProbeAnnotation(pydantic.BaseModel): - color: Literal['blue', 'orange'] - text: Literal['press right', 'press left'] - - -class ProbeImageset(Imageset[ProbeAnnotation]): - """ - An imageset consisting of two images: a - """ - manifest_url = 'https://hlbdatasets.s3.us-east-1.amazonaws.com/imagesets/probe-images/probe-images-manifest.json' - zipped_images_url = 'https://hlbdatasets.s3.us-east-1.amazonaws.com/imagesets/probe-images/probe-images.zip' - annotation_schema = ProbeAnnotation - -# %% -if __name__ == '__main__': - imageset = ProbeImageset() diff --git a/hobj/data_loaders/images/template.py b/hobj/data_loaders/images/template.py deleted file mode 100644 index 51e527e..0000000 --- a/hobj/data_loaders/images/template.py +++ /dev/null @@ -1,165 +0,0 @@ -import json -from abc import ABC -from pathlib import Path -from typing import Any, Dict, Generic, List, TypeVar - -import PIL.Image -import pydantic - -from hobj.types import ImageId -from hobj.utils.file_io import download_file, download_json, unzip_file -from hobj.utils.hash import hash_image - - -# %% -class ImageManifestEntry(pydantic.BaseModel, ABC): - sha256: str = pydantic.Field(pattern=r'^[a-f0-9]{64}$') - relpath: Path = pydantic.Field( - description='The relative path to the image file inside of the unzipped imageset directory.' - ) - annotation: Any = pydantic.Field( - description='Arbitrary annotation data for the image, in a JSON-valid format.' - ) - - -class ImageManifest(pydantic.BaseModel): - entries: Dict[ImageId, ImageManifestEntry] = pydantic.Field( - description='A mapping from a unique image ID to image manifest entries.' - ) - - -# This is a type variable for ImageManifestEntry.annotation: -IA = TypeVar('IA') - - -class Imageset(Generic[IA], ABC): - """ - Imagesets are a combination of: - - Images - - Annotations on those images - """ - - manifest_url: str - zipped_images_url: str - annotation_schema: IA - - def __init__( - self, - cachedir: Path | None = None, - redownload=False, - ): - """ - Download and materialize the imageset into a local cache directory. - """ - - repo_root = Path(__file__).resolve().parents[3] - self.cachedir = (cachedir if cachedir is not None else repo_root / 'data').resolve() - self.cachedir.mkdir(parents=True, exist_ok=True) - - self._dataset_dir = self.cachedir / self.__class__.__name__ - self._dataset_dir.mkdir(parents=True, exist_ok=True) - self._images_dir = self._dataset_dir / 'images' - - manifest_data = self._load_manifest_json(redownload=redownload) - image_manifest = ImageManifest(**manifest_data) - self._manifest = image_manifest - self._ensure_images_present(manifest=image_manifest, redownload=redownload) - - self._image_id_to_annotation: Dict[ImageId, IA] = {} - self._image_id_to_sha256: Dict[ImageId, str] = {} - self._image_id_to_relpath: Dict[ImageId, Path] = {} - self._image_ids: List[ImageId] = [] - - for image_id, entry in image_manifest.entries.items(): - self._image_ids.append(image_id) - self._image_id_to_sha256[image_id] = entry.sha256 - self._image_id_to_relpath[image_id] = entry.relpath - self._image_id_to_annotation[image_id] = self.annotation_schema(**entry.annotation) - - def _load_manifest_json(self, redownload: bool) -> dict[str, Any]: - if redownload or not self.manifest_path.exists(): - manifest_data = download_json(self.manifest_url) - self.manifest_path.write_text(json.dumps(manifest_data, indent=2)) - return json.loads(self.manifest_path.read_text()) - - def _ensure_images_present(self, manifest: ImageManifest, redownload: bool = False) -> None: - """ - Ensure the images for this imageset exist locally. - """ - if redownload or not self._all_images_present(manifest): - self._download_and_extract_images(manifest) - - def _all_images_present(self, manifest: ImageManifest) -> bool: - for entry in manifest.entries.values(): - if not (self._images_dir / entry.relpath).exists(): - return False - return True - - def _download_and_extract_images(self, manifest: ImageManifest) -> None: - self._dataset_dir.mkdir(parents=True, exist_ok=True) - if self._images_dir.exists(): - for path in sorted(self._images_dir.rglob('*'), reverse=True): - if path.is_file(): - path.unlink() - elif path.is_dir(): - path.rmdir() - self._images_dir.rmdir() - - download_file(self.zipped_images_url, self.archive_path) - unzip_file(zip_path=self.archive_path, output_dir=self._images_dir) - self._verify_images(manifest) - - def _verify_images(self, manifest: ImageManifest) -> None: - for image_id, entry in manifest.entries.items(): - image_path = self._images_dir / entry.relpath - if not image_path.exists(): - raise FileNotFoundError(f"Missing image file for {image_id}: {image_path}") - - with PIL.Image.open(image_path) as image_data: - observed_sha256 = hash_image(image_data) - - if observed_sha256 != entry.sha256: - raise ValueError( - f"SHA256 mismatch for image {image_id}: {observed_sha256} != {entry.sha256}" - ) - - @property - def manifest_path(self) -> Path: - return self._dataset_dir / 'manifest.json' - - @property - def archive_path(self) -> Path: - archive_name = Path(self.zipped_images_url).name - return self._dataset_dir / archive_name - - @property - def images_dir(self) -> Path: - return self._images_dir - - @property - def image_ids(self) -> list[ImageId]: - """ - List of image refs in this imageset. - :return: - """ - return self._image_ids - - def get_annotation(self, *, image_id: ImageId) -> IA: - """ - Get the annotation for a given image. If an image has multiple annotations, this will throw an error. - """ - - entry = self._image_id_to_annotation[image_id] - return entry - - def get_image_path(self, *, image_id: ImageId) -> Path: - return self.images_dir / self._image_id_to_relpath[image_id] - - def __len__(self) -> int: - return len(self.image_ids) - - def __repr__(self): - return f"{self.__class__.__name__}({len(self)})" - - def __str__(self): - return f"Imageset(n={len(self)})" diff --git a/hobj/data_loaders/images/warmup.py b/hobj/data_loaders/images/warmup.py deleted file mode 100644 index 3fdd9c9..0000000 --- a/hobj/data_loaders/images/warmup.py +++ /dev/null @@ -1,24 +0,0 @@ -import pydantic - -from hobj.data_loaders.images.template import Imageset - - -class MutatorWarmupAnnotation(pydantic.BaseModel): - category: str = pydantic.Field( - examples=[ - 'Mutator19', - 'Mutator30', - ], - pattern=r'^Mutator\d+$' - ) - - -class MutatorWarmupImageset(Imageset[MutatorWarmupAnnotation]): - manifest_url = 'https://hlbdatasets.s3.us-east-1.amazonaws.com/imagesets/mutator-warmup/mutator-warmup-manifest.json' - zipped_images_url = 'https://hlbdatasets.s3.us-east-1.amazonaws.com/imagesets/mutator-warmup/MutatorWarmup.zip' - annotation_schema = MutatorWarmupAnnotation - - -if __name__ == '__main__': - - imageset = MutatorWarmupImageset(redownload=True) diff --git a/hobj/data_loaders/store.py b/hobj/data_loaders/store.py deleted file mode 100644 index 8b13789..0000000 --- a/hobj/data_loaders/store.py +++ /dev/null @@ -1 +0,0 @@ - diff --git a/hobj/learning_models/__init__.py b/hobj/learning_models/__init__.py index ad3411b..a88682b 100644 --- a/hobj/learning_models/__init__.py +++ b/hobj/learning_models/__init__.py @@ -21,8 +21,8 @@ def reset_state(self, seed: typing.Union[int, None]) -> None: @abstractmethod def get_response( - self, - image: ImageId, + self, + image: ImageId, ) -> typing.Literal[0, 1]: """ This function takes the current stimulus image (given either as a PIL.Image or a ImageRef) and returns one of two possible actions (parameterized by an integer). @@ -53,8 +53,8 @@ def reset_state(self, seed: typing.Union[int, None]) -> None: self.random_generator = np.random.default_rng(seed=seed) def get_response( - self, - image: ImageId, + self, + image: ImageId, ) -> typing.Literal[0, 1]: action = self.random_generator.integers(2) action = int(action) @@ -67,11 +67,10 @@ def give_feedback(self, reward: float) -> None: # %% class LinearLearner(BinaryLearningModel): def __init__( - self, - representational_model: RepresentationalModel, - update_rule: UpdateRule, + self, + representational_model: RepresentationalModel, + update_rule: UpdateRule, ): - self.representational_model = representational_model self.update_rule = update_rule @@ -103,10 +102,9 @@ def reset_state(self, seed: int) -> None: return def get_response( - self, - image: ImageId, + self, + image: ImageId, ) -> typing.Literal[0, 1]: - f = self.representational_model.get_features(image=image) logits = f @ self.w + self.b action = self._random_tiebreaking_argmax(logits[0], logits[1]) @@ -118,7 +116,14 @@ def get_response( return action def give_feedback(self, reward: float) -> None: - delta_w, delta_b = self.update_rule.get_update(x=self._f_last, w=self.w, b=self.b, logits=self._logits_last, action=self._action_last, reward=reward) # [action] + delta_w, delta_b = self.update_rule.get_update( + x=self._f_last, + w=self.w, + b=self.b, + logits=self._logits_last, + action=self._action_last, + reward=reward, + ) # [action] self.w += delta_w self.b += delta_b return diff --git a/hobj/learning_models/representation.py b/hobj/learning_models/representation.py index bd3d1f4..7a3dd69 100644 --- a/hobj/learning_models/representation.py +++ b/hobj/learning_models/representation.py @@ -12,11 +12,10 @@ class RepresentationalModel: """ def __init__( - self, - d: int, - image_to_features_func: Callable[[ImageId], np.ndarray], + self, + d: int, + image_to_features_func: Callable[[ImageId], np.ndarray], ): - if not isinstance(d, int): raise ValueError(f"Expected d to be an int, but got {d} of type {type(d)}") if d <= 0: @@ -30,10 +29,7 @@ def __init__( def d(self) -> int: return self._d - def get_features( - self, - image: ImageId - ) -> np.ndarray: + def get_features(self, image: ImageId) -> np.ndarray: """ Returns a feature vector for the image_url. To work successfully with UpdateRule, the feature vector must be of shape (d,) and have norm 1. @@ -45,16 +41,16 @@ def get_features( f = self._image_to_features_func(image) if f.shape != (self.d,): - raise ValueError(f"Expected feature vector of shape {(self.d,)}, but got {f.shape}") + raise ValueError( + f"Expected feature vector of shape {(self.d,)}, but got {f.shape}" + ) return f @classmethod def from_precomputed_features( - cls, - image_ref_to_features: Dict[ImageId, np.ndarray] - ) -> 'RepresentationalModel': - + cls, image_ref_to_features: Dict[ImageId, np.ndarray] + ) -> "RepresentationalModel": """ Convenience method for creating a RepresentationalModel, when one has a precomputed dict which maps ImageRefs to np.ndarray feature vectors. @@ -69,7 +65,9 @@ def image_to_features_func(image: ImageId) -> np.ndarray: for ref in image_ref_to_features: f = image_ref_to_features[ref] if not isinstance(f, np.ndarray): - raise ValueError(f"Expected feature vector to be a np.ndarray, but got {f} of type {type(f)}") + raise ValueError( + f"Expected feature vector to be a np.ndarray, but got {f} of type {type(f)}" + ) if not len(f.shape) == 1: raise ValueError(f"Expected feature vector to be 1D, but got {f.shape}") @@ -77,6 +75,8 @@ def image_to_features_func(image: ImageId) -> np.ndarray: d = f.shape[0] if not f.shape[0] == d: - raise ValueError(f"Expected feature vector to be of shape ({d},), but got {f.shape}") + raise ValueError( + f"Expected feature vector to be of shape ({d},), but got {f.shape}" + ) return cls(d=d, image_to_features_func=image_to_features_func) diff --git a/hobj/learning_models/update_rules.py b/hobj/learning_models/update_rules.py index 3297e26..5a8c0b1 100644 --- a/hobj/learning_models/update_rules.py +++ b/hobj/learning_models/update_rules.py @@ -27,13 +27,13 @@ def reset(self) -> None: @abstractmethod def get_update( - self, - x: np.ndarray, - w: np.ndarray, - b: Union[np.ndarray, np.generic, float], - logits: np.ndarray, - action: int, - reward: float + self, + x: np.ndarray, + w: np.ndarray, + b: Union[np.ndarray, np.generic, float], + logits: np.ndarray, + action: int, + reward: float, ) -> Tuple[np.ndarray, Union[np.ndarray, np.generic, float]]: """ Returns delta_w and delta_b, where @@ -63,13 +63,13 @@ def reset(self): self.ncounts = None def get_update( - self, - x: np.ndarray, - w: np.ndarray, - b: Union[np.ndarray, np.generic, float], - logits: np.ndarray, - action: int, - reward: float + self, + x: np.ndarray, + w: np.ndarray, + b: Union[np.ndarray, np.generic, float], + logits: np.ndarray, + action: int, + reward: float, ) -> Tuple[np.ndarray, Union[np.ndarray, np.generic, float]]: if self.ncounts is None: self.ncounts = np.zeros(w.shape[1]) @@ -99,15 +99,14 @@ def get_update( class Square(UpdateRule): - def get_update( - self, - x: np.ndarray, - w: np.ndarray, - b: Union[np.ndarray, np.generic, float], - logits: np.ndarray, - action: int, - reward: float + self, + x: np.ndarray, + w: np.ndarray, + b: Union[np.ndarray, np.generic, float], + logits: np.ndarray, + action: int, + reward: float, ) -> Tuple[np.ndarray, Union[np.ndarray, np.generic, float]]: delta = np.zeros(w.shape) @@ -119,15 +118,14 @@ def get_update( class Perceptron(UpdateRule): - def get_update( - self, - x: np.ndarray, - w: np.ndarray, - b: Union[np.ndarray, np.generic, float], - logits: np.ndarray, - action: int, - reward: float + self, + x: np.ndarray, + w: np.ndarray, + b: Union[np.ndarray, np.generic, float], + logits: np.ndarray, + action: int, + reward: float, ) -> Tuple[np.ndarray, Union[np.ndarray, np.generic, float]]: nactions = len(logits) gts = np.zeros(nactions) @@ -141,15 +139,14 @@ def get_update( class Hinge(UpdateRule): - def get_update( - self, - x: np.ndarray, - w: np.ndarray, - b: Union[np.ndarray, np.generic, float], - logits: np.ndarray, - action: int, - reward: float + self, + x: np.ndarray, + w: np.ndarray, + b: Union[np.ndarray, np.generic, float], + logits: np.ndarray, + action: int, + reward: float, ) -> Tuple[np.ndarray, Union[np.ndarray, np.generic, float]]: nactions = len(logits) gts = np.zeros(nactions) @@ -163,17 +160,15 @@ def get_update( class MAE(UpdateRule): - def get_update( - self, - x: np.ndarray, - w: np.ndarray, - b: Union[np.ndarray, np.generic, float], - logits: np.ndarray, - action: int, - reward: float + self, + x: np.ndarray, + w: np.ndarray, + b: Union[np.ndarray, np.generic, float], + logits: np.ndarray, + action: int, + reward: float, ) -> Tuple[np.ndarray, Union[np.ndarray, np.generic, float]]: - nactions = len(logits) reward_prediction = logits[action] @@ -191,13 +186,13 @@ class Exponential(UpdateRule): max_weight_norm = 10.0 def get_update( - self, - x: np.ndarray, - w: np.ndarray, - b: Union[np.ndarray, np.generic, float], - logits: np.ndarray, - action: int, - reward: float + self, + x: np.ndarray, + w: np.ndarray, + b: Union[np.ndarray, np.generic, float], + logits: np.ndarray, + action: int, + reward: float, ) -> Tuple[np.ndarray, Union[np.ndarray, np.generic, float]]: nactions = len(logits) @@ -214,32 +209,32 @@ def get_update( class CE(UpdateRule): - def get_update( - self, - x: np.ndarray, - w: np.ndarray, - b: Union[np.ndarray, np.generic, float], - logits: np.ndarray, - action: int, - reward: float + self, + x: np.ndarray, + w: np.ndarray, + b: Union[np.ndarray, np.generic, float], + logits: np.ndarray, + action: int, + reward: float, ) -> Tuple[np.ndarray, Union[np.ndarray, np.generic, float]]: nactions = len(logits) gts = np.zeros(nactions) reward_prediction = logits[action] - gts[action] = 4 * self.alpha * (reward / (1 + np.exp(reward * reward_prediction))) + gts[action] = ( + 4 * self.alpha * (reward / (1 + np.exp(reward * reward_prediction))) + ) delta = x[:, None] * gts[None, :] return delta, 0 class REINFORCE(UpdateRule): - def _compute_trace( - self, - action_taken: int, - logits: np.ndarray, + self, + action_taken: int, + logits: np.ndarray, ): """ Computes the negative derivative of the probability of taking each action with respect to logit[i] @@ -264,13 +259,13 @@ def _compute_trace( return expression def get_update( - self, - x: np.ndarray, - w: np.ndarray, - b: Union[np.ndarray, np.generic, float], - logits: np.ndarray, - action: int, - reward: float + self, + x: np.ndarray, + w: np.ndarray, + b: Union[np.ndarray, np.generic, float], + logits: np.ndarray, + action: int, + reward: float, ) -> Tuple[np.ndarray, Union[np.ndarray, np.generic, float]]: gt = self.alpha * reward * self._compute_trace(action, logits) diff --git a/hobj/stats/__init__.py b/hobj/stats/__init__.py index e6723e2..e69de29 100644 --- a/hobj/stats/__init__.py +++ b/hobj/stats/__init__.py @@ -1 +0,0 @@ -from hobj.stats.ci import estimate_basic_bootstrap_CI \ No newline at end of file diff --git a/hobj/stats/binomial.py b/hobj/stats/binomial.py index aad1b90..465d9e1 100644 --- a/hobj/stats/binomial.py +++ b/hobj/stats/binomial.py @@ -1,5 +1,4 @@ def estimate_variance_of_binomial_proportion(kvec, nvec): - """ Returns the unbiased estimate of the variance associated with the proportion estimator, phat = k/n: :param kvec: diff --git a/hobj/stats/ci.py b/hobj/stats/ci.py index 13979a5..83af88a 100644 --- a/hobj/stats/ci.py +++ b/hobj/stats/ci.py @@ -4,9 +4,9 @@ def estimate_basic_bootstrap_CI( - alpha: float, - point_estimate: Union[np.ndarray, np.generic, float, int], # [*] - bootstrapped_point_estimates: np.ndarray, # [n_bootstraps, *] + alpha: float, + point_estimate: Union[np.ndarray, np.generic, float, int], # [*] + bootstrapped_point_estimates: np.ndarray, # [n_bootstraps, *] ) -> Tuple[float, float]: """ Estimates the basic confidence interval for a given point estimate(s) using the bootstrap method. @@ -17,14 +17,16 @@ def estimate_basic_bootstrap_CI( """ if not 0 < alpha < 1: - raise ValueError(f'alpha must be in the range (0, 1); got {alpha:.2f}') + raise ValueError(f"alpha must be in the range (0, 1); got {alpha:.2f}") # Coerce point_estimate to a numpy array point_estimate = np.array(point_estimate) # [*] # Ensure the dimensions are as expected if not len(point_estimate.shape) == len(bootstrapped_point_estimates.shape) - 1: - raise ValueError(f'The dimensions of the point estimate and bootstrapped point estimates do not match: {point_estimate.shape} vs {bootstrapped_point_estimates.shape}') + raise ValueError( + f"The dimensions of the point estimate and bootstrapped point estimates do not match: {point_estimate.shape} vs {bootstrapped_point_estimates.shape}" + ) # Calculate confidence interval using the basic bootstrap method low = np.quantile(bootstrapped_point_estimates, alpha / 2, axis=0) # [*] diff --git a/hobj/utils/file_io.py b/hobj/utils/file_io.py index 6778353..12ff671 100644 --- a/hobj/utils/file_io.py +++ b/hobj/utils/file_io.py @@ -16,7 +16,7 @@ def unzip_file(zip_path: Path, output_dir: Path) -> None: :return: """ - if not zip_path.as_posix().endswith('.zip'): + if not zip_path.as_posix().endswith(".zip"): raise ValueError(f"Expected a .zip file, got {zip_path}") if not zip_path.exists(): raise FileNotFoundError(f"Zip file {zip_path} does not exist.") @@ -24,21 +24,27 @@ def unzip_file(zip_path: Path, output_dir: Path) -> None: if not output_dir.exists(): output_dir.mkdir(parents=True) - with zipfile.ZipFile(zip_path, 'r') as zip_ref: + with zipfile.ZipFile(zip_path, "r") as zip_ref: zip_ref.extractall(output_dir) def download_file(url: str, output_path: Path) -> None: # Send a GET request to fetch the file response = requests.get(url, stream=True) - total_size_in_bytes = int(response.headers.get('content-length', 0)) + total_size_in_bytes = int(response.headers.get("content-length", 0)) # Create the output directory if it does not exist if not output_path.parent.exists(): output_path.parent.mkdir(parents=True) - with tqdm(total=total_size_in_bytes, unit='B', unit_scale=True, disable=False, desc='Download progress') as progress_bar: - with open(output_path.as_posix(), 'wb') as file: + with tqdm( + total=total_size_in_bytes, + unit="B", + unit_scale=True, + disable=False, + desc="Download progress", + ) as progress_bar: + with open(output_path.as_posix(), "wb") as file: # Iterate over the response data in chunks and write to file for chunk in response.iter_content(chunk_size=1024): if chunk: @@ -55,23 +61,18 @@ def get_bytes_size(num_bytes: int, output_units: str = None) -> (float, str): :return: """ - unit_conversion = { - 'B': 1, - 'KB': 1e3, - 'MB': 1e6, - 'GB': 1e9 - } + unit_conversion = {"B": 1, "KB": 1e3, "MB": 1e6, "GB": 1e9} # Automatically select the byte unit (KB, MB, etc.) if output_units is None: if num_bytes == 0: - output_units = 'B' + output_units = "B" elif num_bytes < 1e6: - output_units = 'KB' + output_units = "KB" elif num_bytes < 1e9: - output_units = 'MB' + output_units = "MB" else: - output_units = 'GB' + output_units = "GB" # Convert the size to the selected unit size = num_bytes / unit_conversion[output_units] @@ -87,7 +88,7 @@ def download_json(url: str) -> Any: response = urllib.request.urlopen(url) if response.status != 200: raise ValueError(f"Could not load JSON data from {url}", response) - data = response.read().decode('utf-8') + data = response.read().decode("utf-8") json_data = json.loads(data) return json_data diff --git a/hobj/utils/hash.py b/hobj/utils/hash.py index f321fbe..ddf82b5 100644 --- a/hobj/utils/hash.py +++ b/hobj/utils/hash.py @@ -13,7 +13,7 @@ def hash_image(image: PIL.Image.Image) -> str: sha256_hash = hashlib.sha256() # Always cast the image to RGBA format - image = image.convert('RGBA') + image = image.convert("RGBA") # Convert the image to a numpy array image_array = np.array(image).astype(np.uint8) @@ -29,7 +29,7 @@ def hash_string(input_string: str) -> str: sha256_hash = hashlib.sha256() # Convert string to bytes - sha256_hash.update(input_string.encode('utf-8')) + sha256_hash.update(input_string.encode("utf-8")) # Return the hexadecimal representation of the hash return sha256_hash.hexdigest() diff --git a/pyproject.toml b/pyproject.toml index 526a8b8..e15fea6 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -12,7 +12,7 @@ authors = [ license = "MIT" license-files = ["license.md"] readme = "README.md" -requires-python = ">=3.11,<3.13" +requires-python = ">=3.12" dependencies = [ "numpy>=2.2", @@ -23,10 +23,16 @@ dependencies = [ "pydantic>=2.10", "xarray>=2025.1", "scipy>=1.17.1", + "ipykernel>=7.2.0", ] +[project.scripts] +hobj-download-data = "hobj.data_loaders.download:main" + [dependency-groups] dev = [ + "enczoo==0.1.3.dev1", + "netcdf4>=1.7.4", "pytest>=8.3", ] @@ -35,4 +41,3 @@ repository = "https://github.com/himjl/hobj" [tool.uv.build-backend] module-root = "" - diff --git a/site/changelist.md b/site/changelist.md index 38dba67..4c5fe6d 100644 --- a/site/changelist.md +++ b/site/changelist.md @@ -7,3 +7,247 @@ We note the following changes since this codebase was released alongisde the pap * Statistical analyses other than the calculation of MSEn scores, their 95% confidence intervals, and generation of bootstrap resamples have been removed from this codebase. * Experiment 2: The lapse-rate corrected performance is now clipped between [0, 1]. * Experiment 2: The estimation of the variance of a lapse-rate corrected performance estimate from using bootstrapping to using the formula $\frac{1}{1-\hat p_{l}} \hat \sigma^2$, which treats the estimated lapse rate as a constant. Because a high number (~1000s) of Binomial observations are used to estimate $\hat p_{l}$, we consider this a decent approximation that is less computationally expensive. + +## 3/25/2026 - cleaner data packaging + + + +### Object renaming +I renamed the objects to follow a cleaner naming scheme. See below for the map from old names to new names: + +
+High-variation object renames + +```json +{ + "MutatorB2000_0": "MutatorObject000", + "MutatorB2000_19": "MutatorObject001", + "MutatorB2000_84": "MutatorObject002", + "MutatorB2000_91": "MutatorObject003", + "MutatorB2000_93": "MutatorObject004", + "MutatorB2000_98": "MutatorObject005", + "MutatorB2000_104": "MutatorObject006", + "MutatorB2000_133": "MutatorObject007", + "MutatorB2000_149": "MutatorObject008", + "MutatorB2000_160": "MutatorObject009", + "MutatorB2000_172": "MutatorObject010", + "MutatorB2000_174": "MutatorObject011", + "MutatorB2000_185": "MutatorObject012", + "MutatorB2000_188": "MutatorObject013", + "MutatorB2000_190": "MutatorObject014", + "MutatorB2000_196": "MutatorObject015", + "MutatorB2000_200": "MutatorObject016", + "MutatorB2000_206": "MutatorObject017", + "MutatorB2000_214": "MutatorObject018", + "MutatorB2000_218": "MutatorObject019", + "MutatorB2000_229": "MutatorObject020", + "MutatorB2000_247": "MutatorObject021", + "MutatorB2000_348": "MutatorObject022", + "MutatorB2000_367": "MutatorObject023", + "MutatorB2000_376": "MutatorObject024", + "MutatorB2000_385": "MutatorObject025", + "MutatorB2000_417": "MutatorObject026", + "MutatorB2000_419": "MutatorObject027", + "MutatorB2000_450": "MutatorObject028", + "MutatorB2000_455": "MutatorObject029", + "MutatorB2000_470": "MutatorObject030", + "MutatorB2000_475": "MutatorObject031", + "MutatorB2000_487": "MutatorObject032", + "MutatorB2000_527": "MutatorObject033", + "MutatorB2000_561": "MutatorObject034", + "MutatorB2000_577": "MutatorObject035", + "MutatorB2000_578": "MutatorObject036", + "MutatorB2000_609": "MutatorObject037", + "MutatorB2000_631": "MutatorObject038", + "MutatorB2000_645": "MutatorObject039", + "MutatorB2000_656": "MutatorObject040", + "MutatorB2000_671": "MutatorObject041", + "MutatorB2000_693": "MutatorObject042", + "MutatorB2000_695": "MutatorObject043", + "MutatorB2000_697": "MutatorObject044", + "MutatorB2000_700": "MutatorObject045", + "MutatorB2000_722": "MutatorObject046", + "MutatorB2000_770": "MutatorObject047", + "MutatorB2000_772": "MutatorObject048", + "MutatorB2000_774": "MutatorObject049", + "MutatorB2000_797": "MutatorObject050", + "MutatorB2000_798": "MutatorObject051", + "MutatorB2000_812": "MutatorObject052", + "MutatorB2000_819": "MutatorObject053", + "MutatorB2000_820": "MutatorObject054", + "MutatorB2000_823": "MutatorObject055", + "MutatorB2000_856": "MutatorObject056", + "MutatorB2000_876": "MutatorObject057", + "MutatorB2000_899": "MutatorObject058", + "MutatorB2000_902": "MutatorObject059", + "MutatorB2000_938": "MutatorObject060", + "MutatorB2000_963": "MutatorObject061", + "MutatorB2000_972": "MutatorObject062", + "MutatorB2000_1012": "MutatorObject063", + "MutatorB2000_1018": "MutatorObject064", + "MutatorB2000_1024": "MutatorObject065", + "MutatorB2000_1030": "MutatorObject066", + "MutatorB2000_1034": "MutatorObject067", + "MutatorB2000_4193": "MutatorObject068", + "MutatorB2000_4235": "MutatorObject069", + "MutatorB2000_4255": "MutatorObject070", + "MutatorB2000_4259": "MutatorObject071", + "MutatorB2000_4267": "MutatorObject072", + "MutatorB2000_4287": "MutatorObject073", + "MutatorB2000_4370": "MutatorObject074", + "MutatorB2000_4448": "MutatorObject075", + "MutatorB2000_4451": "MutatorObject076", + "MutatorB2000_4454": "MutatorObject077", + "MutatorB2000_4482": "MutatorObject078", + "MutatorB2000_4489": "MutatorObject079", + "MutatorB2000_4491": "MutatorObject080", + "MutatorB2000_4521": "MutatorObject081", + "MutatorB2000_4530": "MutatorObject082", + "MutatorB2000_4567": "MutatorObject083", + "MutatorB2000_4568": "MutatorObject084", + "MutatorB2000_4569": "MutatorObject085", + "MutatorB2000_4578": "MutatorObject086", + "MutatorB2000_4614": "MutatorObject087", + "MutatorB2000_4622": "MutatorObject088", + "MutatorB2000_4630": "MutatorObject089", + "MutatorB2000_4634": "MutatorObject090", + "MutatorB2000_4635": "MutatorObject091", + "MutatorB2000_4678": "MutatorObject092", + "MutatorB2000_4710": "MutatorObject093", + "MutatorB2000_4715": "MutatorObject094", + "MutatorB2000_4718": "MutatorObject095", + "MutatorB2000_4720": "MutatorObject096", + "MutatorB2000_4723": "MutatorObject097", + "MutatorB2000_4724": "MutatorObject098", + "MutatorB2000_4732": "MutatorObject099", + "MutatorB2000_4750": "MutatorObject100", + "MutatorB2000_4752": "MutatorObject101", + "MutatorB2000_4754": "MutatorObject102", + "MutatorB2000_4772": "MutatorObject103", + "MutatorB2000_4805": "MutatorObject104", + "MutatorB2000_4821": "MutatorObject105", + "MutatorB2000_4829": "MutatorObject106", + "MutatorB2000_4832": "MutatorObject107", + "MutatorB2000_4835": "MutatorObject108", + "MutatorB2000_4845": "MutatorObject109", + "MutatorB2000_4847": "MutatorObject110", + "MutatorB2000_4872": "MutatorObject111", + "MutatorB2000_4878": "MutatorObject112", + "MutatorB2000_4908": "MutatorObject113", + "MutatorB2000_4910": "MutatorObject114", + "MutatorB2000_4911": "MutatorObject115", + "MutatorB2000_4932": "MutatorObject116", + "MutatorB2000_4939": "MutatorObject117", + "MutatorB2000_4940": "MutatorObject118", + "MutatorB2000_4945": "MutatorObject119", + "MutatorB2000_4946": "MutatorObject120", + "MutatorB2000_4950": "MutatorObject121", + "MutatorB2000_4951": "MutatorObject122", + "MutatorB2000_4953": "MutatorObject123", + "MutatorB2000_4968": "MutatorObject124", + "MutatorB2000_4974": "MutatorObject125", + "MutatorB2000_4986": "MutatorObject126", + "MutatorB2000_4998": "MutatorObject127" +} +``` + +
+ +
+One-shot object renames + +```json +{ + "MutatorB2000_46": "MutatorOneshotObject00", + "MutatorB2000_116": "MutatorOneshotObject01", + "MutatorB2000_138": "MutatorOneshotObject02", + "MutatorB2000_270": "MutatorOneshotObject03", + "MutatorB2000_288": "MutatorOneshotObject04", + "MutatorB2000_296": "MutatorOneshotObject05", + "MutatorB2000_462": "MutatorOneshotObject06", + "MutatorB2000_496": "MutatorOneshotObject07", + "MutatorB2000_613": "MutatorOneshotObject08", + "MutatorB2000_663": "MutatorOneshotObject09", + "MutatorB2000_694": "MutatorOneshotObject10", + "MutatorB2000_701": "MutatorOneshotObject11", + "MutatorB2000_746": "MutatorOneshotObject12", + "MutatorB2000_801": "MutatorOneshotObject13", + "MutatorB2000_926": "MutatorOneshotObject14", + "MutatorB2000_953": "MutatorOneshotObject15", + "MutatorB2000_1164": "MutatorOneshotObject16", + "MutatorB2000_1219": "MutatorOneshotObject17", + "MutatorB2000_1229": "MutatorOneshotObject18", + "MutatorB2000_1251": "MutatorOneshotObject19", + "MutatorB2000_1258": "MutatorOneshotObject20", + "MutatorB2000_1280": "MutatorOneshotObject21", + "MutatorB2000_1363": "MutatorOneshotObject22", + "MutatorB2000_1424": "MutatorOneshotObject23", + "MutatorB2000_1767": "MutatorOneshotObject24", + "MutatorB2000_1825": "MutatorOneshotObject25", + "MutatorB2000_1865": "MutatorOneshotObject26", + "MutatorB2000_2092": "MutatorOneshotObject27", + "MutatorB2000_2106": "MutatorOneshotObject28", + "MutatorB2000_2122": "MutatorOneshotObject29", + "MutatorB2000_2130": "MutatorOneshotObject30", + "MutatorB2000_2139": "MutatorOneshotObject31", + "MutatorB2000_2198": "MutatorOneshotObject32", + "MutatorB2000_2292": "MutatorOneshotObject33", + "MutatorB2000_2304": "MutatorOneshotObject34", + "MutatorB2000_2314": "MutatorOneshotObject35", + "MutatorB2000_2344": "MutatorOneshotObject36", + "MutatorB2000_2365": "MutatorOneshotObject37", + "MutatorB2000_2444": "MutatorOneshotObject38", + "MutatorB2000_2722": "MutatorOneshotObject39", + "MutatorB2000_2757": "MutatorOneshotObject40", + "MutatorB2000_2832": "MutatorOneshotObject41", + "MutatorB2000_2909": "MutatorOneshotObject42", + "MutatorB2000_3035": "MutatorOneshotObject43", + "MutatorB2000_3043": "MutatorOneshotObject44", + "MutatorB2000_3066": "MutatorOneshotObject45", + "MutatorB2000_3077": "MutatorOneshotObject46", + "MutatorB2000_3123": "MutatorOneshotObject47", + "MutatorB2000_3278": "MutatorOneshotObject48", + "MutatorB2000_3308": "MutatorOneshotObject49", + "MutatorB2000_3496": "MutatorOneshotObject50", + "MutatorB2000_3525": "MutatorOneshotObject51", + "MutatorB2000_3527": "MutatorOneshotObject52", + "MutatorB2000_3585": "MutatorOneshotObject53", + "MutatorB2000_3601": "MutatorOneshotObject54", + "MutatorB2000_3615": "MutatorOneshotObject55", + "MutatorB2000_3636": "MutatorOneshotObject56", + "MutatorB2000_3733": "MutatorOneshotObject57", + "MutatorB2000_4049": "MutatorOneshotObject58", + "MutatorB2000_4256": "MutatorOneshotObject59", + "MutatorB2000_4305": "MutatorOneshotObject60", + "MutatorB2000_4628": "MutatorOneshotObject61", + "MutatorB2000_4703": "MutatorOneshotObject62", + "MutatorB2000_4792": "MutatorOneshotObject63" +} +``` + +
+ + +
+Warmup object renames + +```json +{ + "Mutator19": "MutatorWarmupObject0", + "Mutator20": "MutatorWarmupObject1", + "Mutator21": "MutatorWarmupObject2", + "Mutator22": "MutatorWarmupObject3", + "Mutator25": "MutatorWarmupObject4", + "Mutator26": "MutatorWarmupObject5", + "Mutator29": "MutatorWarmupObject6", + "Mutator30": "MutatorWarmupObject7" +} +``` + +
+ + + +### Image renaming + +Following the renames of the object categories, the images were renamed as well. The old image names are available in the `original_filename` columns of each `meta-*.csv` file for each imageset. diff --git a/site/readme_images/human_learning_curves.svg b/site/readme_images/human_learning_curves.svg index 24ac401..8b2d032 100644 --- a/site/readme_images/human_learning_curves.svg +++ b/site/readme_images/human_learning_curves.svg @@ -6,11 +6,11 @@ - 2025-01-27T13:47:46.663343 + 2026-03-26T18:22:59.609218 image/svg+xml - Matplotlib v3.9.2, https://matplotlib.org/ + Matplotlib v3.9.0, https://matplotlib.org/ @@ -42,18 +42,18 @@ z +" clip-path="url(#pee8cec0876)" style="fill: none; stroke-dasharray: 1.5,2.475; stroke-dashoffset: 0; stroke: #000000; stroke-width: 1.5"/> - - + @@ -105,7 +105,7 @@ z - + @@ -120,7 +120,7 @@ z - + @@ -161,131 +161,131 @@ z - - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + @@ -516,12 +516,12 @@ z - - + @@ -564,7 +564,7 @@ z - + @@ -606,7 +606,7 @@ z - + @@ -653,7 +653,7 @@ z - + @@ -680,7 +680,7 @@ z - + @@ -736,7 +736,7 @@ z - + @@ -783,7 +783,7 @@ z - + @@ -1015,522 +1015,522 @@ L 287.827931 60.476176 L 288.340456 72.368628 L 288.847777 72.368628 L 289.35 72.368628 -" clip-path="url(#pc940f8c749)" style="fill: none; stroke: #808080; stroke-opacity: 0.05; stroke-linecap: square"/> +" clip-path="url(#pee8cec0876)" style="fill: none; stroke: #808080; stroke-opacity: 0.05; stroke-linecap: square"/> - +L 287.310094 78.314854 +L 287.827931 60.476176 +L 288.340456 66.422402 +L 288.847777 60.476176 +L 289.35 48.583725 +" clip-path="url(#pee8cec0876)" style="fill: none; stroke: #808080; stroke-opacity: 0.05; stroke-linecap: square"/> - +L 288.847777 84.26108 +L 289.35 72.368628 +" clip-path="url(#pee8cec0876)" style="fill: none; stroke: #808080; stroke-opacity: 0.05; stroke-linecap: square"/> - +L 287.310094 78.314854 +L 287.827931 48.583725 +L 288.340456 72.368628 +L 288.847777 36.691273 +L 289.35 42.637499 +" clip-path="url(#pee8cec0876)" style="fill: none; stroke: #808080; stroke-opacity: 0.05; stroke-linecap: square"/> - +L 287.310094 119.938435 +L 287.827931 108.045983 +L 288.340456 131.830887 +L 288.847777 131.830887 +L 289.35 78.314854 +" clip-path="url(#pee8cec0876)" style="fill: none; stroke: #808080; stroke-opacity: 0.05; stroke-linecap: square"/> - +L 288.847777 60.476176 +L 289.35 72.368628 +" clip-path="url(#pee8cec0876)" style="fill: none; stroke: #808080; stroke-opacity: 0.05; stroke-linecap: square"/> +" clip-path="url(#pee8cec0876)" style="fill: none; stroke: #808080; stroke-opacity: 0.05; stroke-linecap: square"/> +" clip-path="url(#pee8cec0876)" style="fill: none; stroke: #808080; stroke-opacity: 0.05; stroke-linecap: square"/> +" clip-path="url(#pee8cec0876)" style="fill: none; stroke: #808080; stroke-opacity: 0.05; stroke-linecap: square"/> +" clip-path="url(#pee8cec0876)" style="fill: none; stroke: #808080; stroke-opacity: 0.05; stroke-linecap: square"/> +" clip-path="url(#pee8cec0876)" style="fill: none; stroke: #808080; stroke-opacity: 0.05; stroke-linecap: square"/> +" clip-path="url(#pee8cec0876)" style="fill: none; stroke: #808080; stroke-opacity: 0.05; stroke-linecap: square"/> +" clip-path="url(#pee8cec0876)" style="fill: none; stroke: #808080; stroke-opacity: 0.05; stroke-linecap: square"/> - - - +" clip-path="url(#pee8cec0876)" style="fill: none; stroke: #808080; stroke-opacity: 0.05; stroke-linecap: square"/> - + +" clip-path="url(#pee8cec0876)" style="fill: none; stroke: #808080; stroke-opacity: 0.05; stroke-linecap: square"/> - + +" clip-path="url(#pee8cec0876)" style="fill: none; stroke: #808080; stroke-opacity: 0.05; stroke-linecap: square"/> - - - - + +" clip-path="url(#pee8cec0876)" style="fill: none; stroke: #808080; stroke-opacity: 0.05; stroke-linecap: square"/> - + +" clip-path="url(#pee8cec0876)" style="fill: none; stroke: #808080; stroke-opacity: 0.05; stroke-linecap: square"/> - + +" clip-path="url(#pee8cec0876)" style="fill: none; stroke: #808080; stroke-opacity: 0.05; stroke-linecap: square"/> - + +" clip-path="url(#pee8cec0876)" style="fill: none; stroke: #808080; stroke-opacity: 0.05; stroke-linecap: square"/> - + +" clip-path="url(#pee8cec0876)" style="fill: none; stroke: #808080; stroke-opacity: 0.05; stroke-linecap: square"/> - + +" clip-path="url(#pee8cec0876)" style="fill: none; stroke: #808080; stroke-opacity: 0.05; stroke-linecap: square"/> - + +" clip-path="url(#pee8cec0876)" style="fill: none; stroke: #808080; stroke-opacity: 0.05; stroke-linecap: square"/> - + +" clip-path="url(#pee8cec0876)" style="fill: none; stroke: #808080; stroke-opacity: 0.05; stroke-linecap: square"/> - + +" clip-path="url(#pee8cec0876)" style="fill: none; stroke: #808080; stroke-opacity: 0.05; stroke-linecap: square"/> - + +" clip-path="url(#pee8cec0876)" style="fill: none; stroke: #808080; stroke-opacity: 0.05; stroke-linecap: square"/> - - + + + + +L 286.25804 72.368628 +L 286.786836 72.368628 +L 287.310094 125.884661 +L 287.827931 78.314854 +L 288.340456 102.099758 +L 288.847777 78.314854 +L 289.35 90.207306 +" clip-path="url(#pee8cec0876)" style="fill: none; stroke: #808080; stroke-opacity: 0.05; stroke-linecap: square"/> - - + - - - - - - +L 287.827931 102.099758 +L 288.340456 90.207306 +L 288.847777 66.422402 +L 289.35 84.26108 +" clip-path="url(#pee8cec0876)" style="fill: none; stroke: #808080; stroke-opacity: 0.05; stroke-linecap: square"/> - - + + + + +" clip-path="url(#pee8cec0876)" style="fill: none; stroke: #808080; stroke-opacity: 0.05; stroke-linecap: square"/> - - + +L 267.823454 60.476176 +L 268.586381 78.314854 +L 269.337836 78.314854 +L 270.078156 60.476176 +L 270.807669 48.583725 +L 271.526685 66.422402 +L 272.235502 66.422402 +L 272.934405 60.476176 +L 273.623668 72.368628 +L 274.303553 54.52995 +L 274.974311 42.637499 +L 275.636185 48.583725 +L 276.289407 66.422402 +L 276.934199 48.583725 +L 277.570778 42.637499 +L 278.199349 78.314854 +L 278.820112 84.26108 +L 279.433258 72.368628 +L 280.038971 66.422402 +L 280.63743 66.422402 +L 281.228807 96.153532 +L 281.813267 66.422402 +L 282.39097 54.52995 +L 282.962071 42.637499 +L 283.526718 42.637499 +L 284.085056 60.476176 +L 284.637225 54.52995 +L 285.183358 66.422402 +L 285.723588 60.476176 +L 286.25804 66.422402 +L 286.786836 66.422402 +L 287.310094 96.153532 +L 287.827931 66.422402 +L 288.340456 66.422402 +L 288.847777 54.52995 +L 289.35 66.422402 +" clip-path="url(#pee8cec0876)" style="fill: none; stroke: #808080; stroke-opacity: 0.05; stroke-linecap: square"/> - - + + + + +L 288.340456 78.314854 +L 288.847777 54.52995 +L 289.35 66.422402 +" clip-path="url(#pee8cec0876)" style="fill: none; stroke: #808080; stroke-opacity: 0.05; stroke-linecap: square"/> - - - - - + +L 282.39097 54.52995 +L 282.962071 48.583725 +L 283.526718 60.476176 +L 284.085056 54.52995 +L 284.637225 60.476176 +L 285.183358 72.368628 +L 285.723588 60.476176 +L 286.25804 48.583725 +L 286.786836 42.637499 +L 287.310094 54.52995 +L 287.827931 48.583725 +L 288.340456 48.583725 +L 288.847777 72.368628 +L 289.35 48.583725 +" clip-path="url(#pee8cec0876)" style="fill: none; stroke: #808080; stroke-opacity: 0.05; stroke-linecap: square"/> - - + - - - +L 289.35 72.368628 +" clip-path="url(#pee8cec0876)" style="fill: none; stroke: #808080; stroke-opacity: 0.05; stroke-linecap: square"/> - - + + + + - - - +L 288.847777 48.583725 +L 289.35 66.422402 +" clip-path="url(#pee8cec0876)" style="fill: none; stroke: #808080; stroke-opacity: 0.05; stroke-linecap: square"/> - - + + + + + + + +L 286.25804 72.368628 +L 286.786836 84.26108 +L 287.310094 72.368628 +L 287.827931 66.422402 +L 288.340456 72.368628 +L 288.847777 78.314854 +L 289.35 66.422402 +" clip-path="url(#pee8cec0876)" style="fill: none; stroke: #808080; stroke-opacity: 0.05; stroke-linecap: square"/> - - + + + + +" clip-path="url(#pee8cec0876)" style="fill: none; stroke: #808080; stroke-opacity: 0.05; stroke-linecap: square"/> - +L 282.39097 72.368628 +L 282.962071 90.207306 +L 283.526718 78.314854 +L 284.085056 102.099758 +L 284.637225 66.422402 +L 285.183358 84.26108 +L 285.723588 84.26108 +L 286.25804 72.368628 +L 286.786836 66.422402 +L 287.310094 84.26108 +L 287.827931 72.368628 +L 288.340456 90.207306 +L 288.847777 72.368628 +L 289.35 96.153532 +" clip-path="url(#pee8cec0876)" style="fill: none; stroke: #808080; stroke-opacity: 0.05; stroke-linecap: square"/> - - - - +L 286.25804 113.992209 +L 286.786836 119.938435 +L 287.310094 125.884661 +L 287.827931 119.938435 +L 288.340456 131.830887 +L 288.847777 102.099758 +L 289.35 96.153532 +" clip-path="url(#pee8cec0876)" style="fill: none; stroke: #808080; stroke-opacity: 0.05; stroke-linecap: square"/> - - + - - - +L 288.847777 66.422402 +L 289.35 72.368628 +" clip-path="url(#pee8cec0876)" style="fill: none; stroke: #808080; stroke-opacity: 0.05; stroke-linecap: square"/> - - + + + + - - - - - - - - - - - - +L 287.827931 96.153532 +L 288.340456 113.992209 +L 288.847777 60.476176 +L 289.35 90.207306 +" clip-path="url(#pee8cec0876)" style="fill: none; stroke: #808080; stroke-opacity: 0.05; stroke-linecap: square"/> - - + + + + +L 251.620955 78.314854 +L 252.67301 96.153532 +L 253.703371 96.153532 +L 254.712915 119.938435 +L 255.702467 78.314854 +L 256.672804 96.153532 +L 257.624656 96.153532 +L 258.558716 125.884661 +L 259.475637 131.830887 +L 260.376035 84.26108 +L 261.260496 84.26108 +L 262.129574 102.099758 +L 262.983796 96.153532 +L 263.82366 125.884661 +L 264.649642 108.045983 +L 265.462192 66.422402 +L 266.261741 78.314854 +L 267.048699 108.045983 +L 267.823454 119.938435 +L 268.586381 108.045983 +L 269.337836 102.099758 +L 270.078156 119.938435 +L 270.807669 72.368628 +L 271.526685 108.045983 +L 272.235502 102.099758 +L 272.934405 108.045983 +L 273.623668 90.207306 +L 274.303553 108.045983 +L 274.974311 72.368628 +L 275.636185 96.153532 +L 276.289407 84.26108 +L 276.934199 66.422402 +L 277.570778 90.207306 +L 278.199349 72.368628 +L 278.820112 96.153532 +L 279.433258 78.314854 +L 280.038971 108.045983 +L 280.63743 113.992209 +L 281.228807 102.099758 +L 281.813267 125.884661 +L 282.39097 102.099758 +L 282.962071 84.26108 +L 283.526718 108.045983 +L 284.085056 90.207306 +L 284.637225 96.153532 +L 285.183358 78.314854 +L 285.723588 84.26108 +L 286.25804 90.207306 +L 286.786836 113.992209 +L 287.310094 96.153532 +L 287.827931 108.045983 +L 288.340456 96.153532 +L 288.847777 119.938435 +L 289.35 84.26108 +" clip-path="url(#pee8cec0876)" style="fill: none; stroke: #808080; stroke-opacity: 0.05; stroke-linecap: square"/> - - + + + + +L 285.183358 102.099758 +L 285.723588 90.207306 +L 286.25804 90.207306 +L 286.786836 113.992209 +L 287.310094 78.314854 +L 287.827931 96.153532 +L 288.340456 84.26108 +L 288.847777 78.314854 +L 289.35 60.476176 +" clip-path="url(#pee8cec0876)" style="fill: none; stroke: #808080; stroke-opacity: 0.05; stroke-linecap: square"/> - - + + + + +L 273.623668 102.099758 +L 274.303553 72.368628 +L 274.974311 125.884661 +L 275.636185 113.992209 +L 276.289407 84.26108 +L 276.934199 78.314854 +L 277.570778 84.26108 +L 278.199349 84.26108 +L 278.820112 66.422402 +L 279.433258 78.314854 +L 280.038971 84.26108 +L 280.63743 108.045983 +L 281.228807 66.422402 +L 281.813267 113.992209 +L 282.39097 78.314854 +L 282.962071 90.207306 +L 283.526718 108.045983 +L 284.085056 90.207306 +L 284.637225 96.153532 +L 285.183358 102.099758 +L 285.723588 119.938435 +L 286.25804 78.314854 +L 286.786836 60.476176 +L 287.310094 90.207306 +L 287.827931 78.314854 +L 288.340456 90.207306 +L 288.847777 84.26108 +L 289.35 131.830887 +" clip-path="url(#pee8cec0876)" style="fill: none; stroke: #808080; stroke-opacity: 0.05; stroke-linecap: square"/> + + + + + + - - - + + + +L 283.526718 108.045983 +L 284.085056 102.099758 +L 284.637225 54.52995 +L 285.183358 72.368628 +L 285.723588 137.777113 +L 286.25804 96.153532 +L 286.786836 78.314854 +L 287.310094 102.099758 +L 287.827931 102.099758 +L 288.340456 48.583725 +L 288.847777 72.368628 +L 289.35 78.314854 +" clip-path="url(#pee8cec0876)" style="fill: none; stroke: #808080; stroke-opacity: 0.05; stroke-linecap: square"/> - +L 287.827931 60.476176 +L 288.340456 72.368628 +L 288.847777 48.583725 +L 289.35 54.52995 +" clip-path="url(#pee8cec0876)" style="fill: none; stroke: #808080; stroke-opacity: 0.05; stroke-linecap: square"/> - +L 283.526718 90.207306 +L 284.085056 113.992209 +L 284.637225 113.992209 +L 285.183358 72.368628 +L 285.723588 84.26108 +L 286.25804 72.368628 +L 286.786836 84.26108 +L 287.310094 137.777113 +L 287.827931 113.992209 +L 288.340456 78.314854 +L 288.847777 96.153532 +L 289.35 78.314854 +" clip-path="url(#pee8cec0876)" style="fill: none; stroke: #808080; stroke-opacity: 0.05; stroke-linecap: square"/> +L 274.974311 72.368628 +L 275.636185 72.368628 +L 276.289407 72.368628 +L 276.934199 90.207306 +L 277.570778 54.52995 +L 278.199349 78.314854 +L 278.820112 84.26108 +L 279.433258 72.368628 +L 280.038971 54.52995 +L 280.63743 96.153532 +L 281.228807 60.476176 +L 281.813267 96.153532 +L 282.39097 72.368628 +L 282.962071 48.583725 +L 283.526718 60.476176 +L 284.085056 60.476176 +L 284.637225 60.476176 +L 285.183358 78.314854 +L 285.723588 66.422402 +L 286.25804 78.314854 +L 286.786836 60.476176 +L 287.310094 84.26108 +L 287.827931 66.422402 +L 288.340456 60.476176 +L 288.847777 72.368628 +L 289.35 60.476176 +" clip-path="url(#pee8cec0876)" style="fill: none; stroke: #808080; stroke-opacity: 0.05; stroke-linecap: square"/> + + + - - + - - - + + + - - - +L 288.340456 60.476176 +L 288.847777 66.422402 +L 289.35 54.52995 +" clip-path="url(#pee8cec0876)" style="fill: none; stroke: #808080; stroke-opacity: 0.05; stroke-linecap: square"/> - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +" clip-path="url(#pee8cec0876)" style="fill: none; stroke: #0000ff; stroke-width: 1.5; stroke-linecap: square"/> + diff --git a/site/readme_images/run_make_images.py b/site/readme_images/run_make_images.py index c7ec90c..f827a3b 100644 --- a/site/readme_images/run_make_images.py +++ b/site/readme_images/run_make_images.py @@ -1,8 +1,7 @@ -if __name__ == '__main__': - +if __name__ == "__main__": # %% import matplotlib.pyplot as plt - from hobj.benchmarks import MutatorHighVarBenchmark + from hobj import MutatorHighVarBenchmark import numpy as np benchmark = MutatorHighVarBenchmark() @@ -17,34 +16,29 @@ y = target_stats.phat.sel(subtask=subtask) yerr = np.sqrt(target_stats.varhat_phat.sel(subtask=subtask)) plt.plot( - x, y, + x, + y, alpha=0.05, - color='gray', + color="gray", lw=1, ) - glc = target_stats.phat.mean(dim='subtask') - glc_se = target_stats.boot_phat.mean('subtask').std('boot_iter', ddof=1) - - plt.errorbar( - x, - glc, - yerr=glc_se, - color='blue', - label='human average' - ) - plt.axhline(0.5, ls=':', color='black', label='chance', zorder=0) - plt.ylabel('test accuracy') - plt.xscale('log') - plt.xlabel('# examples') - plt.title('Human learning curves') + glc = target_stats.phat.mean(dim="subtask") + glc_se = target_stats.boot_phat.mean("subtask").std("boot_iter", ddof=1) + + plt.errorbar(x, glc, yerr=glc_se, color="blue", label="human average") + plt.axhline(0.5, ls=":", color="black", label="chance", zorder=0) + plt.ylabel("test accuracy") + plt.xscale("log") + plt.xlabel("# examples") + plt.title("Human learning curves") plt.xlim([None, 100]) plt.legend(loc=(1.05, 0.5)) # Remove top and right spines - plt.gca().spines['top'].set_visible(False) - plt.gca().spines['right'].set_visible(False) + plt.gca().spines["top"].set_visible(False) + plt.gca().spines["right"].set_visible(False) plt.tight_layout() - plt.savefig('./human_learning_curves.svg', transparent=True) + plt.savefig("./human_learning_curves.svg", transparent=True) plt.show() diff --git a/tests/test_dummy_learner.py b/tests/test_dummy_learner.py index f164712..ef6bd88 100644 --- a/tests/test_dummy_learner.py +++ b/tests/test_dummy_learner.py @@ -2,18 +2,18 @@ from hobj.learning_models import RandomGuesser + @pytest.fixture def dummy_learner() -> RandomGuesser: return RandomGuesser(seed=0) def test_dummy_learner_deterministic(dummy_learner): - ntests = 10 actions = [] expected_actions = [1, 1, 1, 0, 0, 0, 0, 0, 0, 1] for i in range(ntests): - a = dummy_learner.get_response(image='hi') + a = dummy_learner.get_response(image="hi") actions.append(a) assert actions == expected_actions diff --git a/tests/test_load_behavior.py b/tests/test_load_behavior.py index 83b6c8d..5383b6e 100644 --- a/tests/test_load_behavior.py +++ b/tests/test_load_behavior.py @@ -1,11 +1,70 @@ +import os + +import pytest + from hobj.data_loaders.behavior import load_highvar_behavior, load_oneshot_behavior +from hobj.data_loaders.images import ( + load_image, + load_imageset_meta_catch, + load_imageset_meta_highvar, + load_imageset_meta_oneshot, + load_imageset_meta_warmup, +) + +pytestmark = pytest.mark.skipif( + os.environ.get("GITHUB_ACTIONS") == "true", + reason="Packaged dataset is not available on GitHub Actions runners.", +) def test_load_highvar(): - sessions = load_highvar_behavior() - assert len(sessions) == 3199 + df = load_highvar_behavior() + assert len(df) == 3199 * 100 + assert "image_id" in df.columns + assert "stimulus_id" not in df.columns def test_load_oneshot(): - sessions = load_oneshot_behavior() - assert len(sessions) == 2547 + df = load_oneshot_behavior() + assert len(df) == 2547 * 20 + assert "image_id" in df.columns + assert "stimulus_id" not in df.columns + + +def test_load_highvar_images(): + df = load_imageset_meta_highvar() + assert len(df) == 12800 + assert {"image_id", "category", "sha256", "relpath"} <= set(df.columns) + + +def test_load_oneshot_images(): + df = load_imageset_meta_oneshot() + assert len(df) == 3904 + assert { + "image_id", + "category", + "transformation", + "transformation_level", + "base_image_id", + "sha256", + "relpath", + } <= set(df.columns) + + +def test_load_warmup_images(): + df = load_imageset_meta_warmup() + assert len(df) == 400 + assert {"image_id", "category", "sha256", "relpath"} <= set(df.columns) + + +def test_load_probe_images(): + df = load_imageset_meta_catch() + assert len(df) == 2 + assert {"image_id", "sha256", "relpath"} <= set(df.columns) + + +def test_load_image(): + df = load_imageset_meta_highvar() + image = load_image(df["image_id"].iloc[0]) + assert image.size[0] > 0 + assert image.size[1] > 0 diff --git a/tests/test_simulate_subtask.py b/tests/test_simulate_subtask.py index 3772a21..4f61f15 100644 --- a/tests/test_simulate_subtask.py +++ b/tests/test_simulate_subtask.py @@ -1,6 +1,5 @@ from typing import List -import PIL.Image import numpy as np from hobj.benchmarks.binary_classification.simulation import BinaryClassificationSubtask @@ -12,7 +11,7 @@ def create_image_refs(nimages_per_class: int, seed: int) -> List[ImageId]: images = [] np.random.seed(seed) for i in range(nimages_per_class): - images.append(f'seed{seed}_image{i}') + images.append(f"seed{seed}_image{i}") return images @@ -30,9 +29,6 @@ def test_simulate_subtask(): learner = RandomGuesser(seed=0) - result = subtask.simulate_session( - learner=learner, - seed=0 - ) + result = subtask.simulate_session(learner=learner, seed=0) assert len(result.perf_seq) == ntrials diff --git a/uv.lock b/uv.lock index 8d370d2..8163d59 100644 --- a/uv.lock +++ b/uv.lock @@ -1,10 +1,37 @@ version = 1 revision = 3 -requires-python = ">=3.11, <3.13" +requires-python = ">=3.12" resolution-markers = [ - "sys_platform == 'win32'", - "sys_platform == 'emscripten'", - "sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version >= '3.14' and platform_machine == 'ARM64' and sys_platform == 'win32'", + "python_full_version >= '3.14' and platform_machine != 'ARM64' and sys_platform == 'win32'", + "python_full_version >= '3.14' and sys_platform == 'emscripten'", + "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.13.*' and platform_machine == 'ARM64' and sys_platform == 'win32'", + "python_full_version < '3.13' and platform_machine == 'ARM64' and sys_platform == 'win32'", + "python_full_version == '3.13.*' and platform_machine != 'ARM64' and sys_platform == 'win32'", + "python_full_version < '3.13' and platform_machine != 'ARM64' and sys_platform == 'win32'", + "python_full_version == '3.13.*' and sys_platform == 'emscripten'", + "python_full_version < '3.13' and sys_platform == 'emscripten'", + "python_full_version == '3.13.*' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version < '3.13' and sys_platform != 'emscripten' and sys_platform != 'win32'", +] + +[[package]] +name = "absl-py" +version = "2.4.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/64/c7/8de93764ad66968d19329a7e0c147a2bb3c7054c554d4a119111b8f9440f/absl_py-2.4.0.tar.gz", hash = "sha256:8c6af82722b35cf71e0f4d1d47dcaebfff286e27110a99fc359349b247dfb5d4", size = 116543, upload-time = "2026-01-28T10:17:05.322Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/18/a6/907a406bb7d359e6a63f99c313846d9eec4f7e6f7437809e03aa00fa3074/absl_py-2.4.0-py3-none-any.whl", hash = "sha256:88476fd881ca8aab94ffa78b7b6c632a782ab3ba1cd19c9bd423abc4fb4cd28d", size = 135750, upload-time = "2026-01-28T10:17:04.19Z" }, +] + +[[package]] +name = "annotated-doc" +version = "0.0.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/57/ba/046ceea27344560984e26a590f90bc7f4a75b06701f653222458922b558c/annotated_doc-0.0.4.tar.gz", hash = "sha256:fbcda96e87e9c92ad167c2e53839e57503ecfda18804ea28102353485033faa4", size = 7288, upload-time = "2025-11-10T22:07:42.062Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1e/d3/26bf1008eb3d2daa8ef4cacc7f3bfdc11818d111f7e2d0201bc6e3b49d45/annotated_doc-0.0.4-py3-none-any.whl", hash = "sha256:571ac1dc6991c450b25a9c2d84a3705e2ae7a53467b5d111c24fa8baabbed320", size = 5303, upload-time = "2025-11-10T22:07:40.673Z" }, ] [[package]] @@ -16,6 +43,50 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643, upload-time = "2024-05-20T21:33:24.1Z" }, ] +[[package]] +name = "anyio" +version = "4.13.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "idna" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/19/14/2c5dd9f512b66549ae92767a9c7b330ae88e1932ca57876909410251fe13/anyio-4.13.0.tar.gz", hash = "sha256:334b70e641fd2221c1505b3890c69882fe4a2df910cba14d97019b90b24439dc", size = 231622, upload-time = "2026-03-24T12:59:09.671Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/da/42/e921fccf5015463e32a3cf6ee7f980a6ed0f395ceeaa45060b61d86486c2/anyio-4.13.0-py3-none-any.whl", hash = "sha256:08b310f9e24a9594186fd75b4f73f4a4152069e3853f1ed8bfbf58369f4ad708", size = 114353, upload-time = "2026-03-24T12:59:08.246Z" }, +] + +[[package]] +name = "appnope" +version = "0.1.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/35/5d/752690df9ef5b76e169e68d6a129fa6d08a7100ca7f754c89495db3c6019/appnope-0.1.4.tar.gz", hash = "sha256:1de3860566df9caf38f01f86f65e0e13e379af54f9e4bee1e66b48f2efffd1ee", size = 4170, upload-time = "2024-02-06T09:43:11.258Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/81/29/5ecc3a15d5a33e31b26c11426c45c501e439cb865d0bff96315d86443b78/appnope-0.1.4-py2.py3-none-any.whl", hash = "sha256:502575ee11cd7a28c0205f379b525beefebab9d161b7c964670864014ed7213c", size = 4321, upload-time = "2024-02-06T09:43:09.663Z" }, +] + +[[package]] +name = "asttokens" +version = "3.0.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/be/a5/8e3f9b6771b0b408517c82d97aed8f2036509bc247d46114925e32fe33f0/asttokens-3.0.1.tar.gz", hash = "sha256:71a4ee5de0bde6a31d64f6b13f2293ac190344478f081c3d1bccfcf5eacb0cb7", size = 62308, upload-time = "2025-11-15T16:43:48.578Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d2/39/e7eaf1799466a4aef85b6a4fe7bd175ad2b1c6345066aa33f1f58d4b18d0/asttokens-3.0.1-py3-none-any.whl", hash = "sha256:15a3ebc0f43c2d0a50eeafea25e19046c68398e487b9f1f5b517f7c0f40f976a", size = 27047, upload-time = "2025-11-15T16:43:16.109Z" }, +] + +[[package]] +name = "astunparse" +version = "1.6.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "six" }, + { name = "wheel" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f3/af/4182184d3c338792894f34a62672919db7ca008c89abee9b564dd34d8029/astunparse-1.6.3.tar.gz", hash = "sha256:5ad93a8456f0d084c3456d059fd9a92cce667963232cbf763eac3bc5b7940872", size = 18290, upload-time = "2019-12-22T18:12:13.129Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2b/03/13dde6512ad7b4557eb792fbcf0c653af6076b81e5941d36ec61f7ce6028/astunparse-1.6.3-py2.py3-none-any.whl", hash = "sha256:c2652417f2c8b5bb325c885ae329bdf3f86424075c4fd1a128674bc6fba4b8e8", size = 12732, upload-time = "2019-12-22T18:12:11.297Z" }, +] + [[package]] name = "certifi" version = "2026.2.25" @@ -25,28 +96,107 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/9a/3c/c17fb3ca2d9c3acff52e30b309f538586f9f5b9c9cf454f3845fc9af4881/certifi-2026.2.25-py3-none-any.whl", hash = "sha256:027692e4402ad994f1c42e52a4997a9763c646b73e4096e4d5d6db8af1d6f0fa", size = 153684, upload-time = "2026-02-25T02:54:15.766Z" }, ] +[[package]] +name = "cffi" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pycparser", marker = "implementation_name != 'PyPy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/eb/56/b1ba7935a17738ae8453301356628e8147c79dbb825bcbc73dc7401f9846/cffi-2.0.0.tar.gz", hash = "sha256:44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529", size = 523588, upload-time = "2025-09-08T23:24:04.541Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ea/47/4f61023ea636104d4f16ab488e268b93008c3d0bb76893b1b31db1f96802/cffi-2.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6d02d6655b0e54f54c4ef0b94eb6be0607b70853c45ce98bd278dc7de718be5d", size = 185271, upload-time = "2025-09-08T23:22:44.795Z" }, + { url = "https://files.pythonhosted.org/packages/df/a2/781b623f57358e360d62cdd7a8c681f074a71d445418a776eef0aadb4ab4/cffi-2.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8eca2a813c1cb7ad4fb74d368c2ffbbb4789d377ee5bb8df98373c2cc0dee76c", size = 181048, upload-time = "2025-09-08T23:22:45.938Z" }, + { url = "https://files.pythonhosted.org/packages/ff/df/a4f0fbd47331ceeba3d37c2e51e9dfc9722498becbeec2bd8bc856c9538a/cffi-2.0.0-cp312-cp312-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:21d1152871b019407d8ac3985f6775c079416c282e431a4da6afe7aefd2bccbe", size = 212529, upload-time = "2025-09-08T23:22:47.349Z" }, + { url = "https://files.pythonhosted.org/packages/d5/72/12b5f8d3865bf0f87cf1404d8c374e7487dcf097a1c91c436e72e6badd83/cffi-2.0.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:b21e08af67b8a103c71a250401c78d5e0893beff75e28c53c98f4de42f774062", size = 220097, upload-time = "2025-09-08T23:22:48.677Z" }, + { url = "https://files.pythonhosted.org/packages/c2/95/7a135d52a50dfa7c882ab0ac17e8dc11cec9d55d2c18dda414c051c5e69e/cffi-2.0.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:1e3a615586f05fc4065a8b22b8152f0c1b00cdbc60596d187c2a74f9e3036e4e", size = 207983, upload-time = "2025-09-08T23:22:50.06Z" }, + { url = "https://files.pythonhosted.org/packages/3a/c8/15cb9ada8895957ea171c62dc78ff3e99159ee7adb13c0123c001a2546c1/cffi-2.0.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:81afed14892743bbe14dacb9e36d9e0e504cd204e0b165062c488942b9718037", size = 206519, upload-time = "2025-09-08T23:22:51.364Z" }, + { url = "https://files.pythonhosted.org/packages/78/2d/7fa73dfa841b5ac06c7b8855cfc18622132e365f5b81d02230333ff26e9e/cffi-2.0.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3e17ed538242334bf70832644a32a7aae3d83b57567f9fd60a26257e992b79ba", size = 219572, upload-time = "2025-09-08T23:22:52.902Z" }, + { url = "https://files.pythonhosted.org/packages/07/e0/267e57e387b4ca276b90f0434ff88b2c2241ad72b16d31836adddfd6031b/cffi-2.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3925dd22fa2b7699ed2617149842d2e6adde22b262fcbfada50e3d195e4b3a94", size = 222963, upload-time = "2025-09-08T23:22:54.518Z" }, + { url = "https://files.pythonhosted.org/packages/b6/75/1f2747525e06f53efbd878f4d03bac5b859cbc11c633d0fb81432d98a795/cffi-2.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:2c8f814d84194c9ea681642fd164267891702542f028a15fc97d4674b6206187", size = 221361, upload-time = "2025-09-08T23:22:55.867Z" }, + { url = "https://files.pythonhosted.org/packages/7b/2b/2b6435f76bfeb6bbf055596976da087377ede68df465419d192acf00c437/cffi-2.0.0-cp312-cp312-win32.whl", hash = "sha256:da902562c3e9c550df360bfa53c035b2f241fed6d9aef119048073680ace4a18", size = 172932, upload-time = "2025-09-08T23:22:57.188Z" }, + { url = "https://files.pythonhosted.org/packages/f8/ed/13bd4418627013bec4ed6e54283b1959cf6db888048c7cf4b4c3b5b36002/cffi-2.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:da68248800ad6320861f129cd9c1bf96ca849a2771a59e0344e88681905916f5", size = 183557, upload-time = "2025-09-08T23:22:58.351Z" }, + { url = "https://files.pythonhosted.org/packages/95/31/9f7f93ad2f8eff1dbc1c3656d7ca5bfd8fb52c9d786b4dcf19b2d02217fa/cffi-2.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:4671d9dd5ec934cb9a73e7ee9676f9362aba54f7f34910956b84d727b0d73fb6", size = 177762, upload-time = "2025-09-08T23:22:59.668Z" }, + { url = "https://files.pythonhosted.org/packages/4b/8d/a0a47a0c9e413a658623d014e91e74a50cdd2c423f7ccfd44086ef767f90/cffi-2.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:00bdf7acc5f795150faa6957054fbbca2439db2f775ce831222b66f192f03beb", size = 185230, upload-time = "2025-09-08T23:23:00.879Z" }, + { url = "https://files.pythonhosted.org/packages/4a/d2/a6c0296814556c68ee32009d9c2ad4f85f2707cdecfd7727951ec228005d/cffi-2.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:45d5e886156860dc35862657e1494b9bae8dfa63bf56796f2fb56e1679fc0bca", size = 181043, upload-time = "2025-09-08T23:23:02.231Z" }, + { url = "https://files.pythonhosted.org/packages/b0/1e/d22cc63332bd59b06481ceaac49d6c507598642e2230f201649058a7e704/cffi-2.0.0-cp313-cp313-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:07b271772c100085dd28b74fa0cd81c8fb1a3ba18b21e03d7c27f3436a10606b", size = 212446, upload-time = "2025-09-08T23:23:03.472Z" }, + { url = "https://files.pythonhosted.org/packages/a9/f5/a2c23eb03b61a0b8747f211eb716446c826ad66818ddc7810cc2cc19b3f2/cffi-2.0.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d48a880098c96020b02d5a1f7d9251308510ce8858940e6fa99ece33f610838b", size = 220101, upload-time = "2025-09-08T23:23:04.792Z" }, + { url = "https://files.pythonhosted.org/packages/f2/7f/e6647792fc5850d634695bc0e6ab4111ae88e89981d35ac269956605feba/cffi-2.0.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:f93fd8e5c8c0a4aa1f424d6173f14a892044054871c771f8566e4008eaa359d2", size = 207948, upload-time = "2025-09-08T23:23:06.127Z" }, + { url = "https://files.pythonhosted.org/packages/cb/1e/a5a1bd6f1fb30f22573f76533de12a00bf274abcdc55c8edab639078abb6/cffi-2.0.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:dd4f05f54a52fb558f1ba9f528228066954fee3ebe629fc1660d874d040ae5a3", size = 206422, upload-time = "2025-09-08T23:23:07.753Z" }, + { url = "https://files.pythonhosted.org/packages/98/df/0a1755e750013a2081e863e7cd37e0cdd02664372c754e5560099eb7aa44/cffi-2.0.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c8d3b5532fc71b7a77c09192b4a5a200ea992702734a2e9279a37f2478236f26", size = 219499, upload-time = "2025-09-08T23:23:09.648Z" }, + { url = "https://files.pythonhosted.org/packages/50/e1/a969e687fcf9ea58e6e2a928ad5e2dd88cc12f6f0ab477e9971f2309b57c/cffi-2.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d9b29c1f0ae438d5ee9acb31cadee00a58c46cc9c0b2f9038c6b0b3470877a8c", size = 222928, upload-time = "2025-09-08T23:23:10.928Z" }, + { url = "https://files.pythonhosted.org/packages/36/54/0362578dd2c9e557a28ac77698ed67323ed5b9775ca9d3fe73fe191bb5d8/cffi-2.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6d50360be4546678fc1b79ffe7a66265e28667840010348dd69a314145807a1b", size = 221302, upload-time = "2025-09-08T23:23:12.42Z" }, + { url = "https://files.pythonhosted.org/packages/eb/6d/bf9bda840d5f1dfdbf0feca87fbdb64a918a69bca42cfa0ba7b137c48cb8/cffi-2.0.0-cp313-cp313-win32.whl", hash = "sha256:74a03b9698e198d47562765773b4a8309919089150a0bb17d829ad7b44b60d27", size = 172909, upload-time = "2025-09-08T23:23:14.32Z" }, + { url = "https://files.pythonhosted.org/packages/37/18/6519e1ee6f5a1e579e04b9ddb6f1676c17368a7aba48299c3759bbc3c8b3/cffi-2.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:19f705ada2530c1167abacb171925dd886168931e0a7b78f5bffcae5c6b5be75", size = 183402, upload-time = "2025-09-08T23:23:15.535Z" }, + { url = "https://files.pythonhosted.org/packages/cb/0e/02ceeec9a7d6ee63bb596121c2c8e9b3a9e150936f4fbef6ca1943e6137c/cffi-2.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:256f80b80ca3853f90c21b23ee78cd008713787b1b1e93eae9f3d6a7134abd91", size = 177780, upload-time = "2025-09-08T23:23:16.761Z" }, + { url = "https://files.pythonhosted.org/packages/92/c4/3ce07396253a83250ee98564f8d7e9789fab8e58858f35d07a9a2c78de9f/cffi-2.0.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fc33c5141b55ed366cfaad382df24fe7dcbc686de5be719b207bb248e3053dc5", size = 185320, upload-time = "2025-09-08T23:23:18.087Z" }, + { url = "https://files.pythonhosted.org/packages/59/dd/27e9fa567a23931c838c6b02d0764611c62290062a6d4e8ff7863daf9730/cffi-2.0.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c654de545946e0db659b3400168c9ad31b5d29593291482c43e3564effbcee13", size = 181487, upload-time = "2025-09-08T23:23:19.622Z" }, + { url = "https://files.pythonhosted.org/packages/d6/43/0e822876f87ea8a4ef95442c3d766a06a51fc5298823f884ef87aaad168c/cffi-2.0.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:24b6f81f1983e6df8db3adc38562c83f7d4a0c36162885ec7f7b77c7dcbec97b", size = 220049, upload-time = "2025-09-08T23:23:20.853Z" }, + { url = "https://files.pythonhosted.org/packages/b4/89/76799151d9c2d2d1ead63c2429da9ea9d7aac304603de0c6e8764e6e8e70/cffi-2.0.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:12873ca6cb9b0f0d3a0da705d6086fe911591737a59f28b7936bdfed27c0d47c", size = 207793, upload-time = "2025-09-08T23:23:22.08Z" }, + { url = "https://files.pythonhosted.org/packages/bb/dd/3465b14bb9e24ee24cb88c9e3730f6de63111fffe513492bf8c808a3547e/cffi-2.0.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:d9b97165e8aed9272a6bb17c01e3cc5871a594a446ebedc996e2397a1c1ea8ef", size = 206300, upload-time = "2025-09-08T23:23:23.314Z" }, + { url = "https://files.pythonhosted.org/packages/47/d9/d83e293854571c877a92da46fdec39158f8d7e68da75bf73581225d28e90/cffi-2.0.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:afb8db5439b81cf9c9d0c80404b60c3cc9c3add93e114dcae767f1477cb53775", size = 219244, upload-time = "2025-09-08T23:23:24.541Z" }, + { url = "https://files.pythonhosted.org/packages/2b/0f/1f177e3683aead2bb00f7679a16451d302c436b5cbf2505f0ea8146ef59e/cffi-2.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:737fe7d37e1a1bffe70bd5754ea763a62a066dc5913ca57e957824b72a85e205", size = 222828, upload-time = "2025-09-08T23:23:26.143Z" }, + { url = "https://files.pythonhosted.org/packages/c6/0f/cafacebd4b040e3119dcb32fed8bdef8dfe94da653155f9d0b9dc660166e/cffi-2.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:38100abb9d1b1435bc4cc340bb4489635dc2f0da7456590877030c9b3d40b0c1", size = 220926, upload-time = "2025-09-08T23:23:27.873Z" }, + { url = "https://files.pythonhosted.org/packages/3e/aa/df335faa45b395396fcbc03de2dfcab242cd61a9900e914fe682a59170b1/cffi-2.0.0-cp314-cp314-win32.whl", hash = "sha256:087067fa8953339c723661eda6b54bc98c5625757ea62e95eb4898ad5e776e9f", size = 175328, upload-time = "2025-09-08T23:23:44.61Z" }, + { url = "https://files.pythonhosted.org/packages/bb/92/882c2d30831744296ce713f0feb4c1cd30f346ef747b530b5318715cc367/cffi-2.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:203a48d1fb583fc7d78a4c6655692963b860a417c0528492a6bc21f1aaefab25", size = 185650, upload-time = "2025-09-08T23:23:45.848Z" }, + { url = "https://files.pythonhosted.org/packages/9f/2c/98ece204b9d35a7366b5b2c6539c350313ca13932143e79dc133ba757104/cffi-2.0.0-cp314-cp314-win_arm64.whl", hash = "sha256:dbd5c7a25a7cb98f5ca55d258b103a2054f859a46ae11aaf23134f9cc0d356ad", size = 180687, upload-time = "2025-09-08T23:23:47.105Z" }, + { url = "https://files.pythonhosted.org/packages/3e/61/c768e4d548bfa607abcda77423448df8c471f25dbe64fb2ef6d555eae006/cffi-2.0.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:9a67fc9e8eb39039280526379fb3a70023d77caec1852002b4da7e8b270c4dd9", size = 188773, upload-time = "2025-09-08T23:23:29.347Z" }, + { url = "https://files.pythonhosted.org/packages/2c/ea/5f76bce7cf6fcd0ab1a1058b5af899bfbef198bea4d5686da88471ea0336/cffi-2.0.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7a66c7204d8869299919db4d5069a82f1561581af12b11b3c9f48c584eb8743d", size = 185013, upload-time = "2025-09-08T23:23:30.63Z" }, + { url = "https://files.pythonhosted.org/packages/be/b4/c56878d0d1755cf9caa54ba71e5d049479c52f9e4afc230f06822162ab2f/cffi-2.0.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7cc09976e8b56f8cebd752f7113ad07752461f48a58cbba644139015ac24954c", size = 221593, upload-time = "2025-09-08T23:23:31.91Z" }, + { url = "https://files.pythonhosted.org/packages/e0/0d/eb704606dfe8033e7128df5e90fee946bbcb64a04fcdaa97321309004000/cffi-2.0.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:92b68146a71df78564e4ef48af17551a5ddd142e5190cdf2c5624d0c3ff5b2e8", size = 209354, upload-time = "2025-09-08T23:23:33.214Z" }, + { url = "https://files.pythonhosted.org/packages/d8/19/3c435d727b368ca475fb8742ab97c9cb13a0de600ce86f62eab7fa3eea60/cffi-2.0.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:b1e74d11748e7e98e2f426ab176d4ed720a64412b6a15054378afdb71e0f37dc", size = 208480, upload-time = "2025-09-08T23:23:34.495Z" }, + { url = "https://files.pythonhosted.org/packages/d0/44/681604464ed9541673e486521497406fadcc15b5217c3e326b061696899a/cffi-2.0.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:28a3a209b96630bca57cce802da70c266eb08c6e97e5afd61a75611ee6c64592", size = 221584, upload-time = "2025-09-08T23:23:36.096Z" }, + { url = "https://files.pythonhosted.org/packages/25/8e/342a504ff018a2825d395d44d63a767dd8ebc927ebda557fecdaca3ac33a/cffi-2.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:7553fb2090d71822f02c629afe6042c299edf91ba1bf94951165613553984512", size = 224443, upload-time = "2025-09-08T23:23:37.328Z" }, + { url = "https://files.pythonhosted.org/packages/e1/5e/b666bacbbc60fbf415ba9988324a132c9a7a0448a9a8f125074671c0f2c3/cffi-2.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6c6c373cfc5c83a975506110d17457138c8c63016b563cc9ed6e056a82f13ce4", size = 223437, upload-time = "2025-09-08T23:23:38.945Z" }, + { url = "https://files.pythonhosted.org/packages/a0/1d/ec1a60bd1a10daa292d3cd6bb0b359a81607154fb8165f3ec95fe003b85c/cffi-2.0.0-cp314-cp314t-win32.whl", hash = "sha256:1fc9ea04857caf665289b7a75923f2c6ed559b8298a1b8c49e59f7dd95c8481e", size = 180487, upload-time = "2025-09-08T23:23:40.423Z" }, + { url = "https://files.pythonhosted.org/packages/bf/41/4c1168c74fac325c0c8156f04b6749c8b6a8f405bbf91413ba088359f60d/cffi-2.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:d68b6cef7827e8641e8ef16f4494edda8b36104d79773a334beaa1e3521430f6", size = 191726, upload-time = "2025-09-08T23:23:41.742Z" }, + { url = "https://files.pythonhosted.org/packages/ae/3a/dbeec9d1ee0844c679f6bb5d6ad4e9f198b1224f4e7a32825f47f6192b0c/cffi-2.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:0a1527a803f0a659de1af2e1fd700213caba79377e27e4693648c2923da066f9", size = 184195, upload-time = "2025-09-08T23:23:43.004Z" }, +] + +[[package]] +name = "cftime" +version = "1.6.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/65/dc/470ffebac2eb8c54151eb893055024fe81b1606e7c6ff8449a588e9cd17f/cftime-1.6.5.tar.gz", hash = "sha256:8225fed6b9b43fb87683ebab52130450fc1730011150d3092096a90e54d1e81e", size = 326605, upload-time = "2025-10-13T18:56:26.352Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b6/c1/e8cb7f78a3f87295450e7300ebaecf83076d96a99a76190593d4e1d2be40/cftime-1.6.5-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:eef25caed5ebd003a38719bd3ff8847cd52ef2ea56c3ebdb2c9345ba131fc7c5", size = 504175, upload-time = "2025-10-13T18:56:06.398Z" }, + { url = "https://files.pythonhosted.org/packages/50/1a/86e1072b09b2f9049bb7378869f64b6747f96a4f3008142afed8955b52a4/cftime-1.6.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c87d2f3b949e45463e559233c69e6a9cf691b2b378c1f7556166adfabbd1c6b0", size = 485980, upload-time = "2025-10-13T18:56:08.669Z" }, + { url = "https://files.pythonhosted.org/packages/35/28/d3177b60da3f308b60dee2aef2eb69997acfab1e863f0bf0d2a418396ce5/cftime-1.6.5-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:82cb413973cc51b55642b3a1ca5b28db5b93a294edbef7dc049c074b478b4647", size = 1591166, upload-time = "2025-10-13T19:39:14.109Z" }, + { url = "https://files.pythonhosted.org/packages/d1/fd/a7266970312df65e68b5641b86e0540a739182f5e9c62eec6dbd29f18055/cftime-1.6.5-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:85ba8e7356d239cfe56ef7707ac30feaf67964642ac760a82e507ee3c5db4ac4", size = 1642614, upload-time = "2025-10-13T18:56:09.815Z" }, + { url = "https://files.pythonhosted.org/packages/c4/73/f0035a4bc2df8885bb7bd5fe63659686ea1ec7d0cc74b4e3d50e447402e5/cftime-1.6.5-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:456039af7907a3146689bb80bfd8edabd074c7f3b4eca61f91b9c2670addd7ad", size = 1688090, upload-time = "2025-10-13T18:56:11.442Z" }, + { url = "https://files.pythonhosted.org/packages/88/15/8856a0ab76708553ff597dd2e617b088c734ba87dc3fd395e2b2f3efffe8/cftime-1.6.5-cp312-cp312-win_amd64.whl", hash = "sha256:da84534c43699960dc980a9a765c33433c5de1a719a4916748c2d0e97a071e44", size = 464840, upload-time = "2025-10-13T18:56:12.506Z" }, + { url = "https://files.pythonhosted.org/packages/3a/85/451009a986d9273d2208fc0898aa00262275b5773259bf3f942f6716a9e7/cftime-1.6.5-cp312-cp312-win_arm64.whl", hash = "sha256:c62cd8db9ea40131eea7d4523691c5d806d3265d31279e4a58574a42c28acd77", size = 450534, upload-time = "2026-01-02T21:16:48.784Z" }, + { url = "https://files.pythonhosted.org/packages/2e/60/74ea344b3b003fada346ed98a6899085d6fd4c777df608992d90c458fda6/cftime-1.6.5-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4aba66fd6497711a47c656f3a732c2d1755ad15f80e323c44a8716ebde39ddd5", size = 502453, upload-time = "2025-10-13T18:56:13.545Z" }, + { url = "https://files.pythonhosted.org/packages/1e/14/adb293ac6127079b49ff11c05cf3d5ce5c1f17d097f326dc02d74ddfcb6e/cftime-1.6.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:89e7cba699242366e67d6fb5aee579440e791063f92a93853610c91647167c0d", size = 484541, upload-time = "2025-10-13T18:56:14.612Z" }, + { url = "https://files.pythonhosted.org/packages/4f/74/bb8a4566af8d0ef3f045d56c462a9115da4f04b07c7fbbf2b4875223eebd/cftime-1.6.5-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:2f1eb43d7a7b919ec99aee709fb62ef87ef1cf0679829ef93d37cc1c725781e9", size = 1591014, upload-time = "2025-10-13T19:39:15.346Z" }, + { url = "https://files.pythonhosted.org/packages/ba/08/52f06ff2f04d376f9cd2c211aefcf2b37f1978e43289341f362fc99f6a0e/cftime-1.6.5-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e02a1d80ffc33fe469c7db68aa24c4a87f01da0c0c621373e5edadc92964900b", size = 1633625, upload-time = "2025-10-13T18:56:15.745Z" }, + { url = "https://files.pythonhosted.org/packages/cf/33/03e0b23d58ea8fab94ecb4f7c5b721e844a0800c13694876149d98830a73/cftime-1.6.5-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:18ab754805233cdd889614b2b3b86a642f6d51a57a1ec327c48053f3414f87d8", size = 1684269, upload-time = "2025-10-13T18:56:17.04Z" }, + { url = "https://files.pythonhosted.org/packages/a4/60/a0cfba63847b43599ef1cdbbf682e61894994c22b9a79fd9e1e8c7e9de41/cftime-1.6.5-cp313-cp313-win_amd64.whl", hash = "sha256:6c27add8f907f4a4cd400e89438f2ea33e2eb5072541a157a4d013b7dbe93f9c", size = 465364, upload-time = "2025-10-13T18:56:18.05Z" }, + { url = "https://files.pythonhosted.org/packages/3d/e8/ec32f2aef22c15604e6fda39ff8d581a00b5469349f8fba61640d5358d2c/cftime-1.6.5-cp313-cp313-win_arm64.whl", hash = "sha256:31d1ff8f6bbd4ca209099d24459ec16dea4fb4c9ab740fbb66dd057ccbd9b1b9", size = 450468, upload-time = "2026-01-02T21:16:50.193Z" }, + { url = "https://files.pythonhosted.org/packages/ea/6c/a9618f589688358e279720f5c0fe67ef0077fba07334ce26895403ebc260/cftime-1.6.5-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:c69ce3bdae6a322cbb44e9ebc20770d47748002fb9d68846a1e934f1bd5daf0b", size = 502725, upload-time = "2025-10-13T18:56:19.424Z" }, + { url = "https://files.pythonhosted.org/packages/d8/e3/da3c36398bfb730b96248d006cabaceed87e401ff56edafb2a978293e228/cftime-1.6.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:e62e9f2943e014c5ef583245bf2e878398af131c97e64f8cd47c1d7baef5c4e2", size = 485445, upload-time = "2025-10-13T18:56:20.853Z" }, + { url = "https://files.pythonhosted.org/packages/32/93/b05939e5abd14bd1ab69538bbe374b4ee2a15467b189ff895e9a8cdaddf6/cftime-1.6.5-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7da5fdaa4360d8cb89b71b8ded9314f2246aa34581e8105c94ad58d6102d9e4f", size = 1584434, upload-time = "2025-10-13T19:39:17.084Z" }, + { url = "https://files.pythonhosted.org/packages/7f/89/648397f9936e0b330999c4e776ebf296ec3c6a65f9901687dbca4ab820da/cftime-1.6.5-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:bff865b4ea4304f2744a1ad2b8149b8328b321dd7a2b9746ef926d229bd7cd49", size = 1609812, upload-time = "2025-10-13T18:56:21.971Z" }, + { url = "https://files.pythonhosted.org/packages/e7/0f/901b4835aa67ad3e915605d4e01d0af80a44b114eefab74ae33de6d36933/cftime-1.6.5-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:e552c5d1c8a58f25af7521e49237db7ca52ed2953e974fe9f7c4491e95fdd36c", size = 1669768, upload-time = "2025-10-13T18:56:24.027Z" }, + { url = "https://files.pythonhosted.org/packages/22/d5/e605e4b28363e7a9ae98ed12cabbda5b155b6009270e6a231d8f10182a17/cftime-1.6.5-cp314-cp314-win_amd64.whl", hash = "sha256:e645b095dc50a38ac454b7e7f0742f639e7d7f6b108ad329358544a6ff8c9ba2", size = 463818, upload-time = "2025-10-13T18:56:25.376Z" }, + { url = "https://files.pythonhosted.org/packages/3d/89/a8f85ae697ff10206ec401c2621f5ca9f327554f586d62f244739ceeb347/cftime-1.6.5-cp314-cp314-win_arm64.whl", hash = "sha256:b9044d7ac82d3d8af189df1032fdc871bbd3f3dd41a6ec79edceb5029b71e6e0", size = 459862, upload-time = "2026-01-02T20:45:02.625Z" }, + { url = "https://files.pythonhosted.org/packages/ab/05/7410e12fd03a0c52717e74e6a1b49958810807dda212e23b65d43ea99676/cftime-1.6.5-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:9ef56460cb0576e1a9161e1428c9e1a633f809a23fa9d598f313748c1ae5064e", size = 533781, upload-time = "2026-01-02T20:45:04.818Z" }, + { url = "https://files.pythonhosted.org/packages/44/ba/10e3546426d3ed9f9cc82e4a99836bb6fac1642c7830f7bdd0ac1c3f0805/cftime-1.6.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:4f4873d38b10032f9f3111c547a1d485519ae64eee6a7a2d091f1f8b08e1ba50", size = 515218, upload-time = "2026-01-02T20:45:06.788Z" }, + { url = "https://files.pythonhosted.org/packages/bd/68/efa11eae867749e921bfec6a865afdba8166e96188112dde70bb8bb49254/cftime-1.6.5-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ccce0f4c9d3f38dd948a117e578b50d0e0db11e2ca9435fb358fd524813e4b61", size = 1579932, upload-time = "2026-01-02T20:45:11.194Z" }, + { url = "https://files.pythonhosted.org/packages/9d/6c/0971e602c1390a423e6621dfbad9f1d375186bdaf9c9c7f75e06f1fbf355/cftime-1.6.5-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:19cbfc5152fb0b34ce03acf9668229af388d7baa63a78f936239cb011ccbe6b1", size = 1555894, upload-time = "2026-01-02T20:45:16.351Z" }, + { url = "https://files.pythonhosted.org/packages/ad/fc/8475a15b7c3209a4a68b563dfc5e01ce74f2d8b9822372c3d30c68ab7f39/cftime-1.6.5-cp314-cp314t-win_amd64.whl", hash = "sha256:4470cd5ef3c2514566f53efbcbb64dd924fa0584637d90285b2f983bd4ee7d97", size = 513027, upload-time = "2026-01-02T20:45:20.023Z" }, + { url = "https://files.pythonhosted.org/packages/f7/80/4ecbda8318fbf40ad4e005a4a93aebba69e81382e5b4c6086251cd5d0ee8/cftime-1.6.5-cp314-cp314t-win_arm64.whl", hash = "sha256:034c15a67144a0a5590ef150c99f844897618b148b87131ed34fda7072614662", size = 469065, upload-time = "2026-01-02T20:45:23.398Z" }, +] + [[package]] name = "charset-normalizer" version = "3.4.6" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/7b/60/e3bec1881450851b087e301bedc3daa9377a4d45f1c26aa90b0b235e38aa/charset_normalizer-3.4.6.tar.gz", hash = "sha256:1ae6b62897110aa7c79ea2f5dd38d1abca6db663687c0b1ad9aed6f6bae3d9d6", size = 143363, upload-time = "2026-03-15T18:53:25.478Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/62/28/ff6f234e628a2de61c458be2779cb182bc03f6eec12200d4a525bbfc9741/charset_normalizer-3.4.6-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:82060f995ab5003a2d6e0f4ad29065b7672b6593c8c63559beefe5b443242c3e", size = 293582, upload-time = "2026-03-15T18:50:25.454Z" }, - { url = "https://files.pythonhosted.org/packages/1c/b7/b1a117e5385cbdb3205f6055403c2a2a220c5ea80b8716c324eaf75c5c95/charset_normalizer-3.4.6-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:60c74963d8350241a79cb8feea80e54d518f72c26db618862a8f53e5023deaf9", size = 197240, upload-time = "2026-03-15T18:50:27.196Z" }, - { url = "https://files.pythonhosted.org/packages/a1/5f/2574f0f09f3c3bc1b2f992e20bce6546cb1f17e111c5be07308dc5427956/charset_normalizer-3.4.6-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f6e4333fb15c83f7d1482a76d45a0818897b3d33f00efd215528ff7c51b8e35d", size = 217363, upload-time = "2026-03-15T18:50:28.601Z" }, - { url = "https://files.pythonhosted.org/packages/4a/d1/0ae20ad77bc949ddd39b51bf383b6ca932f2916074c95cad34ae465ab71f/charset_normalizer-3.4.6-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:bc72863f4d9aba2e8fd9085e63548a324ba706d2ea2c83b260da08a59b9482de", size = 212994, upload-time = "2026-03-15T18:50:30.102Z" }, - { url = "https://files.pythonhosted.org/packages/60/ac/3233d262a310c1b12633536a07cde5ddd16985e6e7e238e9f3f9423d8eb9/charset_normalizer-3.4.6-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9cc4fc6c196d6a8b76629a70ddfcd4635a6898756e2d9cac5565cf0654605d73", size = 204697, upload-time = "2026-03-15T18:50:31.654Z" }, - { url = "https://files.pythonhosted.org/packages/25/3c/8a18fc411f085b82303cfb7154eed5bd49c77035eb7608d049468b53f87c/charset_normalizer-3.4.6-cp311-cp311-manylinux_2_31_armv7l.whl", hash = "sha256:0c173ce3a681f309f31b87125fecec7a5d1347261ea11ebbb856fa6006b23c8c", size = 191673, upload-time = "2026-03-15T18:50:33.433Z" }, - { url = "https://files.pythonhosted.org/packages/ff/a7/11cfe61d6c5c5c7438d6ba40919d0306ed83c9ab957f3d4da2277ff67836/charset_normalizer-3.4.6-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c907cdc8109f6c619e6254212e794d6548373cc40e1ec75e6e3823d9135d29cc", size = 201120, upload-time = "2026-03-15T18:50:35.105Z" }, - { url = "https://files.pythonhosted.org/packages/b5/10/cf491fa1abd47c02f69687046b896c950b92b6cd7337a27e6548adbec8e4/charset_normalizer-3.4.6-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:404a1e552cf5b675a87f0651f8b79f5f1e6fd100ee88dc612f89aa16abd4486f", size = 200911, upload-time = "2026-03-15T18:50:36.819Z" }, - { url = "https://files.pythonhosted.org/packages/28/70/039796160b48b18ed466fde0af84c1b090c4e288fae26cd674ad04a2d703/charset_normalizer-3.4.6-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:e3c701e954abf6fc03a49f7c579cc80c2c6cc52525340ca3186c41d3f33482ef", size = 192516, upload-time = "2026-03-15T18:50:38.228Z" }, - { url = "https://files.pythonhosted.org/packages/ff/34/c56f3223393d6ff3124b9e78f7de738047c2d6bc40a4f16ac0c9d7a1cb3c/charset_normalizer-3.4.6-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:7a6967aaf043bceabab5412ed6bd6bd26603dae84d5cb75bf8d9a74a4959d398", size = 218795, upload-time = "2026-03-15T18:50:39.664Z" }, - { url = "https://files.pythonhosted.org/packages/e8/3b/ce2d4f86c5282191a041fdc5a4ce18f1c6bd40a5bd1f74cf8625f08d51c1/charset_normalizer-3.4.6-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:5feb91325bbceade6afab43eb3b508c63ee53579fe896c77137ded51c6b6958e", size = 201833, upload-time = "2026-03-15T18:50:41.552Z" }, - { url = "https://files.pythonhosted.org/packages/3b/9b/b6a9f76b0fd7c5b5ec58b228ff7e85095370282150f0bd50b3126f5506d6/charset_normalizer-3.4.6-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:f820f24b09e3e779fe84c3c456cb4108a7aa639b0d1f02c28046e11bfcd088ed", size = 213920, upload-time = "2026-03-15T18:50:43.33Z" }, - { url = "https://files.pythonhosted.org/packages/ae/98/7bc23513a33d8172365ed30ee3a3b3fe1ece14a395e5fc94129541fc6003/charset_normalizer-3.4.6-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:b35b200d6a71b9839a46b9b7fff66b6638bb52fc9658aa58796b0326595d3021", size = 206951, upload-time = "2026-03-15T18:50:44.789Z" }, - { url = "https://files.pythonhosted.org/packages/32/73/c0b86f3d1458468e11aec870e6b3feac931facbe105a894b552b0e518e79/charset_normalizer-3.4.6-cp311-cp311-win32.whl", hash = "sha256:9ca4c0b502ab399ef89248a2c84c54954f77a070f28e546a85e91da627d1301e", size = 143703, upload-time = "2026-03-15T18:50:46.103Z" }, - { url = "https://files.pythonhosted.org/packages/c6/e3/76f2facfe8eddee0bbd38d2594e709033338eae44ebf1738bcefe0a06185/charset_normalizer-3.4.6-cp311-cp311-win_amd64.whl", hash = "sha256:a9e68c9d88823b274cf1e72f28cb5dc89c990edf430b0bfd3e2fb0785bfeabf4", size = 153857, upload-time = "2026-03-15T18:50:47.563Z" }, - { url = "https://files.pythonhosted.org/packages/e2/dc/9abe19c9b27e6cd3636036b9d1b387b78c40dedbf0b47f9366737684b4b0/charset_normalizer-3.4.6-cp311-cp311-win_arm64.whl", hash = "sha256:97d0235baafca5f2b09cf332cc275f021e694e8362c6bb9c96fc9a0eb74fc316", size = 142751, upload-time = "2026-03-15T18:50:49.234Z" }, { url = "https://files.pythonhosted.org/packages/e5/62/c0815c992c9545347aeea7859b50dc9044d147e2e7278329c6e02ac9a616/charset_normalizer-3.4.6-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:2ef7fedc7a6ecbe99969cd09632516738a97eeb8bd7258bf8a0f23114c057dab", size = 295154, upload-time = "2026-03-15T18:50:50.88Z" }, { url = "https://files.pythonhosted.org/packages/a8/37/bdca6613c2e3c58c7421891d80cc3efa1d32e882f7c4a7ee6039c3fc951a/charset_normalizer-3.4.6-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a4ea868bc28109052790eb2b52a9ab33f3aa7adc02f96673526ff47419490e21", size = 199191, upload-time = "2026-03-15T18:50:52.658Z" }, { url = "https://files.pythonhosted.org/packages/6c/92/9934d1bbd69f7f398b38c5dae1cbf9cc672e7c34a4adf7b17c0a9c17d15d/charset_normalizer-3.4.6-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:836ab36280f21fc1a03c99cd05c6b7af70d2697e374c7af0b61ed271401a72a2", size = 218674, upload-time = "2026-03-15T18:50:54.102Z" }, @@ -63,9 +213,75 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/6c/18/c094561b5d64a24277707698e54b7f67bd17a4f857bbfbb1072bba07c8bf/charset_normalizer-3.4.6-cp312-cp312-win32.whl", hash = "sha256:c2274ca724536f173122f36c98ce188fd24ce3dad886ec2b7af859518ce008a4", size = 144229, upload-time = "2026-03-15T18:51:11.694Z" }, { url = "https://files.pythonhosted.org/packages/ab/20/0567efb3a8fd481b8f34f739ebddc098ed062a59fed41a8d193a61939e8f/charset_normalizer-3.4.6-cp312-cp312-win_amd64.whl", hash = "sha256:c8ae56368f8cc97c7e40a7ee18e1cedaf8e780cd8bc5ed5ac8b81f238614facb", size = 154277, upload-time = "2026-03-15T18:51:13.004Z" }, { url = "https://files.pythonhosted.org/packages/15/57/28d79b44b51933119e21f65479d0864a8d5893e494cf5daab15df0247c17/charset_normalizer-3.4.6-cp312-cp312-win_arm64.whl", hash = "sha256:899d28f422116b08be5118ef350c292b36fc15ec2daeb9ea987c89281c7bb5c4", size = 142817, upload-time = "2026-03-15T18:51:14.408Z" }, + { url = "https://files.pythonhosted.org/packages/1e/1d/4fdabeef4e231153b6ed7567602f3b68265ec4e5b76d6024cf647d43d981/charset_normalizer-3.4.6-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:11afb56037cbc4b1555a34dd69151e8e069bee82e613a73bef6e714ce733585f", size = 294823, upload-time = "2026-03-15T18:51:15.755Z" }, + { url = "https://files.pythonhosted.org/packages/47/7b/20e809b89c69d37be748d98e84dce6820bf663cf19cf6b942c951a3e8f41/charset_normalizer-3.4.6-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:423fb7e748a08f854a08a222b983f4df1912b1daedce51a72bd24fe8f26a1843", size = 198527, upload-time = "2026-03-15T18:51:17.177Z" }, + { url = "https://files.pythonhosted.org/packages/37/a6/4f8d27527d59c039dce6f7622593cdcd3d70a8504d87d09eb11e9fdc6062/charset_normalizer-3.4.6-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:d73beaac5e90173ac3deb9928a74763a6d230f494e4bfb422c217a0ad8e629bf", size = 218388, upload-time = "2026-03-15T18:51:18.934Z" }, + { url = "https://files.pythonhosted.org/packages/f6/9b/4770ccb3e491a9bacf1c46cc8b812214fe367c86a96353ccc6daf87b01ec/charset_normalizer-3.4.6-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d60377dce4511655582e300dc1e5a5f24ba0cb229005a1d5c8d0cb72bb758ab8", size = 214563, upload-time = "2026-03-15T18:51:20.374Z" }, + { url = "https://files.pythonhosted.org/packages/2b/58/a199d245894b12db0b957d627516c78e055adc3a0d978bc7f65ddaf7c399/charset_normalizer-3.4.6-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:530e8cebeea0d76bdcf93357aa5e41336f48c3dc709ac52da2bb167c5b8271d9", size = 206587, upload-time = "2026-03-15T18:51:21.807Z" }, + { url = "https://files.pythonhosted.org/packages/7e/70/3def227f1ec56f5c69dfc8392b8bd63b11a18ca8178d9211d7cc5e5e4f27/charset_normalizer-3.4.6-cp313-cp313-manylinux_2_31_armv7l.whl", hash = "sha256:a26611d9987b230566f24a0a125f17fe0de6a6aff9f25c9f564aaa2721a5fb88", size = 194724, upload-time = "2026-03-15T18:51:23.508Z" }, + { url = "https://files.pythonhosted.org/packages/58/ab/9318352e220c05efd31c2779a23b50969dc94b985a2efa643ed9077bfca5/charset_normalizer-3.4.6-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:34315ff4fc374b285ad7f4a0bf7dcbfe769e1b104230d40f49f700d4ab6bbd84", size = 202956, upload-time = "2026-03-15T18:51:25.239Z" }, + { url = "https://files.pythonhosted.org/packages/75/13/f3550a3ac25b70f87ac98c40d3199a8503676c2f1620efbf8d42095cfc40/charset_normalizer-3.4.6-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:5f8ddd609f9e1af8c7bd6e2aca279c931aefecd148a14402d4e368f3171769fd", size = 201923, upload-time = "2026-03-15T18:51:26.682Z" }, + { url = "https://files.pythonhosted.org/packages/1b/db/c5c643b912740b45e8eec21de1bbab8e7fc085944d37e1e709d3dcd9d72f/charset_normalizer-3.4.6-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:80d0a5615143c0b3225e5e3ef22c8d5d51f3f72ce0ea6fb84c943546c7b25b6c", size = 195366, upload-time = "2026-03-15T18:51:28.129Z" }, + { url = "https://files.pythonhosted.org/packages/5a/67/3b1c62744f9b2448443e0eb160d8b001c849ec3fef591e012eda6484787c/charset_normalizer-3.4.6-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:92734d4d8d187a354a556626c221cd1a892a4e0802ccb2af432a1d85ec012194", size = 219752, upload-time = "2026-03-15T18:51:29.556Z" }, + { url = "https://files.pythonhosted.org/packages/f6/98/32ffbaf7f0366ffb0445930b87d103f6b406bc2c271563644bde8a2b1093/charset_normalizer-3.4.6-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:613f19aa6e082cf96e17e3ffd89383343d0d589abda756b7764cf78361fd41dc", size = 203296, upload-time = "2026-03-15T18:51:30.921Z" }, + { url = "https://files.pythonhosted.org/packages/41/12/5d308c1bbe60cabb0c5ef511574a647067e2a1f631bc8634fcafaccd8293/charset_normalizer-3.4.6-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:2b1a63e8224e401cafe7739f77efd3f9e7f5f2026bda4aead8e59afab537784f", size = 215956, upload-time = "2026-03-15T18:51:32.399Z" }, + { url = "https://files.pythonhosted.org/packages/53/e9/5f85f6c5e20669dbe56b165c67b0260547dea97dba7e187938833d791687/charset_normalizer-3.4.6-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6cceb5473417d28edd20c6c984ab6fee6c6267d38d906823ebfe20b03d607dc2", size = 208652, upload-time = "2026-03-15T18:51:34.214Z" }, + { url = "https://files.pythonhosted.org/packages/f1/11/897052ea6af56df3eef3ca94edafee410ca699ca0c7b87960ad19932c55e/charset_normalizer-3.4.6-cp313-cp313-win32.whl", hash = "sha256:d7de2637729c67d67cf87614b566626057e95c303bc0a55ffe391f5205e7003d", size = 143940, upload-time = "2026-03-15T18:51:36.15Z" }, + { url = "https://files.pythonhosted.org/packages/a1/5c/724b6b363603e419829f561c854b87ed7c7e31231a7908708ac086cdf3e2/charset_normalizer-3.4.6-cp313-cp313-win_amd64.whl", hash = "sha256:572d7c822caf521f0525ba1bce1a622a0b85cf47ffbdae6c9c19e3b5ac3c4389", size = 154101, upload-time = "2026-03-15T18:51:37.876Z" }, + { url = "https://files.pythonhosted.org/packages/01/a5/7abf15b4c0968e47020f9ca0935fb3274deb87cb288cd187cad92e8cdffd/charset_normalizer-3.4.6-cp313-cp313-win_arm64.whl", hash = "sha256:a4474d924a47185a06411e0064b803c68be044be2d60e50e8bddcc2649957c1f", size = 143109, upload-time = "2026-03-15T18:51:39.565Z" }, + { url = "https://files.pythonhosted.org/packages/25/6f/ffe1e1259f384594063ea1869bfb6be5cdb8bc81020fc36c3636bc8302a1/charset_normalizer-3.4.6-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:9cc6e6d9e571d2f863fa77700701dae73ed5f78881efc8b3f9a4398772ff53e8", size = 294458, upload-time = "2026-03-15T18:51:41.134Z" }, + { url = "https://files.pythonhosted.org/packages/56/60/09bb6c13a8c1016c2ed5c6a6488e4ffef506461aa5161662bd7636936fb1/charset_normalizer-3.4.6-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ef5960d965e67165d75b7c7ffc60a83ec5abfc5c11b764ec13ea54fbef8b4421", size = 199277, upload-time = "2026-03-15T18:51:42.953Z" }, + { url = "https://files.pythonhosted.org/packages/00/50/dcfbb72a5138bbefdc3332e8d81a23494bf67998b4b100703fd15fa52d81/charset_normalizer-3.4.6-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b3694e3f87f8ac7ce279d4355645b3c878d24d1424581b46282f24b92f5a4ae2", size = 218758, upload-time = "2026-03-15T18:51:44.339Z" }, + { url = "https://files.pythonhosted.org/packages/03/b3/d79a9a191bb75f5aa81f3aaaa387ef29ce7cb7a9e5074ba8ea095cc073c2/charset_normalizer-3.4.6-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5d11595abf8dd942a77883a39d81433739b287b6aa71620f15164f8096221b30", size = 215299, upload-time = "2026-03-15T18:51:45.871Z" }, + { url = "https://files.pythonhosted.org/packages/76/7e/bc8911719f7084f72fd545f647601ea3532363927f807d296a8c88a62c0d/charset_normalizer-3.4.6-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7bda6eebafd42133efdca535b04ccb338ab29467b3f7bf79569883676fc628db", size = 206811, upload-time = "2026-03-15T18:51:47.308Z" }, + { url = "https://files.pythonhosted.org/packages/e2/40/c430b969d41dda0c465aa36cc7c2c068afb67177bef50905ac371b28ccc7/charset_normalizer-3.4.6-cp314-cp314-manylinux_2_31_armv7l.whl", hash = "sha256:bbc8c8650c6e51041ad1be191742b8b421d05bbd3410f43fa2a00c8db87678e8", size = 193706, upload-time = "2026-03-15T18:51:48.849Z" }, + { url = "https://files.pythonhosted.org/packages/48/15/e35e0590af254f7df984de1323640ef375df5761f615b6225ba8deb9799a/charset_normalizer-3.4.6-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:22c6f0c2fbc31e76c3b8a86fba1a56eda6166e238c29cdd3d14befdb4a4e4815", size = 202706, upload-time = "2026-03-15T18:51:50.257Z" }, + { url = "https://files.pythonhosted.org/packages/5e/bd/f736f7b9cc5e93a18b794a50346bb16fbfd6b37f99e8f306f7951d27c17c/charset_normalizer-3.4.6-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7edbed096e4a4798710ed6bc75dcaa2a21b68b6c356553ac4823c3658d53743a", size = 202497, upload-time = "2026-03-15T18:51:52.012Z" }, + { url = "https://files.pythonhosted.org/packages/9d/ba/2cc9e3e7dfdf7760a6ed8da7446d22536f3d0ce114ac63dee2a5a3599e62/charset_normalizer-3.4.6-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:7f9019c9cb613f084481bd6a100b12e1547cf2efe362d873c2e31e4035a6fa43", size = 193511, upload-time = "2026-03-15T18:51:53.723Z" }, + { url = "https://files.pythonhosted.org/packages/9e/cb/5be49b5f776e5613be07298c80e1b02a2d900f7a7de807230595c85a8b2e/charset_normalizer-3.4.6-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:58c948d0d086229efc484fe2f30c2d382c86720f55cd9bc33591774348ad44e0", size = 220133, upload-time = "2026-03-15T18:51:55.333Z" }, + { url = "https://files.pythonhosted.org/packages/83/43/99f1b5dad345accb322c80c7821071554f791a95ee50c1c90041c157ae99/charset_normalizer-3.4.6-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:419a9d91bd238052642a51938af8ac05da5b3343becde08d5cdeab9046df9ee1", size = 203035, upload-time = "2026-03-15T18:51:56.736Z" }, + { url = "https://files.pythonhosted.org/packages/87/9a/62c2cb6a531483b55dddff1a68b3d891a8b498f3ca555fbcf2978e804d9d/charset_normalizer-3.4.6-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:5273b9f0b5835ff0350c0828faea623c68bfa65b792720c453e22b25cc72930f", size = 216321, upload-time = "2026-03-15T18:51:58.17Z" }, + { url = "https://files.pythonhosted.org/packages/6e/79/94a010ff81e3aec7c293eb82c28f930918e517bc144c9906a060844462eb/charset_normalizer-3.4.6-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:0e901eb1049fdb80f5bd11ed5ea1e498ec423102f7a9b9e4645d5b8204ff2815", size = 208973, upload-time = "2026-03-15T18:51:59.998Z" }, + { url = "https://files.pythonhosted.org/packages/2a/57/4ecff6d4ec8585342f0c71bc03efaa99cb7468f7c91a57b105bcd561cea8/charset_normalizer-3.4.6-cp314-cp314-win32.whl", hash = "sha256:b4ff1d35e8c5bd078be89349b6f3a845128e685e751b6ea1169cf2160b344c4d", size = 144610, upload-time = "2026-03-15T18:52:02.213Z" }, + { url = "https://files.pythonhosted.org/packages/80/94/8434a02d9d7f168c25767c64671fead8d599744a05d6a6c877144c754246/charset_normalizer-3.4.6-cp314-cp314-win_amd64.whl", hash = "sha256:74119174722c4349af9708993118581686f343adc1c8c9c007d59be90d077f3f", size = 154962, upload-time = "2026-03-15T18:52:03.658Z" }, + { url = "https://files.pythonhosted.org/packages/46/4c/48f2cdbfd923026503dfd67ccea45c94fd8fe988d9056b468579c66ed62b/charset_normalizer-3.4.6-cp314-cp314-win_arm64.whl", hash = "sha256:e5bcc1a1ae744e0bb59641171ae53743760130600da8db48cbb6e4918e186e4e", size = 143595, upload-time = "2026-03-15T18:52:05.123Z" }, + { url = "https://files.pythonhosted.org/packages/31/93/8878be7569f87b14f1d52032946131bcb6ebbd8af3e20446bc04053dc3f1/charset_normalizer-3.4.6-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:ad8faf8df23f0378c6d527d8b0b15ea4a2e23c89376877c598c4870d1b2c7866", size = 314828, upload-time = "2026-03-15T18:52:06.831Z" }, + { url = "https://files.pythonhosted.org/packages/06/b6/fae511ca98aac69ecc35cde828b0a3d146325dd03d99655ad38fc2cc3293/charset_normalizer-3.4.6-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f5ea69428fa1b49573eef0cc44a1d43bebd45ad0c611eb7d7eac760c7ae771bc", size = 208138, upload-time = "2026-03-15T18:52:08.239Z" }, + { url = "https://files.pythonhosted.org/packages/54/57/64caf6e1bf07274a1e0b7c160a55ee9e8c9ec32c46846ce59b9c333f7008/charset_normalizer-3.4.6-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:06a7e86163334edfc5d20fe104db92fcd666e5a5df0977cb5680a506fe26cc8e", size = 224679, upload-time = "2026-03-15T18:52:10.043Z" }, + { url = "https://files.pythonhosted.org/packages/aa/cb/9ff5a25b9273ef160861b41f6937f86fae18b0792fe0a8e75e06acb08f1d/charset_normalizer-3.4.6-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:e1f6e2f00a6b8edb562826e4632e26d063ac10307e80f7461f7de3ad8ef3f077", size = 223475, upload-time = "2026-03-15T18:52:11.854Z" }, + { url = "https://files.pythonhosted.org/packages/fc/97/440635fc093b8d7347502a377031f9605a1039c958f3cd18dcacffb37743/charset_normalizer-3.4.6-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:95b52c68d64c1878818687a473a10547b3292e82b6f6fe483808fb1468e2f52f", size = 215230, upload-time = "2026-03-15T18:52:13.325Z" }, + { url = "https://files.pythonhosted.org/packages/cd/24/afff630feb571a13f07c8539fbb502d2ab494019492aaffc78ef41f1d1d0/charset_normalizer-3.4.6-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:7504e9b7dc05f99a9bbb4525c67a2c155073b44d720470a148b34166a69c054e", size = 199045, upload-time = "2026-03-15T18:52:14.752Z" }, + { url = "https://files.pythonhosted.org/packages/e5/17/d1399ecdaf7e0498c327433e7eefdd862b41236a7e484355b8e0e5ebd64b/charset_normalizer-3.4.6-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:172985e4ff804a7ad08eebec0a1640ece87ba5041d565fff23c8f99c1f389484", size = 211658, upload-time = "2026-03-15T18:52:16.278Z" }, + { url = "https://files.pythonhosted.org/packages/b5/38/16baa0affb957b3d880e5ac2144caf3f9d7de7bc4a91842e447fbb5e8b67/charset_normalizer-3.4.6-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:4be9f4830ba8741527693848403e2c457c16e499100963ec711b1c6f2049b7c7", size = 210769, upload-time = "2026-03-15T18:52:17.782Z" }, + { url = "https://files.pythonhosted.org/packages/05/34/c531bc6ac4c21da9ddfddb3107be2287188b3ea4b53b70fc58f2a77ac8d8/charset_normalizer-3.4.6-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:79090741d842f564b1b2827c0b82d846405b744d31e84f18d7a7b41c20e473ff", size = 201328, upload-time = "2026-03-15T18:52:19.553Z" }, + { url = "https://files.pythonhosted.org/packages/fa/73/a5a1e9ca5f234519c1953608a03fe109c306b97fdfb25f09182babad51a7/charset_normalizer-3.4.6-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:87725cfb1a4f1f8c2fc9890ae2f42094120f4b44db9360be5d99a4c6b0e03a9e", size = 225302, upload-time = "2026-03-15T18:52:21.043Z" }, + { url = "https://files.pythonhosted.org/packages/ba/f6/cd782923d112d296294dea4bcc7af5a7ae0f86ab79f8fefbda5526b6cfc0/charset_normalizer-3.4.6-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:fcce033e4021347d80ed9c66dcf1e7b1546319834b74445f561d2e2221de5659", size = 211127, upload-time = "2026-03-15T18:52:22.491Z" }, + { url = "https://files.pythonhosted.org/packages/0e/c5/0b6898950627af7d6103a449b22320372c24c6feda91aa24e201a478d161/charset_normalizer-3.4.6-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:ca0276464d148c72defa8bb4390cce01b4a0e425f3b50d1435aa6d7a18107602", size = 222840, upload-time = "2026-03-15T18:52:24.113Z" }, + { url = "https://files.pythonhosted.org/packages/7d/25/c4bba773bef442cbdc06111d40daa3de5050a676fa26e85090fc54dd12f0/charset_normalizer-3.4.6-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:197c1a244a274bb016dd8b79204850144ef77fe81c5b797dc389327adb552407", size = 216890, upload-time = "2026-03-15T18:52:25.541Z" }, + { url = "https://files.pythonhosted.org/packages/35/1a/05dacadb0978da72ee287b0143097db12f2e7e8d3ffc4647da07a383b0b7/charset_normalizer-3.4.6-cp314-cp314t-win32.whl", hash = "sha256:2a24157fa36980478dd1770b585c0f30d19e18f4fb0c47c13aa568f871718579", size = 155379, upload-time = "2026-03-15T18:52:27.05Z" }, + { url = "https://files.pythonhosted.org/packages/5d/7a/d269d834cb3a76291651256f3b9a5945e81d0a49ab9f4a498964e83c0416/charset_normalizer-3.4.6-cp314-cp314t-win_amd64.whl", hash = "sha256:cd5e2801c89992ed8c0a3f0293ae83c159a60d9a5d685005383ef4caca77f2c4", size = 169043, upload-time = "2026-03-15T18:52:28.502Z" }, + { url = "https://files.pythonhosted.org/packages/23/06/28b29fba521a37a8932c6a84192175c34d49f84a6d4773fa63d05f9aff22/charset_normalizer-3.4.6-cp314-cp314t-win_arm64.whl", hash = "sha256:47955475ac79cc504ef2704b192364e51d0d473ad452caedd0002605f780101c", size = 148523, upload-time = "2026-03-15T18:52:29.956Z" }, { url = "https://files.pythonhosted.org/packages/2a/68/687187c7e26cb24ccbd88e5069f5ef00eba804d36dde11d99aad0838ab45/charset_normalizer-3.4.6-py3-none-any.whl", hash = "sha256:947cf925bc916d90adba35a64c82aace04fa39b46b52d4630ece166655905a69", size = 61455, upload-time = "2026-03-15T18:53:23.833Z" }, ] +[[package]] +name = "click" +version = "8.3.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/3d/fa/656b739db8587d7b5dfa22e22ed02566950fbfbcdc20311993483657a5c0/click-8.3.1.tar.gz", hash = "sha256:12ff4785d337a1bb490bb7e9c2b1ee5da3112e94a8622f26a6c77f5d2fc6842a", size = 295065, upload-time = "2025-11-15T20:45:42.706Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/98/78/01c019cdb5d6498122777c1a43056ebb3ebfeef2076d9d026bfe15583b2b/click-8.3.1-py3-none-any.whl", hash = "sha256:981153a64e25f12d547d3426c367a4857371575ee7ad18df2a6183ab0545b2a6", size = 108274, upload-time = "2025-11-15T20:45:41.139Z" }, +] + +[[package]] +name = "clip" +version = "0.2.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/58/dc/12bf8888635ade4de57565dca75909a809d1da6ec341eacd546028a73ab9/clip-0.2.0.tar.gz", hash = "sha256:c0913fbb1a0eac8a20da4a5c890d454b081305f64429c0aa5b652164450253b8", size = 5453, upload-time = "2013-01-20T00:55:37.748Z" } + [[package]] name = "colorama" version = "0.4.6" @@ -75,6 +291,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" }, ] +[[package]] +name = "comm" +version = "0.2.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/4c/13/7d740c5849255756bc17888787313b61fd38a0a8304fc4f073dfc46122aa/comm-0.2.3.tar.gz", hash = "sha256:2dc8048c10962d55d7ad693be1e7045d891b7ce8d999c97963a5e3e99c055971", size = 6319, upload-time = "2025-07-25T14:02:04.452Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/60/97/891a0971e1e4a8c5d2b20bbe0e524dc04548d2307fee33cdeba148fd4fc7/comm-0.2.3-py3-none-any.whl", hash = "sha256:c615d91d75f7f04f095b30d1c1711babd43bdc6419c1be9886a85f2f4e489417", size = 7294, upload-time = "2025-07-25T14:02:02.896Z" }, +] + [[package]] name = "contourpy" version = "1.3.3" @@ -84,17 +309,6 @@ dependencies = [ ] sdist = { url = "https://files.pythonhosted.org/packages/58/01/1253e6698a07380cd31a736d248a3f2a50a7c88779a1813da27503cadc2a/contourpy-1.3.3.tar.gz", hash = "sha256:083e12155b210502d0bca491432bb04d56dc3432f95a979b429f2848c3dbe880", size = 13466174, upload-time = "2025-07-26T12:03:12.549Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/91/2e/c4390a31919d8a78b90e8ecf87cd4b4c4f05a5b48d05ec17db8e5404c6f4/contourpy-1.3.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:709a48ef9a690e1343202916450bc48b9e51c049b089c7f79a267b46cffcdaa1", size = 288773, upload-time = "2025-07-26T12:01:02.277Z" }, - { url = "https://files.pythonhosted.org/packages/0d/44/c4b0b6095fef4dc9c420e041799591e3b63e9619e3044f7f4f6c21c0ab24/contourpy-1.3.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:23416f38bfd74d5d28ab8429cc4d63fa67d5068bd711a85edb1c3fb0c3e2f381", size = 270149, upload-time = "2025-07-26T12:01:04.072Z" }, - { url = "https://files.pythonhosted.org/packages/30/2e/dd4ced42fefac8470661d7cb7e264808425e6c5d56d175291e93890cce09/contourpy-1.3.3-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:929ddf8c4c7f348e4c0a5a3a714b5c8542ffaa8c22954862a46ca1813b667ee7", size = 329222, upload-time = "2025-07-26T12:01:05.688Z" }, - { url = "https://files.pythonhosted.org/packages/f2/74/cc6ec2548e3d276c71389ea4802a774b7aa3558223b7bade3f25787fafc2/contourpy-1.3.3-cp311-cp311-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9e999574eddae35f1312c2b4b717b7885d4edd6cb46700e04f7f02db454e67c1", size = 377234, upload-time = "2025-07-26T12:01:07.054Z" }, - { url = "https://files.pythonhosted.org/packages/03/b3/64ef723029f917410f75c09da54254c5f9ea90ef89b143ccadb09df14c15/contourpy-1.3.3-cp311-cp311-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0bf67e0e3f482cb69779dd3061b534eb35ac9b17f163d851e2a547d56dba0a3a", size = 380555, upload-time = "2025-07-26T12:01:08.801Z" }, - { url = "https://files.pythonhosted.org/packages/5f/4b/6157f24ca425b89fe2eb7e7be642375711ab671135be21e6faa100f7448c/contourpy-1.3.3-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:51e79c1f7470158e838808d4a996fa9bac72c498e93d8ebe5119bc1e6becb0db", size = 355238, upload-time = "2025-07-26T12:01:10.319Z" }, - { url = "https://files.pythonhosted.org/packages/98/56/f914f0dd678480708a04cfd2206e7c382533249bc5001eb9f58aa693e200/contourpy-1.3.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:598c3aaece21c503615fd59c92a3598b428b2f01bfb4b8ca9c4edeecc2438620", size = 1326218, upload-time = "2025-07-26T12:01:12.659Z" }, - { url = "https://files.pythonhosted.org/packages/fb/d7/4a972334a0c971acd5172389671113ae82aa7527073980c38d5868ff1161/contourpy-1.3.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:322ab1c99b008dad206d406bb61d014cf0174df491ae9d9d0fac6a6fda4f977f", size = 1392867, upload-time = "2025-07-26T12:01:15.533Z" }, - { url = "https://files.pythonhosted.org/packages/75/3e/f2cc6cd56dc8cff46b1a56232eabc6feea52720083ea71ab15523daab796/contourpy-1.3.3-cp311-cp311-win32.whl", hash = "sha256:fd907ae12cd483cd83e414b12941c632a969171bf90fc937d0c9f268a31cafff", size = 183677, upload-time = "2025-07-26T12:01:17.088Z" }, - { url = "https://files.pythonhosted.org/packages/98/4b/9bd370b004b5c9d8045c6c33cf65bae018b27aca550a3f657cdc99acdbd8/contourpy-1.3.3-cp311-cp311-win_amd64.whl", hash = "sha256:3519428f6be58431c56581f1694ba8e50626f2dd550af225f82fb5f5814d2a42", size = 225234, upload-time = "2025-07-26T12:01:18.256Z" }, - { url = "https://files.pythonhosted.org/packages/d9/b6/71771e02c2e004450c12b1120a5f488cad2e4d5b590b1af8bad060360fe4/contourpy-1.3.3-cp311-cp311-win_arm64.whl", hash = "sha256:15ff10bfada4bf92ec8b31c62bf7c1834c244019b4a33095a68000d7075df470", size = 193123, upload-time = "2025-07-26T12:01:19.848Z" }, { url = "https://files.pythonhosted.org/packages/be/45/adfee365d9ea3d853550b2e735f9d66366701c65db7855cd07621732ccfc/contourpy-1.3.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b08a32ea2f8e42cf1d4be3169a98dd4be32bafe4f22b6c4cb4ba810fa9e5d2cb", size = 293419, upload-time = "2025-07-26T12:01:21.16Z" }, { url = "https://files.pythonhosted.org/packages/53/3e/405b59cfa13021a56bba395a6b3aca8cec012b45bf177b0eaf7a202cde2c/contourpy-1.3.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:556dba8fb6f5d8742f2923fe9457dbdd51e1049c4a43fd3986a0b14a1d815fc6", size = 273979, upload-time = "2025-07-26T12:01:22.448Z" }, { url = "https://files.pythonhosted.org/packages/d4/1c/a12359b9b2ca3a845e8f7f9ac08bdf776114eb931392fcad91743e2ea17b/contourpy-1.3.3-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:92d9abc807cf7d0e047b95ca5d957cf4792fcd04e920ca70d48add15c1a90ea7", size = 332653, upload-time = "2025-07-26T12:01:24.155Z" }, @@ -106,11 +320,119 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/cf/8f/5847f44a7fddf859704217a99a23a4f6417b10e5ab1256a179264561540e/contourpy-1.3.3-cp312-cp312-win32.whl", hash = "sha256:023b44101dfe49d7d53932be418477dba359649246075c996866106da069af69", size = 185018, upload-time = "2025-07-26T12:01:35.64Z" }, { url = "https://files.pythonhosted.org/packages/19/e8/6026ed58a64563186a9ee3f29f41261fd1828f527dd93d33b60feca63352/contourpy-1.3.3-cp312-cp312-win_amd64.whl", hash = "sha256:8153b8bfc11e1e4d75bcb0bff1db232f9e10b274e0929de9d608027e0d34ff8b", size = 226567, upload-time = "2025-07-26T12:01:36.804Z" }, { url = "https://files.pythonhosted.org/packages/d1/e2/f05240d2c39a1ed228d8328a78b6f44cd695f7ef47beb3e684cf93604f86/contourpy-1.3.3-cp312-cp312-win_arm64.whl", hash = "sha256:07ce5ed73ecdc4a03ffe3e1b3e3c1166db35ae7584be76f65dbbe28a7791b0cc", size = 193655, upload-time = "2025-07-26T12:01:37.999Z" }, - { url = "https://files.pythonhosted.org/packages/a5/29/8dcfe16f0107943fa92388c23f6e05cff0ba58058c4c95b00280d4c75a14/contourpy-1.3.3-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:cd5dfcaeb10f7b7f9dc8941717c6c2ade08f587be2226222c12b25f0483ed497", size = 278809, upload-time = "2025-07-26T12:02:52.74Z" }, - { url = "https://files.pythonhosted.org/packages/85/a9/8b37ef4f7dafeb335daee3c8254645ef5725be4d9c6aa70b50ec46ef2f7e/contourpy-1.3.3-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:0c1fc238306b35f246d61a1d416a627348b5cf0648648a031e14bb8705fcdfe8", size = 261593, upload-time = "2025-07-26T12:02:54.037Z" }, - { url = "https://files.pythonhosted.org/packages/0a/59/ebfb8c677c75605cc27f7122c90313fd2f375ff3c8d19a1694bda74aaa63/contourpy-1.3.3-pp311-pypy311_pp73-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:70f9aad7de812d6541d29d2bbf8feb22ff7e1c299523db288004e3157ff4674e", size = 302202, upload-time = "2025-07-26T12:02:55.947Z" }, - { url = "https://files.pythonhosted.org/packages/3c/37/21972a15834d90bfbfb009b9d004779bd5a07a0ec0234e5ba8f64d5736f4/contourpy-1.3.3-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5ed3657edf08512fc3fe81b510e35c2012fbd3081d2e26160f27ca28affec989", size = 329207, upload-time = "2025-07-26T12:02:57.468Z" }, - { url = "https://files.pythonhosted.org/packages/0c/58/bd257695f39d05594ca4ad60df5bcb7e32247f9951fd09a9b8edb82d1daa/contourpy-1.3.3-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:3d1a3799d62d45c18bafd41c5fa05120b96a28079f2393af559b843d1a966a77", size = 225315, upload-time = "2025-07-26T12:02:58.801Z" }, + { url = "https://files.pythonhosted.org/packages/68/35/0167aad910bbdb9599272bd96d01a9ec6852f36b9455cf2ca67bd4cc2d23/contourpy-1.3.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:177fb367556747a686509d6fef71d221a4b198a3905fe824430e5ea0fda54eb5", size = 293257, upload-time = "2025-07-26T12:01:39.367Z" }, + { url = "https://files.pythonhosted.org/packages/96/e4/7adcd9c8362745b2210728f209bfbcf7d91ba868a2c5f40d8b58f54c509b/contourpy-1.3.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:d002b6f00d73d69333dac9d0b8d5e84d9724ff9ef044fd63c5986e62b7c9e1b1", size = 274034, upload-time = "2025-07-26T12:01:40.645Z" }, + { url = "https://files.pythonhosted.org/packages/73/23/90e31ceeed1de63058a02cb04b12f2de4b40e3bef5e082a7c18d9c8ae281/contourpy-1.3.3-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:348ac1f5d4f1d66d3322420f01d42e43122f43616e0f194fc1c9f5d830c5b286", size = 334672, upload-time = "2025-07-26T12:01:41.942Z" }, + { url = "https://files.pythonhosted.org/packages/ed/93/b43d8acbe67392e659e1d984700e79eb67e2acb2bd7f62012b583a7f1b55/contourpy-1.3.3-cp313-cp313-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:655456777ff65c2c548b7c454af9c6f33f16c8884f11083244b5819cc214f1b5", size = 381234, upload-time = "2025-07-26T12:01:43.499Z" }, + { url = "https://files.pythonhosted.org/packages/46/3b/bec82a3ea06f66711520f75a40c8fc0b113b2a75edb36aa633eb11c4f50f/contourpy-1.3.3-cp313-cp313-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:644a6853d15b2512d67881586bd03f462c7ab755db95f16f14d7e238f2852c67", size = 385169, upload-time = "2025-07-26T12:01:45.219Z" }, + { url = "https://files.pythonhosted.org/packages/4b/32/e0f13a1c5b0f8572d0ec6ae2f6c677b7991fafd95da523159c19eff0696a/contourpy-1.3.3-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4debd64f124ca62069f313a9cb86656ff087786016d76927ae2cf37846b006c9", size = 362859, upload-time = "2025-07-26T12:01:46.519Z" }, + { url = "https://files.pythonhosted.org/packages/33/71/e2a7945b7de4e58af42d708a219f3b2f4cff7386e6b6ab0a0fa0033c49a9/contourpy-1.3.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a15459b0f4615b00bbd1e91f1b9e19b7e63aea7483d03d804186f278c0af2659", size = 1332062, upload-time = "2025-07-26T12:01:48.964Z" }, + { url = "https://files.pythonhosted.org/packages/12/fc/4e87ac754220ccc0e807284f88e943d6d43b43843614f0a8afa469801db0/contourpy-1.3.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ca0fdcd73925568ca027e0b17ab07aad764be4706d0a925b89227e447d9737b7", size = 1403932, upload-time = "2025-07-26T12:01:51.979Z" }, + { url = "https://files.pythonhosted.org/packages/a6/2e/adc197a37443f934594112222ac1aa7dc9a98faf9c3842884df9a9d8751d/contourpy-1.3.3-cp313-cp313-win32.whl", hash = "sha256:b20c7c9a3bf701366556e1b1984ed2d0cedf999903c51311417cf5f591d8c78d", size = 185024, upload-time = "2025-07-26T12:01:53.245Z" }, + { url = "https://files.pythonhosted.org/packages/18/0b/0098c214843213759692cc638fce7de5c289200a830e5035d1791d7a2338/contourpy-1.3.3-cp313-cp313-win_amd64.whl", hash = "sha256:1cadd8b8969f060ba45ed7c1b714fe69185812ab43bd6b86a9123fe8f99c3263", size = 226578, upload-time = "2025-07-26T12:01:54.422Z" }, + { url = "https://files.pythonhosted.org/packages/8a/9a/2f6024a0c5995243cd63afdeb3651c984f0d2bc727fd98066d40e141ad73/contourpy-1.3.3-cp313-cp313-win_arm64.whl", hash = "sha256:fd914713266421b7536de2bfa8181aa8c699432b6763a0ea64195ebe28bff6a9", size = 193524, upload-time = "2025-07-26T12:01:55.73Z" }, + { url = "https://files.pythonhosted.org/packages/c0/b3/f8a1a86bd3298513f500e5b1f5fd92b69896449f6cab6a146a5d52715479/contourpy-1.3.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:88df9880d507169449d434c293467418b9f6cbe82edd19284aa0409e7fdb933d", size = 306730, upload-time = "2025-07-26T12:01:57.051Z" }, + { url = "https://files.pythonhosted.org/packages/3f/11/4780db94ae62fc0c2053909b65dc3246bd7cecfc4f8a20d957ad43aa4ad8/contourpy-1.3.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:d06bb1f751ba5d417047db62bca3c8fde202b8c11fb50742ab3ab962c81e8216", size = 287897, upload-time = "2025-07-26T12:01:58.663Z" }, + { url = "https://files.pythonhosted.org/packages/ae/15/e59f5f3ffdd6f3d4daa3e47114c53daabcb18574a26c21f03dc9e4e42ff0/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e4e6b05a45525357e382909a4c1600444e2a45b4795163d3b22669285591c1ae", size = 326751, upload-time = "2025-07-26T12:02:00.343Z" }, + { url = "https://files.pythonhosted.org/packages/0f/81/03b45cfad088e4770b1dcf72ea78d3802d04200009fb364d18a493857210/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ab3074b48c4e2cf1a960e6bbeb7f04566bf36b1861d5c9d4d8ac04b82e38ba20", size = 375486, upload-time = "2025-07-26T12:02:02.128Z" }, + { url = "https://files.pythonhosted.org/packages/0c/ba/49923366492ffbdd4486e970d421b289a670ae8cf539c1ea9a09822b371a/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6c3d53c796f8647d6deb1abe867daeb66dcc8a97e8455efa729516b997b8ed99", size = 388106, upload-time = "2025-07-26T12:02:03.615Z" }, + { url = "https://files.pythonhosted.org/packages/9f/52/5b00ea89525f8f143651f9f03a0df371d3cbd2fccd21ca9b768c7a6500c2/contourpy-1.3.3-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:50ed930df7289ff2a8d7afeb9603f8289e5704755c7e5c3bbd929c90c817164b", size = 352548, upload-time = "2025-07-26T12:02:05.165Z" }, + { url = "https://files.pythonhosted.org/packages/32/1d/a209ec1a3a3452d490f6b14dd92e72280c99ae3d1e73da74f8277d4ee08f/contourpy-1.3.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:4feffb6537d64b84877da813a5c30f1422ea5739566abf0bd18065ac040e120a", size = 1322297, upload-time = "2025-07-26T12:02:07.379Z" }, + { url = "https://files.pythonhosted.org/packages/bc/9e/46f0e8ebdd884ca0e8877e46a3f4e633f6c9c8c4f3f6e72be3fe075994aa/contourpy-1.3.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:2b7e9480ffe2b0cd2e787e4df64270e3a0440d9db8dc823312e2c940c167df7e", size = 1391023, upload-time = "2025-07-26T12:02:10.171Z" }, + { url = "https://files.pythonhosted.org/packages/b9/70/f308384a3ae9cd2209e0849f33c913f658d3326900d0ff5d378d6a1422d2/contourpy-1.3.3-cp313-cp313t-win32.whl", hash = "sha256:283edd842a01e3dcd435b1c5116798d661378d83d36d337b8dde1d16a5fc9ba3", size = 196157, upload-time = "2025-07-26T12:02:11.488Z" }, + { url = "https://files.pythonhosted.org/packages/b2/dd/880f890a6663b84d9e34a6f88cded89d78f0091e0045a284427cb6b18521/contourpy-1.3.3-cp313-cp313t-win_amd64.whl", hash = "sha256:87acf5963fc2b34825e5b6b048f40e3635dd547f590b04d2ab317c2619ef7ae8", size = 240570, upload-time = "2025-07-26T12:02:12.754Z" }, + { url = "https://files.pythonhosted.org/packages/80/99/2adc7d8ffead633234817ef8e9a87115c8a11927a94478f6bb3d3f4d4f7d/contourpy-1.3.3-cp313-cp313t-win_arm64.whl", hash = "sha256:3c30273eb2a55024ff31ba7d052dde990d7d8e5450f4bbb6e913558b3d6c2301", size = 199713, upload-time = "2025-07-26T12:02:14.4Z" }, + { url = "https://files.pythonhosted.org/packages/72/8b/4546f3ab60f78c514ffb7d01a0bd743f90de36f0019d1be84d0a708a580a/contourpy-1.3.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fde6c716d51c04b1c25d0b90364d0be954624a0ee9d60e23e850e8d48353d07a", size = 292189, upload-time = "2025-07-26T12:02:16.095Z" }, + { url = "https://files.pythonhosted.org/packages/fd/e1/3542a9cb596cadd76fcef413f19c79216e002623158befe6daa03dbfa88c/contourpy-1.3.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:cbedb772ed74ff5be440fa8eee9bd49f64f6e3fc09436d9c7d8f1c287b121d77", size = 273251, upload-time = "2025-07-26T12:02:17.524Z" }, + { url = "https://files.pythonhosted.org/packages/b1/71/f93e1e9471d189f79d0ce2497007731c1e6bf9ef6d1d61b911430c3db4e5/contourpy-1.3.3-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:22e9b1bd7a9b1d652cd77388465dc358dafcd2e217d35552424aa4f996f524f5", size = 335810, upload-time = "2025-07-26T12:02:18.9Z" }, + { url = "https://files.pythonhosted.org/packages/91/f9/e35f4c1c93f9275d4e38681a80506b5510e9327350c51f8d4a5a724d178c/contourpy-1.3.3-cp314-cp314-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a22738912262aa3e254e4f3cb079a95a67132fc5a063890e224393596902f5a4", size = 382871, upload-time = "2025-07-26T12:02:20.418Z" }, + { url = "https://files.pythonhosted.org/packages/b5/71/47b512f936f66a0a900d81c396a7e60d73419868fba959c61efed7a8ab46/contourpy-1.3.3-cp314-cp314-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:afe5a512f31ee6bd7d0dda52ec9864c984ca3d66664444f2d72e0dc4eb832e36", size = 386264, upload-time = "2025-07-26T12:02:21.916Z" }, + { url = "https://files.pythonhosted.org/packages/04/5f/9ff93450ba96b09c7c2b3f81c94de31c89f92292f1380261bd7195bea4ea/contourpy-1.3.3-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f64836de09927cba6f79dcd00fdd7d5329f3fccc633468507079c829ca4db4e3", size = 363819, upload-time = "2025-07-26T12:02:23.759Z" }, + { url = "https://files.pythonhosted.org/packages/3e/a6/0b185d4cc480ee494945cde102cb0149ae830b5fa17bf855b95f2e70ad13/contourpy-1.3.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:1fd43c3be4c8e5fd6e4f2baeae35ae18176cf2e5cced681cca908addf1cdd53b", size = 1333650, upload-time = "2025-07-26T12:02:26.181Z" }, + { url = "https://files.pythonhosted.org/packages/43/d7/afdc95580ca56f30fbcd3060250f66cedbde69b4547028863abd8aa3b47e/contourpy-1.3.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:6afc576f7b33cf00996e5c1102dc2a8f7cc89e39c0b55df93a0b78c1bd992b36", size = 1404833, upload-time = "2025-07-26T12:02:28.782Z" }, + { url = "https://files.pythonhosted.org/packages/e2/e2/366af18a6d386f41132a48f033cbd2102e9b0cf6345d35ff0826cd984566/contourpy-1.3.3-cp314-cp314-win32.whl", hash = "sha256:66c8a43a4f7b8df8b71ee1840e4211a3c8d93b214b213f590e18a1beca458f7d", size = 189692, upload-time = "2025-07-26T12:02:30.128Z" }, + { url = "https://files.pythonhosted.org/packages/7d/c2/57f54b03d0f22d4044b8afb9ca0e184f8b1afd57b4f735c2fa70883dc601/contourpy-1.3.3-cp314-cp314-win_amd64.whl", hash = "sha256:cf9022ef053f2694e31d630feaacb21ea24224be1c3ad0520b13d844274614fd", size = 232424, upload-time = "2025-07-26T12:02:31.395Z" }, + { url = "https://files.pythonhosted.org/packages/18/79/a9416650df9b525737ab521aa181ccc42d56016d2123ddcb7b58e926a42c/contourpy-1.3.3-cp314-cp314-win_arm64.whl", hash = "sha256:95b181891b4c71de4bb404c6621e7e2390745f887f2a026b2d99e92c17892339", size = 198300, upload-time = "2025-07-26T12:02:32.956Z" }, + { url = "https://files.pythonhosted.org/packages/1f/42/38c159a7d0f2b7b9c04c64ab317042bb6952b713ba875c1681529a2932fe/contourpy-1.3.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:33c82d0138c0a062380332c861387650c82e4cf1747aaa6938b9b6516762e772", size = 306769, upload-time = "2025-07-26T12:02:34.2Z" }, + { url = "https://files.pythonhosted.org/packages/c3/6c/26a8205f24bca10974e77460de68d3d7c63e282e23782f1239f226fcae6f/contourpy-1.3.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ea37e7b45949df430fe649e5de8351c423430046a2af20b1c1961cae3afcda77", size = 287892, upload-time = "2025-07-26T12:02:35.807Z" }, + { url = "https://files.pythonhosted.org/packages/66/06/8a475c8ab718ebfd7925661747dbb3c3ee9c82ac834ccb3570be49d129f4/contourpy-1.3.3-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d304906ecc71672e9c89e87c4675dc5c2645e1f4269a5063b99b0bb29f232d13", size = 326748, upload-time = "2025-07-26T12:02:37.193Z" }, + { url = "https://files.pythonhosted.org/packages/b4/a3/c5ca9f010a44c223f098fccd8b158bb1cb287378a31ac141f04730dc49be/contourpy-1.3.3-cp314-cp314t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ca658cd1a680a5c9ea96dc61cdbae1e85c8f25849843aa799dfd3cb370ad4fbe", size = 375554, upload-time = "2025-07-26T12:02:38.894Z" }, + { url = "https://files.pythonhosted.org/packages/80/5b/68bd33ae63fac658a4145088c1e894405e07584a316738710b636c6d0333/contourpy-1.3.3-cp314-cp314t-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ab2fd90904c503739a75b7c8c5c01160130ba67944a7b77bbf36ef8054576e7f", size = 388118, upload-time = "2025-07-26T12:02:40.642Z" }, + { url = "https://files.pythonhosted.org/packages/40/52/4c285a6435940ae25d7410a6c36bda5145839bc3f0beb20c707cda18b9d2/contourpy-1.3.3-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b7301b89040075c30e5768810bc96a8e8d78085b47d8be6e4c3f5a0b4ed478a0", size = 352555, upload-time = "2025-07-26T12:02:42.25Z" }, + { url = "https://files.pythonhosted.org/packages/24/ee/3e81e1dd174f5c7fefe50e85d0892de05ca4e26ef1c9a59c2a57e43b865a/contourpy-1.3.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:2a2a8b627d5cc6b7c41a4beff6c5ad5eb848c88255fda4a8745f7e901b32d8e4", size = 1322295, upload-time = "2025-07-26T12:02:44.668Z" }, + { url = "https://files.pythonhosted.org/packages/3c/b2/6d913d4d04e14379de429057cd169e5e00f6c2af3bb13e1710bcbdb5da12/contourpy-1.3.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:fd6ec6be509c787f1caf6b247f0b1ca598bef13f4ddeaa126b7658215529ba0f", size = 1391027, upload-time = "2025-07-26T12:02:47.09Z" }, + { url = "https://files.pythonhosted.org/packages/93/8a/68a4ec5c55a2971213d29a9374913f7e9f18581945a7a31d1a39b5d2dfe5/contourpy-1.3.3-cp314-cp314t-win32.whl", hash = "sha256:e74a9a0f5e3fff48fb5a7f2fd2b9b70a3fe014a67522f79b7cca4c0c7e43c9ae", size = 202428, upload-time = "2025-07-26T12:02:48.691Z" }, + { url = "https://files.pythonhosted.org/packages/fa/96/fd9f641ffedc4fa3ace923af73b9d07e869496c9cc7a459103e6e978992f/contourpy-1.3.3-cp314-cp314t-win_amd64.whl", hash = "sha256:13b68d6a62db8eafaebb8039218921399baf6e47bf85006fd8529f2a08ef33fc", size = 250331, upload-time = "2025-07-26T12:02:50.137Z" }, + { url = "https://files.pythonhosted.org/packages/ae/8c/469afb6465b853afff216f9528ffda78a915ff880ed58813ba4faf4ba0b6/contourpy-1.3.3-cp314-cp314t-win_arm64.whl", hash = "sha256:b7448cb5a725bb1e35ce88771b86fba35ef418952474492cf7c764059933ff8b", size = 203831, upload-time = "2025-07-26T12:02:51.449Z" }, +] + +[[package]] +name = "cuda-bindings" +version = "13.2.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cuda-pathfinder", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/52/c8/b2589d68acf7e3d63e2be330b84bc25712e97ed799affbca7edd7eae25d6/cuda_bindings-13.2.0-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e865447abfb83d6a98ad5130ed3c70b1fc295ae3eeee39fd07b4ddb0671b6788", size = 5722404, upload-time = "2026-03-11T00:12:44.041Z" }, + { url = "https://files.pythonhosted.org/packages/1f/92/f899f7bbb5617bb65ec52a6eac1e9a1447a86b916c4194f8a5001b8cde0c/cuda_bindings-13.2.0-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:46d8776a55d6d5da9dd6e9858fba2efcda2abe6743871dee47dd06eb8cb6d955", size = 6320619, upload-time = "2026-03-11T00:12:45.939Z" }, + { url = "https://files.pythonhosted.org/packages/df/93/eef988860a3ca985f82c4f3174fc0cdd94e07331ba9a92e8e064c260337f/cuda_bindings-13.2.0-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6629ca2df6f795b784752409bcaedbd22a7a651b74b56a165ebc0c9dcbd504d0", size = 5614610, upload-time = "2026-03-11T00:12:50.337Z" }, + { url = "https://files.pythonhosted.org/packages/18/23/6db3aba46864aee357ab2415135b3fe3da7e9f1fa0221fa2a86a5968099c/cuda_bindings-13.2.0-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7dca0da053d3b4cc4869eff49c61c03f3c5dbaa0bcd712317a358d5b8f3f385d", size = 6149914, upload-time = "2026-03-11T00:12:52.374Z" }, + { url = "https://files.pythonhosted.org/packages/c0/87/87a014f045b77c6de5c8527b0757fe644417b184e5367db977236a141602/cuda_bindings-13.2.0-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a6464b30f46692d6c7f65d4a0e0450d81dd29de3afc1bb515653973d01c2cd6e", size = 5685673, upload-time = "2026-03-11T00:12:56.371Z" }, + { url = "https://files.pythonhosted.org/packages/ee/5e/c0fe77a73aaefd3fff25ffaccaac69c5a63eafdf8b9a4c476626ef0ac703/cuda_bindings-13.2.0-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f4af9f3e1be603fa12d5ad6cfca7844c9d230befa9792b5abdf7dd79979c3626", size = 6191386, upload-time = "2026-03-11T00:12:58.965Z" }, + { url = "https://files.pythonhosted.org/packages/5f/58/ed2c3b39c8dd5f96aa7a4abef0d47a73932c7a988e30f5fa428f00ed0da1/cuda_bindings-13.2.0-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:df850a1ff8ce1b3385257b08e47b70e959932f5f432d0a4e46a355962b4e4771", size = 5507469, upload-time = "2026-03-11T00:13:04.063Z" }, + { url = "https://files.pythonhosted.org/packages/1f/01/0c941b112ceeb21439b05895eace78ca1aa2eaaf695c8521a068fd9b4c00/cuda_bindings-13.2.0-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e8a16384c6494e5485f39314b0b4afb04bee48d49edb16d5d8593fd35bbd231b", size = 6059693, upload-time = "2026-03-11T00:13:06.003Z" }, +] + +[[package]] +name = "cuda-pathfinder" +version = "1.5.0" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/93/66/0c02bd330e7d976f83fa68583d6198d76f23581bcbb5c0e98a6148f326e5/cuda_pathfinder-1.5.0-py3-none-any.whl", hash = "sha256:498f90a9e9de36044a7924742aecce11c50c49f735f1bc53e05aa46de9ea4110", size = 49739, upload-time = "2026-03-24T21:14:30.869Z" }, +] + +[[package]] +name = "cuda-toolkit" +version = "13.0.2" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/57/b2/453099f5f3b698d7d0eab38916aac44c7f76229f451709e2eb9db6615dcd/cuda_toolkit-13.0.2-py2.py3-none-any.whl", hash = "sha256:b198824cf2f54003f50d64ada3a0f184b42ca0846c1c94192fa269ecd97a66eb", size = 2364, upload-time = "2025-12-19T23:24:07.328Z" }, +] + +[package.optional-dependencies] +cublas = [ + { name = "nvidia-cublas", marker = "sys_platform == 'linux'" }, +] +cudart = [ + { name = "nvidia-cuda-runtime", marker = "sys_platform == 'linux'" }, +] +cufft = [ + { name = "nvidia-cufft", marker = "sys_platform == 'linux'" }, +] +cufile = [ + { name = "nvidia-cufile", marker = "sys_platform == 'linux'" }, +] +cupti = [ + { name = "nvidia-cuda-cupti", marker = "sys_platform == 'linux'" }, +] +curand = [ + { name = "nvidia-curand", marker = "sys_platform == 'linux'" }, +] +cusolver = [ + { name = "nvidia-cusolver", marker = "sys_platform == 'linux'" }, +] +cusparse = [ + { name = "nvidia-cusparse", marker = "sys_platform == 'linux'" }, +] +nvjitlink = [ + { name = "nvidia-nvjitlink", marker = "sys_platform == 'linux'" }, +] +nvrtc = [ + { name = "nvidia-cuda-nvrtc", marker = "sys_platform == 'linux'" }, +] +nvtx = [ + { name = "nvidia-nvtx", marker = "sys_platform == 'linux'" }, ] [[package]] @@ -122,20 +444,86 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/e7/05/c19819d5e3d95294a6f5947fb9b9629efb316b96de511b418c53d245aae6/cycler-0.12.1-py3-none-any.whl", hash = "sha256:85cef7cff222d8644161529808465972e51340599459b8ac3ccbac5a854e0d30", size = 8321, upload-time = "2023-10-07T05:32:16.783Z" }, ] +[[package]] +name = "debugpy" +version = "1.8.20" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e0/b7/cd8080344452e4874aae67c40d8940e2b4d47b01601a8fd9f44786c757c7/debugpy-1.8.20.tar.gz", hash = "sha256:55bc8701714969f1ab89a6d5f2f3d40c36f91b2cbe2f65d98bf8196f6a6a2c33", size = 1645207, upload-time = "2026-01-29T23:03:28.199Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/14/57/7f34f4736bfb6e00f2e4c96351b07805d83c9a7b33d28580ae01374430f7/debugpy-1.8.20-cp312-cp312-macosx_15_0_universal2.whl", hash = "sha256:4ae3135e2089905a916909ef31922b2d733d756f66d87345b3e5e52b7a55f13d", size = 2550686, upload-time = "2026-01-29T23:03:42.023Z" }, + { url = "https://files.pythonhosted.org/packages/ab/78/b193a3975ca34458f6f0e24aaf5c3e3da72f5401f6054c0dfd004b41726f/debugpy-1.8.20-cp312-cp312-manylinux_2_34_x86_64.whl", hash = "sha256:88f47850a4284b88bd2bfee1f26132147d5d504e4e86c22485dfa44b97e19b4b", size = 4310588, upload-time = "2026-01-29T23:03:43.314Z" }, + { url = "https://files.pythonhosted.org/packages/c1/55/f14deb95eaf4f30f07ef4b90a8590fc05d9e04df85ee379712f6fb6736d7/debugpy-1.8.20-cp312-cp312-win32.whl", hash = "sha256:4057ac68f892064e5f98209ab582abfee3b543fb55d2e87610ddc133a954d390", size = 5331372, upload-time = "2026-01-29T23:03:45.526Z" }, + { url = "https://files.pythonhosted.org/packages/a1/39/2bef246368bd42f9bd7cba99844542b74b84dacbdbea0833e610f384fee8/debugpy-1.8.20-cp312-cp312-win_amd64.whl", hash = "sha256:a1a8f851e7cf171330679ef6997e9c579ef6dd33c9098458bd9986a0f4ca52e3", size = 5372835, upload-time = "2026-01-29T23:03:47.245Z" }, + { url = "https://files.pythonhosted.org/packages/15/e2/fc500524cc6f104a9d049abc85a0a8b3f0d14c0a39b9c140511c61e5b40b/debugpy-1.8.20-cp313-cp313-macosx_15_0_universal2.whl", hash = "sha256:5dff4bb27027821fdfcc9e8f87309a28988231165147c31730128b1c983e282a", size = 2539560, upload-time = "2026-01-29T23:03:48.738Z" }, + { url = "https://files.pythonhosted.org/packages/90/83/fb33dcea789ed6018f8da20c5a9bc9d82adc65c0c990faed43f7c955da46/debugpy-1.8.20-cp313-cp313-manylinux_2_34_x86_64.whl", hash = "sha256:84562982dd7cf5ebebfdea667ca20a064e096099997b175fe204e86817f64eaf", size = 4293272, upload-time = "2026-01-29T23:03:50.169Z" }, + { url = "https://files.pythonhosted.org/packages/a6/25/b1e4a01bfb824d79a6af24b99ef291e24189080c93576dfd9b1a2815cd0f/debugpy-1.8.20-cp313-cp313-win32.whl", hash = "sha256:da11dea6447b2cadbf8ce2bec59ecea87cc18d2c574980f643f2d2dfe4862393", size = 5331208, upload-time = "2026-01-29T23:03:51.547Z" }, + { url = "https://files.pythonhosted.org/packages/13/f7/a0b368ce54ffff9e9028c098bd2d28cfc5b54f9f6c186929083d4c60ba58/debugpy-1.8.20-cp313-cp313-win_amd64.whl", hash = "sha256:eb506e45943cab2efb7c6eafdd65b842f3ae779f020c82221f55aca9de135ed7", size = 5372930, upload-time = "2026-01-29T23:03:53.585Z" }, + { url = "https://files.pythonhosted.org/packages/33/2e/f6cb9a8a13f5058f0a20fe09711a7b726232cd5a78c6a7c05b2ec726cff9/debugpy-1.8.20-cp314-cp314-macosx_15_0_universal2.whl", hash = "sha256:9c74df62fc064cd5e5eaca1353a3ef5a5d50da5eb8058fcef63106f7bebe6173", size = 2538066, upload-time = "2026-01-29T23:03:54.999Z" }, + { url = "https://files.pythonhosted.org/packages/c5/56/6ddca50b53624e1ca3ce1d1e49ff22db46c47ea5fb4c0cc5c9b90a616364/debugpy-1.8.20-cp314-cp314-manylinux_2_34_x86_64.whl", hash = "sha256:077a7447589ee9bc1ff0cdf443566d0ecf540ac8aa7333b775ebcb8ce9f4ecad", size = 4269425, upload-time = "2026-01-29T23:03:56.518Z" }, + { url = "https://files.pythonhosted.org/packages/c5/d9/d64199c14a0d4c476df46c82470a3ce45c8d183a6796cfb5e66533b3663c/debugpy-1.8.20-cp314-cp314-win32.whl", hash = "sha256:352036a99dd35053b37b7803f748efc456076f929c6a895556932eaf2d23b07f", size = 5331407, upload-time = "2026-01-29T23:03:58.481Z" }, + { url = "https://files.pythonhosted.org/packages/e0/d9/1f07395b54413432624d61524dfd98c1a7c7827d2abfdb8829ac92638205/debugpy-1.8.20-cp314-cp314-win_amd64.whl", hash = "sha256:a98eec61135465b062846112e5ecf2eebb855305acc1dfbae43b72903b8ab5be", size = 5372521, upload-time = "2026-01-29T23:03:59.864Z" }, + { url = "https://files.pythonhosted.org/packages/e0/c3/7f67dea8ccf8fdcb9c99033bbe3e90b9e7395415843accb81428c441be2d/debugpy-1.8.20-py2.py3-none-any.whl", hash = "sha256:5be9bed9ae3be00665a06acaa48f8329d2b9632f15fd09f6a9a8c8d9907e54d7", size = 5337658, upload-time = "2026-01-29T23:04:17.404Z" }, +] + +[[package]] +name = "decorator" +version = "5.2.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/43/fa/6d96a0978d19e17b68d634497769987b16c8f4cd0a7a05048bec693caa6b/decorator-5.2.1.tar.gz", hash = "sha256:65f266143752f734b0a7cc83c46f4618af75b8c5911b00ccb61d0ac9b6da0360", size = 56711, upload-time = "2025-02-24T04:41:34.073Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4e/8c/f3147f5c4b73e7550fe5f9352eaa956ae838d5c51eb58e7a25b9f3e2643b/decorator-5.2.1-py3-none-any.whl", hash = "sha256:d316bb415a2d9e2d2b3abcc4084c6502fc09240e292cd76a76afc106a1c8e04a", size = 9190, upload-time = "2025-02-24T04:41:32.565Z" }, +] + +[[package]] +name = "enczoo" +version = "0.1.3.dev1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "clip" }, + { name = "pillow" }, + { name = "tensorflow" }, + { name = "torch" }, + { name = "torchvision" }, + { name = "tqdm" }, + { name = "transformers" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ef/2c/1a704e5fcbcd242578337e1b83c0234417dfb082b0d45cc850bd16ec5e4f/enczoo-0.1.3.dev1.tar.gz", hash = "sha256:15ba63c43de120c40f250a65f1980923bfc2b381a031c113bd20fbe2119268c2", size = 11660, upload-time = "2026-03-24T17:31:07.368Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/05/50/dd2168abeff0dd861f5162017cea976e15b4c009f365e4ea0dc8066a2947/enczoo-0.1.3.dev1-py3-none-any.whl", hash = "sha256:9f8f10834149b86483f5218634a466d678bd6bd1360c3e47be715e6a49d56263", size = 17232, upload-time = "2026-03-24T17:31:06.197Z" }, +] + +[[package]] +name = "executing" +version = "2.2.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/cc/28/c14e053b6762b1044f34a13aab6859bbf40456d37d23aa286ac24cfd9a5d/executing-2.2.1.tar.gz", hash = "sha256:3632cc370565f6648cc328b32435bd120a1e4ebb20c77e3fdde9a13cd1e533c4", size = 1129488, upload-time = "2025-09-01T09:48:10.866Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c1/ea/53f2148663b321f21b5a606bd5f191517cf40b7072c0497d3c92c4a13b1e/executing-2.2.1-py2.py3-none-any.whl", hash = "sha256:760643d3452b4d777d295bb167ccc74c64a81df23fb5e08eff250c425a4b2017", size = 28317, upload-time = "2025-09-01T09:48:08.5Z" }, +] + +[[package]] +name = "filelock" +version = "3.25.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/94/b8/00651a0f559862f3bb7d6f7477b192afe3f583cc5e26403b44e59a55ab34/filelock-3.25.2.tar.gz", hash = "sha256:b64ece2b38f4ca29dd3e810287aa8c48182bbecd1ae6e9ae126c9b35f1382694", size = 40480, upload-time = "2026-03-11T20:45:38.487Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a4/a5/842ae8f0c08b61d6484b52f99a03510a3a72d23141942d216ebe81fefbce/filelock-3.25.2-py3-none-any.whl", hash = "sha256:ca8afb0da15f229774c9ad1b455ed96e85a81373065fb10446672f64444ddf70", size = 26759, upload-time = "2026-03-11T20:45:37.437Z" }, +] + +[[package]] +name = "flatbuffers" +version = "25.12.19" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e8/2d/d2a548598be01649e2d46231d151a6c56d10b964d94043a335ae56ea2d92/flatbuffers-25.12.19-py2.py3-none-any.whl", hash = "sha256:7634f50c427838bb021c2d66a3d1168e9d199b0607e6329399f04846d42e20b4", size = 26661, upload-time = "2025-12-19T23:16:13.622Z" }, +] + [[package]] name = "fonttools" version = "4.62.1" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/9a/08/7012b00a9a5874311b639c3920270c36ee0c445b69d9989a85e5c92ebcb0/fonttools-4.62.1.tar.gz", hash = "sha256:e54c75fd6041f1122476776880f7c3c3295ffa31962dc6ebe2543c00dca58b5d", size = 3580737, upload-time = "2026-03-13T13:54:25.52Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/88/39/23ff32561ec8d45a4d48578b4d241369d9270dc50926c017570e60893701/fonttools-4.62.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:40975849bac44fb0b9253d77420c6d8b523ac4dcdcefeff6e4d706838a5b80f7", size = 2871039, upload-time = "2026-03-13T13:52:33.127Z" }, - { url = "https://files.pythonhosted.org/packages/24/7f/66d3f8a9338a9b67fe6e1739f47e1cd5cee78bd3bc1206ef9b0b982289a5/fonttools-4.62.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:9dde91633f77fa576879a0c76b1d89de373cae751a98ddf0109d54e173b40f14", size = 2416346, upload-time = "2026-03-13T13:52:35.676Z" }, - { url = "https://files.pythonhosted.org/packages/aa/53/5276ceba7bff95da7793a07c5284e1da901cf00341ce5e2f3273056c0cca/fonttools-4.62.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6acb4109f8bee00fec985c8c7afb02299e35e9c94b57287f3ea542f28bd0b0a7", size = 5100897, upload-time = "2026-03-13T13:52:38.102Z" }, - { url = "https://files.pythonhosted.org/packages/cc/a1/40a5c4d8e28b0851d53a8eeeb46fbd73c325a2a9a165f290a5ed90e6c597/fonttools-4.62.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1c5c25671ce8805e0d080e2ffdeca7f1e86778c5cbfbeae86d7f866d8830517b", size = 5071078, upload-time = "2026-03-13T13:52:41.305Z" }, - { url = "https://files.pythonhosted.org/packages/e3/be/d378fca4c65ea1956fee6d90ace6e861776809cbbc5af22388a090c3c092/fonttools-4.62.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:a5d8825e1140f04e6c99bb7d37a9e31c172f3bc208afbe02175339e699c710e1", size = 5076908, upload-time = "2026-03-13T13:52:44.122Z" }, - { url = "https://files.pythonhosted.org/packages/f8/d9/ae6a1d0693a4185a84605679c8a1f719a55df87b9c6e8e817bfdd9ef5936/fonttools-4.62.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:268abb1cb221e66c014acc234e872b7870d8b5d4657a83a8f4205094c32d2416", size = 5202275, upload-time = "2026-03-13T13:52:46.591Z" }, - { url = "https://files.pythonhosted.org/packages/54/6c/af95d9c4efb15cabff22642b608342f2bd67137eea6107202d91b5b03184/fonttools-4.62.1-cp311-cp311-win32.whl", hash = "sha256:942b03094d7edbb99bdf1ae7e9090898cad7bf9030b3d21f33d7072dbcb51a53", size = 2293075, upload-time = "2026-03-13T13:52:48.711Z" }, - { url = "https://files.pythonhosted.org/packages/d3/97/bf54c5b3f2be34e1f143e6db838dfdc54f2ffa3e68c738934c82f3b2a08d/fonttools-4.62.1-cp311-cp311-win_amd64.whl", hash = "sha256:e8514f4924375f77084e81467e63238b095abda5107620f49421c368a6017ed2", size = 2344593, upload-time = "2026-03-13T13:52:50.725Z" }, { url = "https://files.pythonhosted.org/packages/47/d4/dbacced3953544b9a93088cc10ef2b596d348c983d5c67a404fa41ec51ba/fonttools-4.62.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:90365821debbd7db678809c7491ca4acd1e0779b9624cdc6ddaf1f31992bf974", size = 2870219, upload-time = "2026-03-13T13:52:53.664Z" }, { url = "https://files.pythonhosted.org/packages/66/9e/a769c8e99b81e5a87ab7e5e7236684de4e96246aae17274e5347d11ebd78/fonttools-4.62.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:12859ff0b47dd20f110804c3e0d0970f7b832f561630cd879969011541a464a9", size = 2414891, upload-time = "2026-03-13T13:52:56.493Z" }, { url = "https://files.pythonhosted.org/packages/69/64/f19a9e3911968c37e1e620e14dfc5778299e1474f72f4e57c5ec771d9489/fonttools-4.62.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9c125ffa00c3d9003cdaaf7f2c79e6e535628093e14b5de1dccb08859b680936", size = 5033197, upload-time = "2026-03-13T13:52:59.179Z" }, @@ -144,14 +532,172 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/29/0b/5cbef6588dc9bd6b5c9ad6a4d5a8ca384d0cea089da31711bbeb4f9654a6/fonttools-4.62.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:19177c8d96c7c36359266e571c5173bcee9157b59cfc8cb0153c5673dc5a3a7d", size = 5122723, upload-time = "2026-03-13T13:53:08.662Z" }, { url = "https://files.pythonhosted.org/packages/4a/47/b3a5342d381595ef439adec67848bed561ab7fdb1019fa522e82101b7d9c/fonttools-4.62.1-cp312-cp312-win32.whl", hash = "sha256:a24decd24d60744ee8b4679d38e88b8303d86772053afc29b19d23bb8207803c", size = 2281278, upload-time = "2026-03-13T13:53:10.998Z" }, { url = "https://files.pythonhosted.org/packages/28/b1/0c2ab56a16f409c6c8a68816e6af707827ad5d629634691ff60a52879792/fonttools-4.62.1-cp312-cp312-win_amd64.whl", hash = "sha256:9e7863e10b3de72376280b515d35b14f5eeed639d1aa7824f4cf06779ec65e42", size = 2331414, upload-time = "2026-03-13T13:53:13.992Z" }, + { url = "https://files.pythonhosted.org/packages/3b/56/6f389de21c49555553d6a5aeed5ac9767631497ac836c4f076273d15bd72/fonttools-4.62.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:c22b1014017111c401469e3acc5433e6acf6ebcc6aa9efb538a533c800971c79", size = 2865155, upload-time = "2026-03-13T13:53:16.132Z" }, + { url = "https://files.pythonhosted.org/packages/03/c5/0e3966edd5ec668d41dfe418787726752bc07e2f5fd8c8f208615e61fa89/fonttools-4.62.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:68959f5fc58ed4599b44aad161c2837477d7f35f5f79402d97439974faebfebe", size = 2412802, upload-time = "2026-03-13T13:53:18.878Z" }, + { url = "https://files.pythonhosted.org/packages/52/94/e6ac4b44026de7786fe46e3bfa0c87e51d5d70a841054065d49cd62bb909/fonttools-4.62.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ef46db46c9447103b8f3ff91e8ba009d5fe181b1920a83757a5762551e32bb68", size = 5013926, upload-time = "2026-03-13T13:53:21.379Z" }, + { url = "https://files.pythonhosted.org/packages/e2/98/8b1e801939839d405f1f122e7d175cebe9aeb4e114f95bfc45e3152af9a7/fonttools-4.62.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:6706d1cb1d5e6251a97ad3c1b9347505c5615c112e66047abbef0f8545fa30d1", size = 4964575, upload-time = "2026-03-13T13:53:23.857Z" }, + { url = "https://files.pythonhosted.org/packages/46/76/7d051671e938b1881670528fec69cc4044315edd71a229c7fd712eaa5119/fonttools-4.62.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:2e7abd2b1e11736f58c1de27819e1955a53267c21732e78243fa2fa2e5c1e069", size = 4953693, upload-time = "2026-03-13T13:53:26.569Z" }, + { url = "https://files.pythonhosted.org/packages/1f/ae/b41f8628ec0be3c1b934fc12b84f4576a5c646119db4d3bdd76a217c90b5/fonttools-4.62.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:403d28ce06ebfc547fbcb0cb8b7f7cc2f7a2d3e1a67ba9a34b14632df9e080f9", size = 5094920, upload-time = "2026-03-13T13:53:29.329Z" }, + { url = "https://files.pythonhosted.org/packages/f2/f6/53a1e9469331a23dcc400970a27a4caa3d9f6edbf5baab0260285238b884/fonttools-4.62.1-cp313-cp313-win32.whl", hash = "sha256:93c316e0f5301b2adbe6a5f658634307c096fd5aae60a5b3412e4f3e1728ab24", size = 2279928, upload-time = "2026-03-13T13:53:32.352Z" }, + { url = "https://files.pythonhosted.org/packages/38/60/35186529de1db3c01f5ad625bde07c1f576305eab6d86bbda4c58445f721/fonttools-4.62.1-cp313-cp313-win_amd64.whl", hash = "sha256:7aa21ff53e28a9c2157acbc44e5b401149d3c9178107130e82d74ceb500e5056", size = 2330514, upload-time = "2026-03-13T13:53:34.991Z" }, + { url = "https://files.pythonhosted.org/packages/36/f0/2888cdac391807d68d90dcb16ef858ddc1b5309bfc6966195a459dd326e2/fonttools-4.62.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:fa1d16210b6b10a826d71bed68dd9ec24a9e218d5a5e2797f37c573e7ec215ca", size = 2864442, upload-time = "2026-03-13T13:53:37.509Z" }, + { url = "https://files.pythonhosted.org/packages/4b/b2/e521803081f8dc35990816b82da6360fa668a21b44da4b53fc9e77efcd62/fonttools-4.62.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:aa69d10ed420d8121118e628ad47d86e4caa79ba37f968597b958f6cceab7eca", size = 2410901, upload-time = "2026-03-13T13:53:40.55Z" }, + { url = "https://files.pythonhosted.org/packages/00/a4/8c3511ff06e53110039358dbbdc1a65d72157a054638387aa2ada300a8b8/fonttools-4.62.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bd13b7999d59c5eb1c2b442eb2d0c427cb517a0b7a1f5798fc5c9e003f5ff782", size = 4999608, upload-time = "2026-03-13T13:53:42.798Z" }, + { url = "https://files.pythonhosted.org/packages/28/63/cd0c3b26afe60995a5295f37c246a93d454023726c3261cfbb3559969bb9/fonttools-4.62.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8d337fdd49a79b0d51c4da87bc38169d21c3abbf0c1aa9367eff5c6656fb6dae", size = 4912726, upload-time = "2026-03-13T13:53:45.405Z" }, + { url = "https://files.pythonhosted.org/packages/70/b9/ac677cb07c24c685cf34f64e140617d58789d67a3dd524164b63648c6114/fonttools-4.62.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:d241cdc4a67b5431c6d7f115fdf63335222414995e3a1df1a41e1182acd4bcc7", size = 4951422, upload-time = "2026-03-13T13:53:48.326Z" }, + { url = "https://files.pythonhosted.org/packages/e6/10/11c08419a14b85b7ca9a9faca321accccc8842dd9e0b1c8a72908de05945/fonttools-4.62.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:c05557a78f8fa514da0f869556eeda40887a8abc77c76ee3f74cf241778afd5a", size = 5060979, upload-time = "2026-03-13T13:53:51.366Z" }, + { url = "https://files.pythonhosted.org/packages/4e/3c/12eea4a4cf054e7ab058ed5ceada43b46809fce2bf319017c4d63ae55bb4/fonttools-4.62.1-cp314-cp314-win32.whl", hash = "sha256:49a445d2f544ce4a69338694cad575ba97b9a75fff02720da0882d1a73f12800", size = 2283733, upload-time = "2026-03-13T13:53:53.606Z" }, + { url = "https://files.pythonhosted.org/packages/6b/67/74b070029043186b5dd13462c958cb7c7f811be0d2e634309d9a1ffb1505/fonttools-4.62.1-cp314-cp314-win_amd64.whl", hash = "sha256:1eecc128c86c552fb963fe846ca4e011b1be053728f798185a1687502f6d398e", size = 2335663, upload-time = "2026-03-13T13:53:56.23Z" }, + { url = "https://files.pythonhosted.org/packages/42/c5/4d2ed3ca6e33617fc5624467da353337f06e7f637707478903c785bd8e20/fonttools-4.62.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:1596aeaddf7f78e21e68293c011316a25267b3effdaccaf4d59bc9159d681b82", size = 2947288, upload-time = "2026-03-13T13:53:59.397Z" }, + { url = "https://files.pythonhosted.org/packages/1f/e9/7ab11ddfda48ed0f89b13380e5595ba572619c27077be0b2c447a63ff351/fonttools-4.62.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:8f8fca95d3bb3208f59626a4b0ea6e526ee51f5a8ad5d91821c165903e8d9260", size = 2449023, upload-time = "2026-03-13T13:54:01.642Z" }, + { url = "https://files.pythonhosted.org/packages/b2/10/a800fa090b5e8819942e54e19b55fc7c21fe14a08757c3aa3ca8db358939/fonttools-4.62.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee91628c08e76f77b533d65feb3fbe6d9dad699f95be51cf0d022db94089cdc4", size = 5137599, upload-time = "2026-03-13T13:54:04.495Z" }, + { url = "https://files.pythonhosted.org/packages/37/dc/8ccd45033fffd74deb6912fa1ca524643f584b94c87a16036855b498a1ed/fonttools-4.62.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:5f37df1cac61d906e7b836abe356bc2f34c99d4477467755c216b72aa3dc748b", size = 4920933, upload-time = "2026-03-13T13:54:07.557Z" }, + { url = "https://files.pythonhosted.org/packages/99/eb/e618adefb839598d25ac8136cd577925d6c513dc0d931d93b8af956210f0/fonttools-4.62.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:92bb00a947e666169c99b43753c4305fc95a890a60ef3aeb2a6963e07902cc87", size = 5016232, upload-time = "2026-03-13T13:54:10.611Z" }, + { url = "https://files.pythonhosted.org/packages/d9/5f/9b5c9bfaa8ec82def8d8168c4f13615990d6ce5996fe52bd49bfb5e05134/fonttools-4.62.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:bdfe592802ef939a0e33106ea4a318eeb17822c7ee168c290273cbd5fabd746c", size = 5042987, upload-time = "2026-03-13T13:54:13.569Z" }, + { url = "https://files.pythonhosted.org/packages/90/aa/dfbbe24c6a6afc5c203d90cc0343e24bcbb09e76d67c4d6eef8c2558d7ba/fonttools-4.62.1-cp314-cp314t-win32.whl", hash = "sha256:b820fcb92d4655513d8402d5b219f94481c4443d825b4372c75a2072aa4b357a", size = 2348021, upload-time = "2026-03-13T13:54:16.98Z" }, + { url = "https://files.pythonhosted.org/packages/13/6f/ae9c4e4dd417948407b680855c2c7790efb52add6009aaecff1e3bc50e8e/fonttools-4.62.1-cp314-cp314t-win_amd64.whl", hash = "sha256:59b372b4f0e113d3746b88985f1c796e7bf830dd54b28374cd85c2b8acd7583e", size = 2414147, upload-time = "2026-03-13T13:54:19.416Z" }, { url = "https://files.pythonhosted.org/packages/fd/ba/56147c165442cc5ba7e82ecf301c9a68353cede498185869e6e02b4c264f/fonttools-4.62.1-py3-none-any.whl", hash = "sha256:7487782e2113861f4ddcc07c3436450659e3caa5e470b27dc2177cade2d8e7fd", size = 1152647, upload-time = "2026-03-13T13:54:22.735Z" }, ] +[[package]] +name = "fsspec" +version = "2026.2.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/51/7c/f60c259dcbf4f0c47cc4ddb8f7720d2dcdc8888c8e5ad84c73ea4531cc5b/fsspec-2026.2.0.tar.gz", hash = "sha256:6544e34b16869f5aacd5b90bdf1a71acb37792ea3ddf6125ee69a22a53fb8bff", size = 313441, upload-time = "2026-02-05T21:50:53.743Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e6/ab/fb21f4c939bb440104cc2b396d3be1d9b7a9fd3c6c2a53d98c45b3d7c954/fsspec-2026.2.0-py3-none-any.whl", hash = "sha256:98de475b5cb3bd66bedd5c4679e87b4fdfe1a3bf4d707b151b3c07e58c9a2437", size = 202505, upload-time = "2026-02-05T21:50:51.819Z" }, +] + +[[package]] +name = "gast" +version = "0.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/91/f6/e73969782a2ecec280f8a176f2476149dd9dba69d5f8779ec6108a7721e6/gast-0.7.0.tar.gz", hash = "sha256:0bb14cd1b806722e91ddbab6fb86bba148c22b40e7ff11e248974e04c8adfdae", size = 33630, upload-time = "2025-11-29T15:30:05.266Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1d/33/f1c6a276de27b7d7339a34749cc33fa87f077f921969c47185d34a887ae2/gast-0.7.0-py3-none-any.whl", hash = "sha256:99cbf1365633a74099f69c59bd650476b96baa5ef196fec88032b00b31ba36f7", size = 22966, upload-time = "2025-11-29T15:30:03.983Z" }, +] + +[[package]] +name = "google-pasta" +version = "0.2.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "six" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/35/4a/0bd53b36ff0323d10d5f24ebd67af2de10a1117f5cf4d7add90df92756f1/google-pasta-0.2.0.tar.gz", hash = "sha256:c9f2c8dfc8f96d0d5808299920721be30c9eec37f2389f28904f454565c8a16e", size = 40430, upload-time = "2020-03-13T18:57:50.34Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a3/de/c648ef6835192e6e2cc03f40b19eeda4382c49b5bafb43d88b931c4c74ac/google_pasta-0.2.0-py3-none-any.whl", hash = "sha256:b32482794a366b5366a32c92a9a9201b107821889935a02b3e51f6b432ea84ed", size = 57471, upload-time = "2020-03-13T18:57:48.872Z" }, +] + +[[package]] +name = "grpcio" +version = "1.78.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/06/8a/3d098f35c143a89520e568e6539cc098fcd294495910e359889ce8741c84/grpcio-1.78.0.tar.gz", hash = "sha256:7382b95189546f375c174f53a5fa873cef91c4b8005faa05cc5b3beea9c4f1c5", size = 12852416, upload-time = "2026-02-06T09:57:18.093Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4e/f4/7384ed0178203d6074446b3c4f46c90a22ddf7ae0b3aee521627f54cfc2a/grpcio-1.78.0-cp312-cp312-linux_armv7l.whl", hash = "sha256:f9ab915a267fc47c7e88c387a3a28325b58c898e23d4995f765728f4e3dedb97", size = 5913985, upload-time = "2026-02-06T09:55:26.832Z" }, + { url = "https://files.pythonhosted.org/packages/81/ed/be1caa25f06594463f685b3790b320f18aea49b33166f4141bfdc2bfb236/grpcio-1.78.0-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:3f8904a8165ab21e07e58bf3e30a73f4dffc7a1e0dbc32d51c61b5360d26f43e", size = 11811853, upload-time = "2026-02-06T09:55:29.224Z" }, + { url = "https://files.pythonhosted.org/packages/24/a7/f06d151afc4e64b7e3cc3e872d331d011c279aaab02831e40a81c691fb65/grpcio-1.78.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:859b13906ce098c0b493af92142ad051bf64c7870fa58a123911c88606714996", size = 6475766, upload-time = "2026-02-06T09:55:31.825Z" }, + { url = "https://files.pythonhosted.org/packages/8a/a8/4482922da832ec0082d0f2cc3a10976d84a7424707f25780b82814aafc0a/grpcio-1.78.0-cp312-cp312-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:b2342d87af32790f934a79c3112641e7b27d63c261b8b4395350dad43eff1dc7", size = 7170027, upload-time = "2026-02-06T09:55:34.7Z" }, + { url = "https://files.pythonhosted.org/packages/54/bf/f4a3b9693e35d25b24b0b39fa46d7d8a3c439e0a3036c3451764678fec20/grpcio-1.78.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:12a771591ae40bc65ba67048fa52ef4f0e6db8279e595fd349f9dfddeef571f9", size = 6690766, upload-time = "2026-02-06T09:55:36.902Z" }, + { url = "https://files.pythonhosted.org/packages/c7/b9/521875265cc99fe5ad4c5a17010018085cae2810a928bf15ebe7d8bcd9cc/grpcio-1.78.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:185dea0d5260cbb2d224c507bf2a5444d5abbb1fa3594c1ed7e4c709d5eb8383", size = 7266161, upload-time = "2026-02-06T09:55:39.824Z" }, + { url = "https://files.pythonhosted.org/packages/05/86/296a82844fd40a4ad4a95f100b55044b4f817dece732bf686aea1a284147/grpcio-1.78.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:51b13f9aed9d59ee389ad666b8c2214cc87b5de258fa712f9ab05f922e3896c6", size = 8253303, upload-time = "2026-02-06T09:55:42.353Z" }, + { url = "https://files.pythonhosted.org/packages/f3/e4/ea3c0caf5468537f27ad5aab92b681ed7cc0ef5f8c9196d3fd42c8c2286b/grpcio-1.78.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fd5f135b1bd58ab088930b3c613455796dfa0393626a6972663ccdda5b4ac6ce", size = 7698222, upload-time = "2026-02-06T09:55:44.629Z" }, + { url = "https://files.pythonhosted.org/packages/d7/47/7f05f81e4bb6b831e93271fb12fd52ba7b319b5402cbc101d588f435df00/grpcio-1.78.0-cp312-cp312-win32.whl", hash = "sha256:94309f498bcc07e5a7d16089ab984d42ad96af1d94b5a4eb966a266d9fcabf68", size = 4066123, upload-time = "2026-02-06T09:55:47.644Z" }, + { url = "https://files.pythonhosted.org/packages/ad/e7/d6914822c88aa2974dbbd10903d801a28a19ce9cd8bad7e694cbbcf61528/grpcio-1.78.0-cp312-cp312-win_amd64.whl", hash = "sha256:9566fe4ababbb2610c39190791e5b829869351d14369603702e890ef3ad2d06e", size = 4797657, upload-time = "2026-02-06T09:55:49.86Z" }, + { url = "https://files.pythonhosted.org/packages/05/a9/8f75894993895f361ed8636cd9237f4ab39ef87fd30db17467235ed1c045/grpcio-1.78.0-cp313-cp313-linux_armv7l.whl", hash = "sha256:ce3a90455492bf8bfa38e56fbbe1dbd4f872a3d8eeaf7337dc3b1c8aa28c271b", size = 5920143, upload-time = "2026-02-06T09:55:52.035Z" }, + { url = "https://files.pythonhosted.org/packages/55/06/0b78408e938ac424100100fd081189451b472236e8a3a1f6500390dc4954/grpcio-1.78.0-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:2bf5e2e163b356978b23652c4818ce4759d40f4712ee9ec5a83c4be6f8c23a3a", size = 11803926, upload-time = "2026-02-06T09:55:55.494Z" }, + { url = "https://files.pythonhosted.org/packages/88/93/b59fe7832ff6ae3c78b813ea43dac60e295fa03606d14d89d2e0ec29f4f3/grpcio-1.78.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:8f2ac84905d12918e4e55a16da17939eb63e433dc11b677267c35568aa63fc84", size = 6478628, upload-time = "2026-02-06T09:55:58.533Z" }, + { url = "https://files.pythonhosted.org/packages/ed/df/e67e3734527f9926b7d9c0dde6cd998d1d26850c3ed8eeec81297967ac67/grpcio-1.78.0-cp313-cp313-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:b58f37edab4a3881bc6c9bca52670610e0c9ca14e2ea3cf9debf185b870457fb", size = 7173574, upload-time = "2026-02-06T09:56:01.786Z" }, + { url = "https://files.pythonhosted.org/packages/a6/62/cc03fffb07bfba982a9ec097b164e8835546980aec25ecfa5f9c1a47e022/grpcio-1.78.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:735e38e176a88ce41840c21bb49098ab66177c64c82426e24e0082500cc68af5", size = 6692639, upload-time = "2026-02-06T09:56:04.529Z" }, + { url = "https://files.pythonhosted.org/packages/bf/9a/289c32e301b85bdb67d7ec68b752155e674ee3ba2173a1858f118e399ef3/grpcio-1.78.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:2045397e63a7a0ee7957c25f7dbb36ddc110e0cfb418403d110c0a7a68a844e9", size = 7268838, upload-time = "2026-02-06T09:56:08.397Z" }, + { url = "https://files.pythonhosted.org/packages/0e/79/1be93f32add280461fa4773880196572563e9c8510861ac2da0ea0f892b6/grpcio-1.78.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:a9f136fbafe7ccf4ac7e8e0c28b31066e810be52d6e344ef954a3a70234e1702", size = 8251878, upload-time = "2026-02-06T09:56:10.914Z" }, + { url = "https://files.pythonhosted.org/packages/65/65/793f8e95296ab92e4164593674ae6291b204bb5f67f9d4a711489cd30ffa/grpcio-1.78.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:748b6138585379c737adc08aeffd21222abbda1a86a0dca2a39682feb9196c20", size = 7695412, upload-time = "2026-02-06T09:56:13.593Z" }, + { url = "https://files.pythonhosted.org/packages/1c/9f/1e233fe697ecc82845942c2822ed06bb522e70d6771c28d5528e4c50f6a4/grpcio-1.78.0-cp313-cp313-win32.whl", hash = "sha256:271c73e6e5676afe4fc52907686670c7cea22ab2310b76a59b678403ed40d670", size = 4064899, upload-time = "2026-02-06T09:56:15.601Z" }, + { url = "https://files.pythonhosted.org/packages/4d/27/d86b89e36de8a951501fb06a0f38df19853210f341d0b28f83f4aa0ffa08/grpcio-1.78.0-cp313-cp313-win_amd64.whl", hash = "sha256:f2d4e43ee362adfc05994ed479334d5a451ab7bc3f3fee1b796b8ca66895acb4", size = 4797393, upload-time = "2026-02-06T09:56:17.882Z" }, + { url = "https://files.pythonhosted.org/packages/29/f2/b56e43e3c968bfe822fa6ce5bca10d5c723aa40875b48791ce1029bb78c7/grpcio-1.78.0-cp314-cp314-linux_armv7l.whl", hash = "sha256:e87cbc002b6f440482b3519e36e1313eb5443e9e9e73d6a52d43bd2004fcfd8e", size = 5920591, upload-time = "2026-02-06T09:56:20.758Z" }, + { url = "https://files.pythonhosted.org/packages/5d/81/1f3b65bd30c334167bfa8b0d23300a44e2725ce39bba5b76a2460d85f745/grpcio-1.78.0-cp314-cp314-macosx_11_0_universal2.whl", hash = "sha256:c41bc64626db62e72afec66b0c8a0da76491510015417c127bfc53b2fe6d7f7f", size = 11813685, upload-time = "2026-02-06T09:56:24.315Z" }, + { url = "https://files.pythonhosted.org/packages/0e/1c/bbe2f8216a5bd3036119c544d63c2e592bdf4a8ec6e4a1867592f4586b26/grpcio-1.78.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:8dfffba826efcf366b1e3ccc37e67afe676f290e13a3b48d31a46739f80a8724", size = 6487803, upload-time = "2026-02-06T09:56:27.367Z" }, + { url = "https://files.pythonhosted.org/packages/16/5c/a6b2419723ea7ddce6308259a55e8e7593d88464ce8db9f4aa857aba96fa/grpcio-1.78.0-cp314-cp314-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:74be1268d1439eaaf552c698cdb11cd594f0c49295ae6bb72c34ee31abbe611b", size = 7173206, upload-time = "2026-02-06T09:56:29.876Z" }, + { url = "https://files.pythonhosted.org/packages/df/1e/b8801345629a415ea7e26c83d75eb5dbe91b07ffe5210cc517348a8d4218/grpcio-1.78.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:be63c88b32e6c0f1429f1398ca5c09bc64b0d80950c8bb7807d7d7fb36fb84c7", size = 6693826, upload-time = "2026-02-06T09:56:32.305Z" }, + { url = "https://files.pythonhosted.org/packages/34/84/0de28eac0377742679a510784f049738a80424b17287739fc47d63c2439e/grpcio-1.78.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:3c586ac70e855c721bda8f548d38c3ca66ac791dc49b66a8281a1f99db85e452", size = 7277897, upload-time = "2026-02-06T09:56:34.915Z" }, + { url = "https://files.pythonhosted.org/packages/ca/9c/ad8685cfe20559a9edb66f735afdcb2b7d3de69b13666fdfc542e1916ebd/grpcio-1.78.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:35eb275bf1751d2ffbd8f57cdbc46058e857cf3971041521b78b7db94bdaf127", size = 8252404, upload-time = "2026-02-06T09:56:37.553Z" }, + { url = "https://files.pythonhosted.org/packages/3c/05/33a7a4985586f27e1de4803887c417ec7ced145ebd069bc38a9607059e2b/grpcio-1.78.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:207db540302c884b8848036b80db352a832b99dfdf41db1eb554c2c2c7800f65", size = 7696837, upload-time = "2026-02-06T09:56:40.173Z" }, + { url = "https://files.pythonhosted.org/packages/73/77/7382241caf88729b106e49e7d18e3116216c778e6a7e833826eb96de22f7/grpcio-1.78.0-cp314-cp314-win32.whl", hash = "sha256:57bab6deef2f4f1ca76cc04565df38dc5713ae6c17de690721bdf30cb1e0545c", size = 4142439, upload-time = "2026-02-06T09:56:43.258Z" }, + { url = "https://files.pythonhosted.org/packages/48/b2/b096ccce418882fbfda4f7496f9357aaa9a5af1896a9a7f60d9f2b275a06/grpcio-1.78.0-cp314-cp314-win_amd64.whl", hash = "sha256:dce09d6116df20a96acfdbf85e4866258c3758180e8c49845d6ba8248b6d0bbb", size = 4929852, upload-time = "2026-02-06T09:56:45.885Z" }, +] + +[[package]] +name = "h11" +version = "0.16.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" }, +] + +[[package]] +name = "h5py" +version = "3.14.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/5d/57/dfb3c5c3f1bf5f5ef2e59a22dec4ff1f3d7408b55bfcefcfb0ea69ef21c6/h5py-3.14.0.tar.gz", hash = "sha256:2372116b2e0d5d3e5e705b7f663f7c8d96fa79a4052d250484ef91d24d6a08f4", size = 424323, upload-time = "2025-06-06T14:06:15.01Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3e/77/8f651053c1843391e38a189ccf50df7e261ef8cd8bfd8baba0cbe694f7c3/h5py-3.14.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:e0045115d83272090b0717c555a31398c2c089b87d212ceba800d3dc5d952e23", size = 3312740, upload-time = "2025-06-06T14:05:01.193Z" }, + { url = "https://files.pythonhosted.org/packages/ff/10/20436a6cf419b31124e59fefc78d74cb061ccb22213226a583928a65d715/h5py-3.14.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6da62509b7e1d71a7d110478aa25d245dd32c8d9a1daee9d2a42dba8717b047a", size = 2829207, upload-time = "2025-06-06T14:05:05.061Z" }, + { url = "https://files.pythonhosted.org/packages/3f/19/c8bfe8543bfdd7ccfafd46d8cfd96fce53d6c33e9c7921f375530ee1d39a/h5py-3.14.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:554ef0ced3571366d4d383427c00c966c360e178b5fb5ee5bb31a435c424db0c", size = 4708455, upload-time = "2025-06-06T14:05:11.528Z" }, + { url = "https://files.pythonhosted.org/packages/86/f9/f00de11c82c88bfc1ef22633557bfba9e271e0cb3189ad704183fc4a2644/h5py-3.14.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0cbd41f4e3761f150aa5b662df991868ca533872c95467216f2bec5fcad84882", size = 4929422, upload-time = "2025-06-06T14:05:18.399Z" }, + { url = "https://files.pythonhosted.org/packages/7a/6d/6426d5d456f593c94b96fa942a9b3988ce4d65ebaf57d7273e452a7222e8/h5py-3.14.0-cp312-cp312-win_amd64.whl", hash = "sha256:bf4897d67e613ecf5bdfbdab39a1158a64df105827da70ea1d90243d796d367f", size = 2862845, upload-time = "2025-06-06T14:05:23.699Z" }, + { url = "https://files.pythonhosted.org/packages/6c/c2/7efe82d09ca10afd77cd7c286e42342d520c049a8c43650194928bcc635c/h5py-3.14.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:aa4b7bbce683379b7bf80aaba68e17e23396100336a8d500206520052be2f812", size = 3289245, upload-time = "2025-06-06T14:05:28.24Z" }, + { url = "https://files.pythonhosted.org/packages/4f/31/f570fab1239b0d9441024b92b6ad03bb414ffa69101a985e4c83d37608bd/h5py-3.14.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:ef9603a501a04fcd0ba28dd8f0995303d26a77a980a1f9474b3417543d4c6174", size = 2807335, upload-time = "2025-06-06T14:05:31.997Z" }, + { url = "https://files.pythonhosted.org/packages/0d/ce/3a21d87896bc7e3e9255e0ad5583ae31ae9e6b4b00e0bcb2a67e2b6acdbc/h5py-3.14.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e8cbaf6910fa3983c46172666b0b8da7b7bd90d764399ca983236f2400436eeb", size = 4700675, upload-time = "2025-06-06T14:05:37.38Z" }, + { url = "https://files.pythonhosted.org/packages/e7/ec/86f59025306dcc6deee5fda54d980d077075b8d9889aac80f158bd585f1b/h5py-3.14.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d90e6445ab7c146d7f7981b11895d70bc1dd91278a4f9f9028bc0c95e4a53f13", size = 4921632, upload-time = "2025-06-06T14:05:43.464Z" }, + { url = "https://files.pythonhosted.org/packages/3f/6d/0084ed0b78d4fd3e7530c32491f2884140d9b06365dac8a08de726421d4a/h5py-3.14.0-cp313-cp313-win_amd64.whl", hash = "sha256:ae18e3de237a7a830adb76aaa68ad438d85fe6e19e0d99944a3ce46b772c69b3", size = 2852929, upload-time = "2025-06-06T14:05:47.659Z" }, +] + +[[package]] +name = "hf-xet" +version = "1.4.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/09/08/23c84a26716382c89151b5b447b4beb19e3345f3a93d3b73009a71a57ad3/hf_xet-1.4.2.tar.gz", hash = "sha256:b7457b6b482d9e0743bd116363239b1fa904a5e65deede350fbc0c4ea67c71ea", size = 672357, upload-time = "2026-03-13T06:58:51.077Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/18/06/e8cf74c3c48e5485c7acc5a990d0d8516cdfb5fdf80f799174f1287cc1b5/hf_xet-1.4.2-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:ac8202ae1e664b2c15cdfc7298cbb25e80301ae596d602ef7870099a126fcad4", size = 3796125, upload-time = "2026-03-13T06:58:33.177Z" }, + { url = "https://files.pythonhosted.org/packages/66/d4/b73ebab01cbf60777323b7de9ef05550790451eb5172a220d6b9845385ec/hf_xet-1.4.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:6d2f8ee39fa9fba9af929f8c0d0482f8ee6e209179ad14a909b6ad78ffcb7c81", size = 3555985, upload-time = "2026-03-13T06:58:31.797Z" }, + { url = "https://files.pythonhosted.org/packages/ff/e7/ded6d1bd041c3f2bca9e913a0091adfe32371988e047dd3a68a2463c15a2/hf_xet-1.4.2-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4642a6cf249c09da8c1f87fe50b24b2a3450b235bf8adb55700b52f0ea6e2eb6", size = 4212085, upload-time = "2026-03-13T06:58:24.323Z" }, + { url = "https://files.pythonhosted.org/packages/97/c1/a0a44d1f98934f7bdf17f7a915b934f9fca44bb826628c553589900f6df8/hf_xet-1.4.2-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:769431385e746c92dc05492dde6f687d304584b89c33d79def8367ace06cb555", size = 3988266, upload-time = "2026-03-13T06:58:22.887Z" }, + { url = "https://files.pythonhosted.org/packages/7a/82/be713b439060e7d1f1d93543c8053d4ef2fe7e6922c5b31642eaa26f3c4b/hf_xet-1.4.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:c9dd1c1bc4cc56168f81939b0e05b4c36dd2d28c13dc1364b17af89aa0082496", size = 4188513, upload-time = "2026-03-13T06:58:40.858Z" }, + { url = "https://files.pythonhosted.org/packages/21/a6/cbd4188b22abd80ebd0edbb2b3e87f2633e958983519980815fb8314eae5/hf_xet-1.4.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:fca58a2ae4e6f6755cc971ac6fcdf777ea9284d7e540e350bb000813b9a3008d", size = 4428287, upload-time = "2026-03-13T06:58:42.601Z" }, + { url = "https://files.pythonhosted.org/packages/b2/4e/84e45b25e2e3e903ed3db68d7eafa96dae9a1d1f6d0e7fc85120347a852f/hf_xet-1.4.2-cp313-cp313t-win_amd64.whl", hash = "sha256:163aab46854ccae0ab6a786f8edecbbfbaa38fcaa0184db6feceebf7000c93c0", size = 3665574, upload-time = "2026-03-13T06:58:53.881Z" }, + { url = "https://files.pythonhosted.org/packages/ee/71/c5ac2b9a7ae39c14e91973035286e73911c31980fe44e7b1d03730c00adc/hf_xet-1.4.2-cp313-cp313t-win_arm64.whl", hash = "sha256:09b138422ecbe50fd0c84d4da5ff537d27d487d3607183cd10e3e53f05188e82", size = 3528760, upload-time = "2026-03-13T06:58:52.187Z" }, + { url = "https://files.pythonhosted.org/packages/1e/0f/fcd2504015eab26358d8f0f232a1aed6b8d363a011adef83fe130bff88f7/hf_xet-1.4.2-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:949dcf88b484bb9d9276ca83f6599e4aa03d493c08fc168c124ad10b2e6f75d7", size = 3796493, upload-time = "2026-03-13T06:58:39.267Z" }, + { url = "https://files.pythonhosted.org/packages/82/56/19c25105ff81731ca6d55a188b5de2aa99d7a2644c7aa9de1810d5d3b726/hf_xet-1.4.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:41659966020d59eb9559c57de2cde8128b706a26a64c60f0531fa2318f409418", size = 3555797, upload-time = "2026-03-13T06:58:37.546Z" }, + { url = "https://files.pythonhosted.org/packages/bf/e3/8933c073186849b5e06762aa89847991d913d10a95d1603eb7f2c3834086/hf_xet-1.4.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:5c588e21d80010119458dd5d02a69093f0d115d84e3467efe71ffb2c67c19146", size = 4212127, upload-time = "2026-03-13T06:58:30.539Z" }, + { url = "https://files.pythonhosted.org/packages/eb/01/f89ebba4e369b4ed699dcb60d3152753870996f41c6d22d3d7cac01310e1/hf_xet-1.4.2-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:a296744d771a8621ad1d50c098d7ab975d599800dae6d48528ba3944e5001ba0", size = 3987788, upload-time = "2026-03-13T06:58:29.139Z" }, + { url = "https://files.pythonhosted.org/packages/84/4d/8a53e5ffbc2cc33bbf755382ac1552c6d9af13f623ed125fe67cc3e6772f/hf_xet-1.4.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:f563f7efe49588b7d0629d18d36f46d1658fe7e08dce3fa3d6526e1c98315e2d", size = 4188315, upload-time = "2026-03-13T06:58:48.017Z" }, + { url = "https://files.pythonhosted.org/packages/d1/b8/b7a1c1b5592254bd67050632ebbc1b42cc48588bf4757cb03c2ef87e704a/hf_xet-1.4.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5b2e0132c56d7ee1bf55bdb638c4b62e7106f6ac74f0b786fed499d5548c5570", size = 4428306, upload-time = "2026-03-13T06:58:49.502Z" }, + { url = "https://files.pythonhosted.org/packages/a0/0c/40779e45b20e11c7c5821a94135e0207080d6b3d76e7b78ccb413c6f839b/hf_xet-1.4.2-cp314-cp314t-win_amd64.whl", hash = "sha256:2f45c712c2fa1215713db10df6ac84b49d0e1c393465440e9cb1de73ecf7bbf6", size = 3665826, upload-time = "2026-03-13T06:58:59.88Z" }, + { url = "https://files.pythonhosted.org/packages/51/4c/e2688c8ad1760d7c30f7c429c79f35f825932581bc7c9ec811436d2f21a0/hf_xet-1.4.2-cp314-cp314t-win_arm64.whl", hash = "sha256:6d53df40616f7168abfccff100d232e9d460583b9d86fa4912c24845f192f2b8", size = 3529113, upload-time = "2026-03-13T06:58:58.491Z" }, + { url = "https://files.pythonhosted.org/packages/b4/86/b40b83a2ff03ef05c4478d2672b1fc2b9683ff870e2b25f4f3af240f2e7b/hf_xet-1.4.2-cp37-abi3-macosx_10_12_x86_64.whl", hash = "sha256:71f02d6e4cdd07f344f6844845d78518cc7186bd2bc52d37c3b73dc26a3b0bc5", size = 3800339, upload-time = "2026-03-13T06:58:36.245Z" }, + { url = "https://files.pythonhosted.org/packages/64/2e/af4475c32b4378b0e92a587adb1aa3ec53e3450fd3e5fe0372a874531c00/hf_xet-1.4.2-cp37-abi3-macosx_11_0_arm64.whl", hash = "sha256:e9b38d876e94d4bdcf650778d6ebbaa791dd28de08db9736c43faff06ede1b5a", size = 3559664, upload-time = "2026-03-13T06:58:34.787Z" }, + { url = "https://files.pythonhosted.org/packages/3c/4c/781267da3188db679e601de18112021a5cb16506fe86b246e22c5401a9c4/hf_xet-1.4.2-cp37-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:77e8c180b7ef12d8a96739a4e1e558847002afe9ea63b6f6358b2271a8bdda1c", size = 4217422, upload-time = "2026-03-13T06:58:27.472Z" }, + { url = "https://files.pythonhosted.org/packages/68/47/d6cf4a39ecf6c7705f887a46f6ef5c8455b44ad9eb0d391aa7e8a2ff7fea/hf_xet-1.4.2-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:c3b3c6a882016b94b6c210957502ff7877802d0dbda8ad142c8595db8b944271", size = 3992847, upload-time = "2026-03-13T06:58:25.989Z" }, + { url = "https://files.pythonhosted.org/packages/2d/ef/e80815061abff54697239803948abc665c6b1d237102c174f4f7a9a5ffc5/hf_xet-1.4.2-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:9d9a634cc929cfbaf2e1a50c0e532ae8c78fa98618426769480c58501e8c8ac2", size = 4193843, upload-time = "2026-03-13T06:58:44.59Z" }, + { url = "https://files.pythonhosted.org/packages/54/75/07f6aa680575d9646c4167db6407c41340cbe2357f5654c4e72a1b01ca14/hf_xet-1.4.2-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:6b0932eb8b10317ea78b7da6bab172b17be03bbcd7809383d8d5abd6a2233e04", size = 4432751, upload-time = "2026-03-13T06:58:46.533Z" }, + { url = "https://files.pythonhosted.org/packages/cd/71/193eabd7e7d4b903c4aa983a215509c6114915a5a237525ec562baddb868/hf_xet-1.4.2-cp37-abi3-win_amd64.whl", hash = "sha256:ad185719fb2e8ac26f88c8100562dbf9dbdcc3d9d2add00faa94b5f106aea53f", size = 3671149, upload-time = "2026-03-13T06:58:57.07Z" }, + { url = "https://files.pythonhosted.org/packages/b4/7e/ccf239da366b37ba7f0b36095450efae4a64980bdc7ec2f51354205fdf39/hf_xet-1.4.2-cp37-abi3-win_arm64.whl", hash = "sha256:32c012286b581f783653e718c1862aea5b9eb140631685bb0c5e7012c8719a87", size = 3533426, upload-time = "2026-03-13T06:58:55.46Z" }, +] + [[package]] name = "hobj" version = "2.0.0" source = { editable = "." } dependencies = [ + { name = "ipykernel" }, { name = "matplotlib" }, { name = "numpy" }, { name = "pandas" }, @@ -164,11 +710,14 @@ dependencies = [ [package.dev-dependencies] dev = [ + { name = "enczoo" }, + { name = "netcdf4" }, { name = "pytest" }, ] [package.metadata] requires-dist = [ + { name = "ipykernel", specifier = ">=7.2.0" }, { name = "matplotlib", specifier = ">=3.9" }, { name = "numpy", specifier = ">=2.2" }, { name = "pandas", specifier = ">=2.2" }, @@ -180,7 +729,59 @@ requires-dist = [ ] [package.metadata.requires-dev] -dev = [{ name = "pytest", specifier = ">=8.3" }] +dev = [ + { name = "enczoo", specifier = "==0.1.3.dev1" }, + { name = "netcdf4", specifier = ">=1.7.4" }, + { name = "pytest", specifier = ">=8.3" }, +] + +[[package]] +name = "httpcore" +version = "1.0.9" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "h11" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" }, +] + +[[package]] +name = "httpx" +version = "0.28.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "certifi" }, + { name = "httpcore" }, + { name = "idna" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" }, +] + +[[package]] +name = "huggingface-hub" +version = "1.7.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "filelock" }, + { name = "fsspec" }, + { name = "hf-xet", marker = "platform_machine == 'AMD64' or platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'arm64' or platform_machine == 'x86_64'" }, + { name = "httpx" }, + { name = "packaging" }, + { name = "pyyaml" }, + { name = "tqdm" }, + { name = "typer" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/19/15/eafc1c57bf0f8afffb243dcd4c0cceb785e956acc17bba4d9bf2ae21fc9c/huggingface_hub-1.7.2.tar.gz", hash = "sha256:7f7e294e9bbb822e025bdb2ada025fa4344d978175a7f78e824d86e35f7ab43b", size = 724684, upload-time = "2026-03-20T10:36:08.767Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/08/de/3ad061a05f74728927ded48c90b73521b9a9328c85d841bdefb30e01fb85/huggingface_hub-1.7.2-py3-none-any.whl", hash = "sha256:288f33a0a17b2a73a1359e2a5fd28d1becb2c121748c6173ab8643fb342c850e", size = 618036, upload-time = "2026-03-20T10:36:06.824Z" }, +] [[package]] name = "idna" @@ -197,122 +798,750 @@ version = "2.3.0" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" }, + { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" }, +] + +[[package]] +name = "ipykernel" +version = "7.2.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "appnope", marker = "sys_platform == 'darwin'" }, + { name = "comm" }, + { name = "debugpy" }, + { name = "ipython" }, + { name = "jupyter-client" }, + { name = "jupyter-core" }, + { name = "matplotlib-inline" }, + { name = "nest-asyncio" }, + { name = "packaging" }, + { name = "psutil" }, + { name = "pyzmq" }, + { name = "tornado" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ca/8d/b68b728e2d06b9e0051019640a40a9eb7a88fcd82c2e1b5ce70bef5ff044/ipykernel-7.2.0.tar.gz", hash = "sha256:18ed160b6dee2cbb16e5f3575858bc19d8f1fe6046a9a680c708494ce31d909e", size = 176046, upload-time = "2026-02-06T16:43:27.403Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/82/b9/e73d5d9f405cba7706c539aa8b311b49d4c2f3d698d9c12f815231169c71/ipykernel-7.2.0-py3-none-any.whl", hash = "sha256:3bbd4420d2b3cc105cbdf3756bfc04500b1e52f090a90716851f3916c62e1661", size = 118788, upload-time = "2026-02-06T16:43:25.149Z" }, +] + +[[package]] +name = "ipython" +version = "9.11.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "decorator" }, + { name = "ipython-pygments-lexers" }, + { name = "jedi" }, + { name = "matplotlib-inline" }, + { name = "pexpect", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, + { name = "prompt-toolkit" }, + { name = "pygments" }, + { name = "stack-data" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/86/28/a4698eda5a8928a45d6b693578b135b753e14fa1c2b36ee9441e69a45576/ipython-9.11.0.tar.gz", hash = "sha256:2a94bc4406b22ecc7e4cb95b98450f3ea493a76bec8896cda11b78d7752a6667", size = 4427354, upload-time = "2026-03-05T08:57:30.549Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b2/90/45c72becc57158facc6a6404f663b77bbcea2519ca57f760e2879ae1315d/ipython-9.11.0-py3-none-any.whl", hash = "sha256:6922d5bcf944c6e525a76a0a304451b60a2b6f875e86656d8bc2dfda5d710e19", size = 624222, upload-time = "2026-03-05T08:57:28.94Z" }, +] + +[[package]] +name = "ipython-pygments-lexers" +version = "1.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ef/4c/5dd1d8af08107f88c7f741ead7a40854b8ac24ddf9ae850afbcf698aa552/ipython_pygments_lexers-1.1.1.tar.gz", hash = "sha256:09c0138009e56b6854f9535736f4171d855c8c08a563a0dcd8022f78355c7e81", size = 8393, upload-time = "2025-01-17T11:24:34.505Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d9/33/1f075bf72b0b747cb3288d011319aaf64083cf2efef8354174e3ed4540e2/ipython_pygments_lexers-1.1.1-py3-none-any.whl", hash = "sha256:a9462224a505ade19a605f71f8fa63c2048833ce50abc86768a0d81d876dc81c", size = 8074, upload-time = "2025-01-17T11:24:33.271Z" }, +] + +[[package]] +name = "jedi" +version = "0.19.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "parso" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/72/3a/79a912fbd4d8dd6fbb02bf69afd3bb72cf0c729bb3063c6f4498603db17a/jedi-0.19.2.tar.gz", hash = "sha256:4770dc3de41bde3966b02eb84fbcf557fb33cce26ad23da12c742fb50ecb11f0", size = 1231287, upload-time = "2024-11-11T01:41:42.873Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c0/5a/9cac0c82afec3d09ccd97c8b6502d48f165f9124db81b4bcb90b4af974ee/jedi-0.19.2-py2.py3-none-any.whl", hash = "sha256:a8ef22bde8490f57fe5c7681a3c83cb58874daf72b4784de3cce5b6ef6edb5b9", size = 1572278, upload-time = "2024-11-11T01:41:40.175Z" }, +] + +[[package]] +name = "jinja2" +version = "3.1.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markupsafe" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d", size = 245115, upload-time = "2025-03-05T20:05:02.478Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899, upload-time = "2025-03-05T20:05:00.369Z" }, +] + +[[package]] +name = "jupyter-client" +version = "8.8.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-core" }, + { name = "python-dateutil" }, + { name = "pyzmq" }, + { name = "tornado" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/05/e4/ba649102a3bc3fbca54e7239fb924fd434c766f855693d86de0b1f2bec81/jupyter_client-8.8.0.tar.gz", hash = "sha256:d556811419a4f2d96c869af34e854e3f059b7cc2d6d01a9cd9c85c267691be3e", size = 348020, upload-time = "2026-01-08T13:55:47.938Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2d/0b/ceb7694d864abc0a047649aec263878acb9f792e1fec3e676f22dc9015e3/jupyter_client-8.8.0-py3-none-any.whl", hash = "sha256:f93a5b99c5e23a507b773d3a1136bd6e16c67883ccdbd9a829b0bbdb98cd7d7a", size = 107371, upload-time = "2026-01-08T13:55:45.562Z" }, +] + +[[package]] +name = "jupyter-core" +version = "5.9.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "platformdirs" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/02/49/9d1284d0dc65e2c757b74c6687b6d319b02f822ad039e5c512df9194d9dd/jupyter_core-5.9.1.tar.gz", hash = "sha256:4d09aaff303b9566c3ce657f580bd089ff5c91f5f89cf7d8846c3cdf465b5508", size = 89814, upload-time = "2025-10-16T19:19:18.444Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e7/e7/80988e32bf6f73919a113473a604f5a8f09094de312b9d52b79c2df7612b/jupyter_core-5.9.1-py3-none-any.whl", hash = "sha256:ebf87fdc6073d142e114c72c9e29a9d7ca03fad818c5d300ce2adc1fb0743407", size = 29032, upload-time = "2025-10-16T19:19:16.783Z" }, +] + +[[package]] +name = "keras" +version = "3.13.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "absl-py" }, + { name = "h5py" }, + { name = "ml-dtypes" }, + { name = "namex" }, + { name = "numpy" }, + { name = "optree" }, + { name = "packaging" }, + { name = "rich" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/09/e9/400582e5f3dbd815d2a373f7de7717dd1bc8349274e9ac1b9ac47410b123/keras-3.13.2.tar.gz", hash = "sha256:62f0123488ac87c929c988617e14f293f7bc993811837d08bb37eff77adc85a9", size = 1155875, upload-time = "2026-01-30T00:35:13.796Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/28/b5/ea85873abc99dc64a7a27ff1a8dbfdc7dbb57d4e5d1a423abc11217af4f1/keras-3.13.2-py3-none-any.whl", hash = "sha256:14b2afc0f9c636cc295d28efc36aae42fc52e7b892c950eec33f3befe4d22fb5", size = 1513769, upload-time = "2026-01-30T00:35:09.664Z" }, +] + +[[package]] +name = "kiwisolver" +version = "1.5.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d0/67/9c61eccb13f0bdca9307614e782fec49ffdde0f7a2314935d489fa93cd9c/kiwisolver-1.5.0.tar.gz", hash = "sha256:d4193f3d9dc3f6f79aaed0e5637f45d98850ebf01f7ca20e69457f3e8946b66a", size = 103482, upload-time = "2026-03-09T13:15:53.382Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4d/b2/818b74ebea34dabe6d0c51cb1c572e046730e64844da6ed646d5298c40ce/kiwisolver-1.5.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:4e9750bc21b886308024f8a54ccb9a2cc38ac9fa813bf4348434e3d54f337ff9", size = 123158, upload-time = "2026-03-09T13:13:23.127Z" }, + { url = "https://files.pythonhosted.org/packages/bf/d9/405320f8077e8e1c5c4bd6adc45e1e6edf6d727b6da7f2e2533cf58bff71/kiwisolver-1.5.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:72ec46b7eba5b395e0a7b63025490d3214c11013f4aacb4f5e8d6c3041829588", size = 66388, upload-time = "2026-03-09T13:13:24.765Z" }, + { url = "https://files.pythonhosted.org/packages/99/9f/795fedf35634f746151ca8839d05681ceb6287fbed6cc1c9bf235f7887c2/kiwisolver-1.5.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ed3a984b31da7481b103f68776f7128a89ef26ed40f4dc41a2223cda7fb24819", size = 64068, upload-time = "2026-03-09T13:13:25.878Z" }, + { url = "https://files.pythonhosted.org/packages/c4/13/680c54afe3e65767bed7ec1a15571e1a2f1257128733851ade24abcefbcc/kiwisolver-1.5.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:bb5136fb5352d3f422df33f0c879a1b0c204004324150cc3b5e3c4f310c9049f", size = 1477934, upload-time = "2026-03-09T13:13:27.166Z" }, + { url = "https://files.pythonhosted.org/packages/c8/2f/cebfcdb60fd6a9b0f6b47a9337198bcbad6fbe15e68189b7011fd914911f/kiwisolver-1.5.0-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b2af221f268f5af85e776a73d62b0845fc8baf8ef0abfae79d29c77d0e776aaf", size = 1278537, upload-time = "2026-03-09T13:13:28.707Z" }, + { url = "https://files.pythonhosted.org/packages/f2/0d/9b782923aada3fafb1d6b84e13121954515c669b18af0c26e7d21f579855/kiwisolver-1.5.0-cp312-cp312-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b0f172dc8ffaccb8522d7c5d899de00133f2f1ca7b0a49b7da98e901de87bf2d", size = 1296685, upload-time = "2026-03-09T13:13:30.528Z" }, + { url = "https://files.pythonhosted.org/packages/27/70/83241b6634b04fe44e892688d5208332bde130f38e610c0418f9ede47ded/kiwisolver-1.5.0-cp312-cp312-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6ab8ba9152203feec73758dad83af9a0bbe05001eb4639e547207c40cfb52083", size = 1346024, upload-time = "2026-03-09T13:13:32.818Z" }, + { url = "https://files.pythonhosted.org/packages/e4/db/30ed226fb271ae1a6431fc0fe0edffb2efe23cadb01e798caeb9f2ceae8f/kiwisolver-1.5.0-cp312-cp312-manylinux_2_39_riscv64.whl", hash = "sha256:cdee07c4d7f6d72008d3f73b9bf027f4e11550224c7c50d8df1ae4a37c1402a6", size = 987241, upload-time = "2026-03-09T13:13:34.435Z" }, + { url = "https://files.pythonhosted.org/packages/ec/bd/c314595208e4c9587652d50959ead9e461995389664e490f4dce7ff0f782/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:7c60d3c9b06fb23bd9c6139281ccbdc384297579ae037f08ae90c69f6845c0b1", size = 2227742, upload-time = "2026-03-09T13:13:36.4Z" }, + { url = "https://files.pythonhosted.org/packages/c1/43/0499cec932d935229b5543d073c2b87c9c22846aab48881e9d8d6e742a2d/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:e315e5ec90d88e140f57696ff85b484ff68bb311e36f2c414aa4286293e6dee0", size = 2323966, upload-time = "2026-03-09T13:13:38.204Z" }, + { url = "https://files.pythonhosted.org/packages/3d/6f/79b0d760907965acfd9d61826a3d41f8f093c538f55cd2633d3f0db269f6/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:1465387ac63576c3e125e5337a6892b9e99e0627d52317f3ca79e6930d889d15", size = 1977417, upload-time = "2026-03-09T13:13:39.966Z" }, + { url = "https://files.pythonhosted.org/packages/ab/31/01d0537c41cb75a551a438c3c7a80d0c60d60b81f694dac83dd436aec0d0/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:530a3fd64c87cffa844d4b6b9768774763d9caa299e9b75d8eca6a4423b31314", size = 2491238, upload-time = "2026-03-09T13:13:41.698Z" }, + { url = "https://files.pythonhosted.org/packages/e4/34/8aefdd0be9cfd00a44509251ba864f5caf2991e36772e61c408007e7f417/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1d9daea4ea6b9be74fe2f01f7fbade8d6ffab263e781274cffca0dba9be9eec9", size = 2294947, upload-time = "2026-03-09T13:13:43.343Z" }, + { url = "https://files.pythonhosted.org/packages/ad/cf/0348374369ca588f8fe9c338fae49fa4e16eeb10ffb3d012f23a54578a9e/kiwisolver-1.5.0-cp312-cp312-win_amd64.whl", hash = "sha256:f18c2d9782259a6dc132fdc7a63c168cbc74b35284b6d75c673958982a378384", size = 73569, upload-time = "2026-03-09T13:13:45.792Z" }, + { url = "https://files.pythonhosted.org/packages/28/26/192b26196e2316e2bd29deef67e37cdf9870d9af8e085e521afff0fed526/kiwisolver-1.5.0-cp312-cp312-win_arm64.whl", hash = "sha256:f7c7553b13f69c1b29a5bde08ddc6d9d0c8bfb84f9ed01c30db25944aeb852a7", size = 64997, upload-time = "2026-03-09T13:13:46.878Z" }, + { url = "https://files.pythonhosted.org/packages/9d/69/024d6711d5ba575aa65d5538042e99964104e97fa153a9f10bc369182bc2/kiwisolver-1.5.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:fd40bb9cd0891c4c3cb1ddf83f8bbfa15731a248fdc8162669405451e2724b09", size = 123166, upload-time = "2026-03-09T13:13:48.032Z" }, + { url = "https://files.pythonhosted.org/packages/ce/48/adbb40df306f587054a348831220812b9b1d787aff714cfbc8556e38fccd/kiwisolver-1.5.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:c0e1403fd7c26d77c1f03e096dc58a5c726503fa0db0456678b8668f76f521e3", size = 66395, upload-time = "2026-03-09T13:13:49.365Z" }, + { url = "https://files.pythonhosted.org/packages/a8/3a/d0a972b34e1c63e2409413104216cd1caa02c5a37cb668d1687d466c1c45/kiwisolver-1.5.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:dda366d548e89a90d88a86c692377d18d8bd64b39c1fb2b92cb31370e2896bbd", size = 64065, upload-time = "2026-03-09T13:13:50.562Z" }, + { url = "https://files.pythonhosted.org/packages/2b/0a/7b98e1e119878a27ba8618ca1e18b14f992ff1eda40f47bccccf4de44121/kiwisolver-1.5.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:332b4f0145c30b5f5ad9374881133e5aa64320428a57c2c2b61e9d891a51c2f3", size = 1477903, upload-time = "2026-03-09T13:13:52.084Z" }, + { url = "https://files.pythonhosted.org/packages/18/d8/55638d89ffd27799d5cc3d8aa28e12f4ce7a64d67b285114dbedc8ea4136/kiwisolver-1.5.0-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0c50b89ffd3e1a911c69a1dd3de7173c0cd10b130f56222e57898683841e4f96", size = 1278751, upload-time = "2026-03-09T13:13:54.673Z" }, + { url = "https://files.pythonhosted.org/packages/b8/97/b4c8d0d18421ecceba20ad8701358453b88e32414e6f6950b5a4bad54e65/kiwisolver-1.5.0-cp313-cp313-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4db576bb8c3ef9365f8b40fe0f671644de6736ae2c27a2c62d7d8a1b4329f099", size = 1296793, upload-time = "2026-03-09T13:13:56.287Z" }, + { url = "https://files.pythonhosted.org/packages/c4/10/f862f94b6389d8957448ec9df59450b81bec4abb318805375c401a1e6892/kiwisolver-1.5.0-cp313-cp313-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0b85aad90cea8ac6797a53b5d5f2e967334fa4d1149f031c4537569972596cb8", size = 1346041, upload-time = "2026-03-09T13:13:58.269Z" }, + { url = "https://files.pythonhosted.org/packages/a3/6a/f1650af35821eaf09de398ec0bc2aefc8f211f0cda50204c9f1673741ba9/kiwisolver-1.5.0-cp313-cp313-manylinux_2_39_riscv64.whl", hash = "sha256:d36ca54cb4c6c4686f7cbb7b817f66f5911c12ddb519450bbe86707155028f87", size = 987292, upload-time = "2026-03-09T13:13:59.871Z" }, + { url = "https://files.pythonhosted.org/packages/de/19/d7fb82984b9238115fe629c915007be608ebd23dc8629703d917dbfaffd4/kiwisolver-1.5.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:38f4a703656f493b0ad185211ccfca7f0386120f022066b018eb5296d8613e23", size = 2227865, upload-time = "2026-03-09T13:14:01.401Z" }, + { url = "https://files.pythonhosted.org/packages/7f/b9/46b7f386589fd222dac9e9de9c956ce5bcefe2ee73b4e79891381dda8654/kiwisolver-1.5.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:3ac2360e93cb41be81121755c6462cff3beaa9967188c866e5fce5cf13170859", size = 2324369, upload-time = "2026-03-09T13:14:02.972Z" }, + { url = "https://files.pythonhosted.org/packages/92/8b/95e237cf3d9c642960153c769ddcbe278f182c8affb20cecc1cc983e7cc5/kiwisolver-1.5.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:c95cab08d1965db3d84a121f1c7ce7479bdd4072c9b3dafd8fecce48a2e6b902", size = 1977989, upload-time = "2026-03-09T13:14:04.503Z" }, + { url = "https://files.pythonhosted.org/packages/1b/95/980c9df53501892784997820136c01f62bc1865e31b82b9560f980c0e649/kiwisolver-1.5.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:fc20894c3d21194d8041a28b65622d5b86db786da6e3cfe73f0c762951a61167", size = 2491645, upload-time = "2026-03-09T13:14:06.106Z" }, + { url = "https://files.pythonhosted.org/packages/cb/32/900647fd0840abebe1561792c6b31e6a7c0e278fc3973d30572a965ca14c/kiwisolver-1.5.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:7a32f72973f0f950c1920475d5c5ea3d971b81b6f0ec53b8d0a956cc965f22e0", size = 2295237, upload-time = "2026-03-09T13:14:08.891Z" }, + { url = "https://files.pythonhosted.org/packages/be/8a/be60e3bbcf513cc5a50f4a3e88e1dcecebb79c1ad607a7222877becaa101/kiwisolver-1.5.0-cp313-cp313-win_amd64.whl", hash = "sha256:0bf3acf1419fa93064a4c2189ac0b58e3be7872bf6ee6177b0d4c63dc4cea276", size = 73573, upload-time = "2026-03-09T13:14:12.327Z" }, + { url = "https://files.pythonhosted.org/packages/4d/d2/64be2e429eb4fca7f7e1c52a91b12663aeaf25de3895e5cca0f47ef2a8d0/kiwisolver-1.5.0-cp313-cp313-win_arm64.whl", hash = "sha256:fa8eb9ecdb7efb0b226acec134e0d709e87a909fa4971a54c0c4f6e88635484c", size = 64998, upload-time = "2026-03-09T13:14:13.469Z" }, + { url = "https://files.pythonhosted.org/packages/b0/69/ce68dd0c85755ae2de490bf015b62f2cea5f6b14ff00a463f9d0774449ff/kiwisolver-1.5.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:db485b3847d182b908b483b2ed133c66d88d49cacf98fd278fadafe11b4478d1", size = 125700, upload-time = "2026-03-09T13:14:14.636Z" }, + { url = "https://files.pythonhosted.org/packages/74/aa/937aac021cf9d4349990d47eb319309a51355ed1dbdc9c077cdc9224cb11/kiwisolver-1.5.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:be12f931839a3bdfe28b584db0e640a65a8bcbc24560ae3fdb025a449b3d754e", size = 67537, upload-time = "2026-03-09T13:14:15.808Z" }, + { url = "https://files.pythonhosted.org/packages/ee/20/3a87fbece2c40ad0f6f0aefa93542559159c5f99831d596050e8afae7a9f/kiwisolver-1.5.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:16b85d37c2cbb3253226d26e64663f755d88a03439a9c47df6246b35defbdfb7", size = 65514, upload-time = "2026-03-09T13:14:18.035Z" }, + { url = "https://files.pythonhosted.org/packages/f0/7f/f943879cda9007c45e1f7dba216d705c3a18d6b35830e488b6c6a4e7cdf0/kiwisolver-1.5.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4432b835675f0ea7414aab3d37d119f7226d24869b7a829caeab49ebda407b0c", size = 1584848, upload-time = "2026-03-09T13:14:19.745Z" }, + { url = "https://files.pythonhosted.org/packages/37/f8/4d4f85cc1870c127c88d950913370dd76138482161cd07eabbc450deff01/kiwisolver-1.5.0-cp313-cp313t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1b0feb50971481a2cc44d94e88bdb02cdd497618252ae226b8eb1201b957e368", size = 1391542, upload-time = "2026-03-09T13:14:21.54Z" }, + { url = "https://files.pythonhosted.org/packages/04/0b/65dd2916c84d252b244bd405303220f729e7c17c9d7d33dca6feeff9ffc4/kiwisolver-1.5.0-cp313-cp313t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:56fa888f10d0f367155e76ce849fa1166fc9730d13bd2d65a2aa13b6f5424489", size = 1404447, upload-time = "2026-03-09T13:14:23.205Z" }, + { url = "https://files.pythonhosted.org/packages/39/5c/2606a373247babce9b1d056c03a04b65f3cf5290a8eac5d7bdead0a17e21/kiwisolver-1.5.0-cp313-cp313t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:940dda65d5e764406b9fb92761cbf462e4e63f712ab60ed98f70552e496f3bf1", size = 1455918, upload-time = "2026-03-09T13:14:24.74Z" }, + { url = "https://files.pythonhosted.org/packages/d5/d1/c6078b5756670658e9192a2ef11e939c92918833d2745f85cd14a6004bdf/kiwisolver-1.5.0-cp313-cp313t-manylinux_2_39_riscv64.whl", hash = "sha256:89fc958c702ee9a745e4700378f5d23fddbc46ff89e8fdbf5395c24d5c1452a3", size = 1072856, upload-time = "2026-03-09T13:14:26.597Z" }, + { url = "https://files.pythonhosted.org/packages/cb/c8/7def6ddf16eb2b3741d8b172bdaa9af882b03c78e9b0772975408801fa63/kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9027d773c4ff81487181a925945743413f6069634d0b122d0b37684ccf4f1e18", size = 2333580, upload-time = "2026-03-09T13:14:28.237Z" }, + { url = "https://files.pythonhosted.org/packages/9e/87/2ac1fce0eb1e616fcd3c35caa23e665e9b1948bb984f4764790924594128/kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:5b233ea3e165e43e35dba1d2b8ecc21cf070b45b65ae17dd2747d2713d942021", size = 2423018, upload-time = "2026-03-09T13:14:30.018Z" }, + { url = "https://files.pythonhosted.org/packages/67/13/c6700ccc6cc218716bfcda4935e4b2997039869b4ad8a94f364c5a3b8e63/kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:ce9bf03dad3b46408c08649c6fbd6ca28a9fce0eb32fdfffa6775a13103b5310", size = 2062804, upload-time = "2026-03-09T13:14:32.888Z" }, + { url = "https://files.pythonhosted.org/packages/1b/bd/877056304626943ff0f1f44c08f584300c199b887cb3176cd7e34f1515f1/kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:fc4d3f1fb9ca0ae9f97b095963bc6326f1dbfd3779d6679a1e016b9baaa153d3", size = 2597482, upload-time = "2026-03-09T13:14:34.971Z" }, + { url = "https://files.pythonhosted.org/packages/75/19/c60626c47bf0f8ac5dcf72c6c98e266d714f2fbbfd50cf6dab5ede3aaa50/kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:f443b4825c50a51ee68585522ab4a1d1257fac65896f282b4c6763337ac9f5d2", size = 2394328, upload-time = "2026-03-09T13:14:36.816Z" }, + { url = "https://files.pythonhosted.org/packages/47/84/6a6d5e5bb8273756c27b7d810d47f7ef2f1f9b9fd23c9ee9a3f8c75c9cef/kiwisolver-1.5.0-cp313-cp313t-win_arm64.whl", hash = "sha256:893ff3a711d1b515ba9da14ee090519bad4610ed1962fbe298a434e8c5f8db53", size = 68410, upload-time = "2026-03-09T13:14:38.695Z" }, + { url = "https://files.pythonhosted.org/packages/e4/d7/060f45052f2a01ad5762c8fdecd6d7a752b43400dc29ff75cd47225a40fd/kiwisolver-1.5.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:8df31fe574b8b3993cc61764f40941111b25c2d9fea13d3ce24a49907cd2d615", size = 123231, upload-time = "2026-03-09T13:14:41.323Z" }, + { url = "https://files.pythonhosted.org/packages/c2/a7/78da680eadd06ff35edef6ef68a1ad273bad3e2a0936c9a885103230aece/kiwisolver-1.5.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:1d49a49ac4cbfb7c1375301cd1ec90169dfeae55ff84710d782260ce77a75a02", size = 66489, upload-time = "2026-03-09T13:14:42.534Z" }, + { url = "https://files.pythonhosted.org/packages/49/b2/97980f3ad4fae37dd7fe31626e2bf75fbf8bdf5d303950ec1fab39a12da8/kiwisolver-1.5.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:0cbe94b69b819209a62cb27bdfa5dc2a8977d8de2f89dfd97ba4f53ed3af754e", size = 64063, upload-time = "2026-03-09T13:14:44.759Z" }, + { url = "https://files.pythonhosted.org/packages/e7/f9/b06c934a6aa8bc91f566bd2a214fd04c30506c2d9e2b6b171953216a65b6/kiwisolver-1.5.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:80aa065ffd378ff784822a6d7c3212f2d5f5e9c3589614b5c228b311fd3063ac", size = 1475913, upload-time = "2026-03-09T13:14:46.247Z" }, + { url = "https://files.pythonhosted.org/packages/6b/f0/f768ae564a710135630672981231320bc403cf9152b5596ec5289de0f106/kiwisolver-1.5.0-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4e7f886f47ab881692f278ae901039a234e4025a68e6dfab514263a0b1c4ae05", size = 1282782, upload-time = "2026-03-09T13:14:48.458Z" }, + { url = "https://files.pythonhosted.org/packages/e2/9f/1de7aad00697325f05238a5f2eafbd487fb637cc27a558b5367a5f37fb7f/kiwisolver-1.5.0-cp314-cp314-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5060731cc3ed12ca3a8b57acd4aeca5bbc2f49216dd0bec1650a1acd89486bcd", size = 1300815, upload-time = "2026-03-09T13:14:50.721Z" }, + { url = "https://files.pythonhosted.org/packages/5a/c2/297f25141d2e468e0ce7f7a7b92e0cf8918143a0cbd3422c1ad627e85a06/kiwisolver-1.5.0-cp314-cp314-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:7a4aa69609f40fce3cbc3f87b2061f042eee32f94b8f11db707b66a26461591a", size = 1347925, upload-time = "2026-03-09T13:14:52.304Z" }, + { url = "https://files.pythonhosted.org/packages/b9/d3/f4c73a02eb41520c47610207b21afa8cdd18fdbf64ffd94674ae21c4812d/kiwisolver-1.5.0-cp314-cp314-manylinux_2_39_riscv64.whl", hash = "sha256:d168fda2dbff7b9b5f38e693182d792a938c31db4dac3a80a4888de603c99554", size = 991322, upload-time = "2026-03-09T13:14:54.637Z" }, + { url = "https://files.pythonhosted.org/packages/7b/46/d3f2efef7732fcda98d22bf4ad5d3d71d545167a852ca710a494f4c15343/kiwisolver-1.5.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:413b820229730d358efd838ecbab79902fe97094565fdc80ddb6b0a18c18a581", size = 2232857, upload-time = "2026-03-09T13:14:56.471Z" }, + { url = "https://files.pythonhosted.org/packages/3f/ec/2d9756bf2b6d26ae4349b8d3662fb3993f16d80c1f971c179ce862b9dbae/kiwisolver-1.5.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:5124d1ea754509b09e53738ec185584cc609aae4a3b510aaf4ed6aa047ef9303", size = 2329376, upload-time = "2026-03-09T13:14:58.072Z" }, + { url = "https://files.pythonhosted.org/packages/8f/9f/876a0a0f2260f1bde92e002b3019a5fabc35e0939c7d945e0fa66185eb20/kiwisolver-1.5.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:e4415a8db000bf49a6dd1c478bf70062eaacff0f462b92b0ba68791a905861f9", size = 1982549, upload-time = "2026-03-09T13:14:59.668Z" }, + { url = "https://files.pythonhosted.org/packages/6c/4f/ba3624dfac23a64d54ac4179832860cb537c1b0af06024936e82ca4154a0/kiwisolver-1.5.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:d618fd27420381a4f6044faa71f46d8bfd911bd077c555f7138ed88729bfbe79", size = 2494680, upload-time = "2026-03-09T13:15:01.364Z" }, + { url = "https://files.pythonhosted.org/packages/39/b7/97716b190ab98911b20d10bf92eca469121ec483b8ce0edd314f51bc85af/kiwisolver-1.5.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5092eb5b1172947f57d6ea7d89b2f29650414e4293c47707eb499ec07a0ac796", size = 2297905, upload-time = "2026-03-09T13:15:03.925Z" }, + { url = "https://files.pythonhosted.org/packages/a3/36/4e551e8aa55c9188bca9abb5096805edbf7431072b76e2298e34fd3a3008/kiwisolver-1.5.0-cp314-cp314-win_amd64.whl", hash = "sha256:d76e2d8c75051d58177e762164d2e9ab92886534e3a12e795f103524f221dd8e", size = 75086, upload-time = "2026-03-09T13:15:07.775Z" }, + { url = "https://files.pythonhosted.org/packages/70/15/9b90f7df0e31a003c71649cf66ef61c3c1b862f48c81007fa2383c8bd8d7/kiwisolver-1.5.0-cp314-cp314-win_arm64.whl", hash = "sha256:fa6248cd194edff41d7ea9425ced8ca3a6f838bfb295f6f1d6e6bb694a8518df", size = 66577, upload-time = "2026-03-09T13:15:09.139Z" }, + { url = "https://files.pythonhosted.org/packages/17/01/7dc8c5443ff42b38e72731643ed7cf1ed9bf01691ae5cdca98501999ed83/kiwisolver-1.5.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:d1ffeb80b5676463d7a7d56acbe8e37a20ce725570e09549fe738e02ca6b7e1e", size = 125794, upload-time = "2026-03-09T13:15:10.525Z" }, + { url = "https://files.pythonhosted.org/packages/46/8a/b4ebe46ebaac6a303417fab10c2e165c557ddaff558f9699d302b256bc53/kiwisolver-1.5.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:bc4d8e252f532ab46a1de9349e2d27b91fce46736a9eedaa37beaca66f574ed4", size = 67646, upload-time = "2026-03-09T13:15:12.016Z" }, + { url = "https://files.pythonhosted.org/packages/60/35/10a844afc5f19d6f567359bf4789e26661755a2f36200d5d1ed8ad0126e5/kiwisolver-1.5.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:6783e069732715ad0c3ce96dbf21dbc2235ab0593f2baf6338101f70371f4028", size = 65511, upload-time = "2026-03-09T13:15:13.311Z" }, + { url = "https://files.pythonhosted.org/packages/f8/8a/685b297052dd041dcebce8e8787b58923b6e78acc6115a0dc9189011c44b/kiwisolver-1.5.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e7c4c09a490dc4d4a7f8cbee56c606a320f9dc28cf92a7157a39d1ce7676a657", size = 1584858, upload-time = "2026-03-09T13:15:15.103Z" }, + { url = "https://files.pythonhosted.org/packages/9e/80/04865e3d4638ac5bddec28908916df4a3075b8c6cc101786a96803188b96/kiwisolver-1.5.0-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2a075bd7bd19c70cf67c8badfa36cf7c5d8de3c9ddb8420c51e10d9c50e94920", size = 1392539, upload-time = "2026-03-09T13:15:16.661Z" }, + { url = "https://files.pythonhosted.org/packages/ba/01/77a19cacc0893fa13fafa46d1bba06fb4dc2360b3292baf4b56d8e067b24/kiwisolver-1.5.0-cp314-cp314t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:bdd3e53429ff02aa319ba59dfe4ceeec345bf46cf180ec2cf6fd5b942e7975e9", size = 1405310, upload-time = "2026-03-09T13:15:18.229Z" }, + { url = "https://files.pythonhosted.org/packages/53/39/bcaf5d0cca50e604cfa9b4e3ae1d64b50ca1ae5b754122396084599ef903/kiwisolver-1.5.0-cp314-cp314t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3cdcb35dc9d807259c981a85531048ede628eabcffb3239adf3d17463518992d", size = 1456244, upload-time = "2026-03-09T13:15:20.444Z" }, + { url = "https://files.pythonhosted.org/packages/d0/7a/72c187abc6975f6978c3e39b7cf67aeb8b3c0a8f9790aa7fd412855e9e1f/kiwisolver-1.5.0-cp314-cp314t-manylinux_2_39_riscv64.whl", hash = "sha256:70d593af6a6ca332d1df73d519fddb5148edb15cd90d5f0155e3746a6d4fcc65", size = 1073154, upload-time = "2026-03-09T13:15:22.039Z" }, + { url = "https://files.pythonhosted.org/packages/c7/ca/cf5b25783ebbd59143b4371ed0c8428a278abe68d6d0104b01865b1bbd0f/kiwisolver-1.5.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:377815a8616074cabbf3f53354e1d040c35815a134e01d7614b7692e4bf8acfa", size = 2334377, upload-time = "2026-03-09T13:15:23.741Z" }, + { url = "https://files.pythonhosted.org/packages/4a/e5/b1f492adc516796e88751282276745340e2a72dcd0d36cf7173e0daf3210/kiwisolver-1.5.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:0255a027391d52944eae1dbb5d4cc5903f57092f3674e8e544cdd2622826b3f0", size = 2425288, upload-time = "2026-03-09T13:15:25.789Z" }, + { url = "https://files.pythonhosted.org/packages/e6/e5/9b21fbe91a61b8f409d74a26498706e97a48008bfcd1864373d32a6ba31c/kiwisolver-1.5.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:012b1eb16e28718fa782b5e61dc6f2da1f0792ca73bd05d54de6cb9561665fc9", size = 2063158, upload-time = "2026-03-09T13:15:27.63Z" }, + { url = "https://files.pythonhosted.org/packages/b1/02/83f47986138310f95ea95531f851b2a62227c11cbc3e690ae1374fe49f0f/kiwisolver-1.5.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:0e3aafb33aed7479377e5e9a82e9d4bf87063741fc99fc7ae48b0f16e32bdd6f", size = 2597260, upload-time = "2026-03-09T13:15:29.421Z" }, + { url = "https://files.pythonhosted.org/packages/07/18/43a5f24608d8c313dd189cf838c8e68d75b115567c6279de7796197cfb6a/kiwisolver-1.5.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:e7a116ae737f0000343218c4edf5bd45893bfeaff0993c0b215d7124c9f77646", size = 2394403, upload-time = "2026-03-09T13:15:31.517Z" }, + { url = "https://files.pythonhosted.org/packages/3b/b5/98222136d839b8afabcaa943b09bd05888c2d36355b7e448550211d1fca4/kiwisolver-1.5.0-cp314-cp314t-win_amd64.whl", hash = "sha256:1dd9b0b119a350976a6d781e7278ec7aca0b201e1a9e2d23d9804afecb6ca681", size = 79687, upload-time = "2026-03-09T13:15:33.204Z" }, + { url = "https://files.pythonhosted.org/packages/99/a2/ca7dc962848040befed12732dff6acae7fb3c4f6fc4272b3f6c9a30b8713/kiwisolver-1.5.0-cp314-cp314t-win_arm64.whl", hash = "sha256:58f812017cd2985c21fbffb4864d59174d4903dd66fa23815e74bbc7a0e2dd57", size = 70032, upload-time = "2026-03-09T13:15:34.411Z" }, + { url = "https://files.pythonhosted.org/packages/1c/fa/2910df836372d8761bb6eff7d8bdcb1613b5c2e03f260efe7abe34d388a7/kiwisolver-1.5.0-graalpy312-graalpy250_312_native-macosx_10_13_x86_64.whl", hash = "sha256:5ae8e62c147495b01a0f4765c878e9bfdf843412446a247e28df59936e99e797", size = 130262, upload-time = "2026-03-09T13:15:35.629Z" }, + { url = "https://files.pythonhosted.org/packages/0f/41/c5f71f9f00aabcc71fee8b7475e3f64747282580c2fe748961ba29b18385/kiwisolver-1.5.0-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:f6764a4ccab3078db14a632420930f6186058750df066b8ea2a7106df91d3203", size = 138036, upload-time = "2026-03-09T13:15:36.894Z" }, + { url = "https://files.pythonhosted.org/packages/fa/06/7399a607f434119c6e1fdc8ec89a8d51ccccadf3341dee4ead6bd14caaf5/kiwisolver-1.5.0-graalpy312-graalpy250_312_native-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c31c13da98624f957b0fb1b5bae5383b2333c2c3f6793d9825dd5ce79b525cb7", size = 194295, upload-time = "2026-03-09T13:15:38.22Z" }, + { url = "https://files.pythonhosted.org/packages/b5/91/53255615acd2a1eaca307ede3c90eb550bae9c94581f8c00081b6b1c8f44/kiwisolver-1.5.0-graalpy312-graalpy250_312_native-win_amd64.whl", hash = "sha256:1f1489f769582498610e015a8ef2d36f28f505ab3096d0e16b4858a9ec214f57", size = 75987, upload-time = "2026-03-09T13:15:39.65Z" }, +] + +[[package]] +name = "libclang" +version = "18.1.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6e/5c/ca35e19a4f142adffa27e3d652196b7362fa612243e2b916845d801454fc/libclang-18.1.1.tar.gz", hash = "sha256:a1214966d08d73d971287fc3ead8dfaf82eb07fb197680d8b3859dbbbbf78250", size = 39612, upload-time = "2024-03-17T16:04:37.434Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4b/49/f5e3e7e1419872b69f6f5e82ba56e33955a74bd537d8a1f5f1eff2f3668a/libclang-18.1.1-1-py2.py3-none-macosx_11_0_arm64.whl", hash = "sha256:0b2e143f0fac830156feb56f9231ff8338c20aecfe72b4ffe96f19e5a1dbb69a", size = 25836045, upload-time = "2024-06-30T17:40:31.646Z" }, + { url = "https://files.pythonhosted.org/packages/e2/e5/fc61bbded91a8830ccce94c5294ecd6e88e496cc85f6704bf350c0634b70/libclang-18.1.1-py2.py3-none-macosx_10_9_x86_64.whl", hash = "sha256:6f14c3f194704e5d09769108f03185fce7acaf1d1ae4bbb2f30a72c2400cb7c5", size = 26502641, upload-time = "2024-03-18T15:52:26.722Z" }, + { url = "https://files.pythonhosted.org/packages/db/ed/1df62b44db2583375f6a8a5e2ca5432bbdc3edb477942b9b7c848c720055/libclang-18.1.1-py2.py3-none-macosx_11_0_arm64.whl", hash = "sha256:83ce5045d101b669ac38e6da8e58765f12da2d3aafb3b9b98d88b286a60964d8", size = 26420207, upload-time = "2024-03-17T15:00:26.63Z" }, + { url = "https://files.pythonhosted.org/packages/1d/fc/716c1e62e512ef1c160e7984a73a5fc7df45166f2ff3f254e71c58076f7c/libclang-18.1.1-py2.py3-none-manylinux2010_x86_64.whl", hash = "sha256:c533091d8a3bbf7460a00cb6c1a71da93bffe148f172c7d03b1c31fbf8aa2a0b", size = 24515943, upload-time = "2024-03-17T16:03:45.942Z" }, + { url = "https://files.pythonhosted.org/packages/3c/3d/f0ac1150280d8d20d059608cf2d5ff61b7c3b7f7bcf9c0f425ab92df769a/libclang-18.1.1-py2.py3-none-manylinux2014_aarch64.whl", hash = "sha256:54dda940a4a0491a9d1532bf071ea3ef26e6dbaf03b5000ed94dd7174e8f9592", size = 23784972, upload-time = "2024-03-17T16:12:47.677Z" }, + { url = "https://files.pythonhosted.org/packages/fe/2f/d920822c2b1ce9326a4c78c0c2b4aa3fde610c7ee9f631b600acb5376c26/libclang-18.1.1-py2.py3-none-manylinux2014_armv7l.whl", hash = "sha256:cf4a99b05376513717ab5d82a0db832c56ccea4fd61a69dbb7bccf2dfb207dbe", size = 20259606, upload-time = "2024-03-17T16:17:42.437Z" }, + { url = "https://files.pythonhosted.org/packages/2d/c2/de1db8c6d413597076a4259cea409b83459b2db997c003578affdd32bf66/libclang-18.1.1-py2.py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:69f8eb8f65c279e765ffd28aaa7e9e364c776c17618af8bff22a8df58677ff4f", size = 24921494, upload-time = "2024-03-17T16:14:20.132Z" }, + { url = "https://files.pythonhosted.org/packages/0b/2d/3f480b1e1d31eb3d6de5e3ef641954e5c67430d5ac93b7fa7e07589576c7/libclang-18.1.1-py2.py3-none-win_amd64.whl", hash = "sha256:4dd2d3b82fab35e2bf9ca717d7b63ac990a3519c7e312f19fa8e86dcc712f7fb", size = 26415083, upload-time = "2024-03-17T16:42:21.703Z" }, + { url = "https://files.pythonhosted.org/packages/71/cf/e01dc4cc79779cd82d77888a88ae2fa424d93b445ad4f6c02bfc18335b70/libclang-18.1.1-py2.py3-none-win_arm64.whl", hash = "sha256:3f0e1f49f04d3cd198985fea0511576b0aee16f9ff0e0f0cad7f9c57ec3c20e8", size = 22361112, upload-time = "2024-03-17T16:42:59.565Z" }, +] + +[[package]] +name = "markdown-it-py" +version = "4.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "mdurl" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/5b/f5/4ec618ed16cc4f8fb3b701563655a69816155e79e24a17b651541804721d/markdown_it_py-4.0.0.tar.gz", hash = "sha256:cb0a2b4aa34f932c007117b194e945bd74e0ec24133ceb5bac59009cda1cb9f3", size = 73070, upload-time = "2025-08-11T12:57:52.854Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/94/54/e7d793b573f298e1c9013b8c4dade17d481164aa517d1d7148619c2cedbf/markdown_it_py-4.0.0-py3-none-any.whl", hash = "sha256:87327c59b172c5011896038353a81343b6754500a08cd7a4973bb48c6d578147", size = 87321, upload-time = "2025-08-11T12:57:51.923Z" }, +] + +[[package]] +name = "markupsafe" +version = "3.0.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7e/99/7690b6d4034fffd95959cbe0c02de8deb3098cc577c67bb6a24fe5d7caa7/markupsafe-3.0.3.tar.gz", hash = "sha256:722695808f4b6457b320fdc131280796bdceb04ab50fe1795cd540799ebe1698", size = 80313, upload-time = "2025-09-27T18:37:40.426Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5a/72/147da192e38635ada20e0a2e1a51cf8823d2119ce8883f7053879c2199b5/markupsafe-3.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d53197da72cc091b024dd97249dfc7794d6a56530370992a5e1a08983ad9230e", size = 11615, upload-time = "2025-09-27T18:36:30.854Z" }, + { url = "https://files.pythonhosted.org/packages/9a/81/7e4e08678a1f98521201c3079f77db69fb552acd56067661f8c2f534a718/markupsafe-3.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1872df69a4de6aead3491198eaf13810b565bdbeec3ae2dc8780f14458ec73ce", size = 12020, upload-time = "2025-09-27T18:36:31.971Z" }, + { url = "https://files.pythonhosted.org/packages/1e/2c/799f4742efc39633a1b54a92eec4082e4f815314869865d876824c257c1e/markupsafe-3.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3a7e8ae81ae39e62a41ec302f972ba6ae23a5c5396c8e60113e9066ef893da0d", size = 24332, upload-time = "2025-09-27T18:36:32.813Z" }, + { url = "https://files.pythonhosted.org/packages/3c/2e/8d0c2ab90a8c1d9a24f0399058ab8519a3279d1bd4289511d74e909f060e/markupsafe-3.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d6dd0be5b5b189d31db7cda48b91d7e0a9795f31430b7f271219ab30f1d3ac9d", size = 22947, upload-time = "2025-09-27T18:36:33.86Z" }, + { url = "https://files.pythonhosted.org/packages/2c/54/887f3092a85238093a0b2154bd629c89444f395618842e8b0c41783898ea/markupsafe-3.0.3-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:94c6f0bb423f739146aec64595853541634bde58b2135f27f61c1ffd1cd4d16a", size = 21962, upload-time = "2025-09-27T18:36:35.099Z" }, + { url = "https://files.pythonhosted.org/packages/c9/2f/336b8c7b6f4a4d95e91119dc8521402461b74a485558d8f238a68312f11c/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:be8813b57049a7dc738189df53d69395eba14fb99345e0a5994914a3864c8a4b", size = 23760, upload-time = "2025-09-27T18:36:36.001Z" }, + { url = "https://files.pythonhosted.org/packages/32/43/67935f2b7e4982ffb50a4d169b724d74b62a3964bc1a9a527f5ac4f1ee2b/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:83891d0e9fb81a825d9a6d61e3f07550ca70a076484292a70fde82c4b807286f", size = 21529, upload-time = "2025-09-27T18:36:36.906Z" }, + { url = "https://files.pythonhosted.org/packages/89/e0/4486f11e51bbba8b0c041098859e869e304d1c261e59244baa3d295d47b7/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:77f0643abe7495da77fb436f50f8dab76dbc6e5fd25d39589a0f1fe6548bfa2b", size = 23015, upload-time = "2025-09-27T18:36:37.868Z" }, + { url = "https://files.pythonhosted.org/packages/2f/e1/78ee7a023dac597a5825441ebd17170785a9dab23de95d2c7508ade94e0e/markupsafe-3.0.3-cp312-cp312-win32.whl", hash = "sha256:d88b440e37a16e651bda4c7c2b930eb586fd15ca7406cb39e211fcff3bf3017d", size = 14540, upload-time = "2025-09-27T18:36:38.761Z" }, + { url = "https://files.pythonhosted.org/packages/aa/5b/bec5aa9bbbb2c946ca2733ef9c4ca91c91b6a24580193e891b5f7dbe8e1e/markupsafe-3.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:26a5784ded40c9e318cfc2bdb30fe164bdb8665ded9cd64d500a34fb42067b1c", size = 15105, upload-time = "2025-09-27T18:36:39.701Z" }, + { url = "https://files.pythonhosted.org/packages/e5/f1/216fc1bbfd74011693a4fd837e7026152e89c4bcf3e77b6692fba9923123/markupsafe-3.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:35add3b638a5d900e807944a078b51922212fb3dedb01633a8defc4b01a3c85f", size = 13906, upload-time = "2025-09-27T18:36:40.689Z" }, + { url = "https://files.pythonhosted.org/packages/38/2f/907b9c7bbba283e68f20259574b13d005c121a0fa4c175f9bed27c4597ff/markupsafe-3.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e1cf1972137e83c5d4c136c43ced9ac51d0e124706ee1c8aa8532c1287fa8795", size = 11622, upload-time = "2025-09-27T18:36:41.777Z" }, + { url = "https://files.pythonhosted.org/packages/9c/d9/5f7756922cdd676869eca1c4e3c0cd0df60ed30199ffd775e319089cb3ed/markupsafe-3.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:116bb52f642a37c115f517494ea5feb03889e04df47eeff5b130b1808ce7c219", size = 12029, upload-time = "2025-09-27T18:36:43.257Z" }, + { url = "https://files.pythonhosted.org/packages/00/07/575a68c754943058c78f30db02ee03a64b3c638586fba6a6dd56830b30a3/markupsafe-3.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:133a43e73a802c5562be9bbcd03d090aa5a1fe899db609c29e8c8d815c5f6de6", size = 24374, upload-time = "2025-09-27T18:36:44.508Z" }, + { url = "https://files.pythonhosted.org/packages/a9/21/9b05698b46f218fc0e118e1f8168395c65c8a2c750ae2bab54fc4bd4e0e8/markupsafe-3.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ccfcd093f13f0f0b7fdd0f198b90053bf7b2f02a3927a30e63f3ccc9df56b676", size = 22980, upload-time = "2025-09-27T18:36:45.385Z" }, + { url = "https://files.pythonhosted.org/packages/7f/71/544260864f893f18b6827315b988c146b559391e6e7e8f7252839b1b846a/markupsafe-3.0.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:509fa21c6deb7a7a273d629cf5ec029bc209d1a51178615ddf718f5918992ab9", size = 21990, upload-time = "2025-09-27T18:36:46.916Z" }, + { url = "https://files.pythonhosted.org/packages/c2/28/b50fc2f74d1ad761af2f5dcce7492648b983d00a65b8c0e0cb457c82ebbe/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a4afe79fb3de0b7097d81da19090f4df4f8d3a2b3adaa8764138aac2e44f3af1", size = 23784, upload-time = "2025-09-27T18:36:47.884Z" }, + { url = "https://files.pythonhosted.org/packages/ed/76/104b2aa106a208da8b17a2fb72e033a5a9d7073c68f7e508b94916ed47a9/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:795e7751525cae078558e679d646ae45574b47ed6e7771863fcc079a6171a0fc", size = 21588, upload-time = "2025-09-27T18:36:48.82Z" }, + { url = "https://files.pythonhosted.org/packages/b5/99/16a5eb2d140087ebd97180d95249b00a03aa87e29cc224056274f2e45fd6/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8485f406a96febb5140bfeca44a73e3ce5116b2501ac54fe953e488fb1d03b12", size = 23041, upload-time = "2025-09-27T18:36:49.797Z" }, + { url = "https://files.pythonhosted.org/packages/19/bc/e7140ed90c5d61d77cea142eed9f9c303f4c4806f60a1044c13e3f1471d0/markupsafe-3.0.3-cp313-cp313-win32.whl", hash = "sha256:bdd37121970bfd8be76c5fb069c7751683bdf373db1ed6c010162b2a130248ed", size = 14543, upload-time = "2025-09-27T18:36:51.584Z" }, + { url = "https://files.pythonhosted.org/packages/05/73/c4abe620b841b6b791f2edc248f556900667a5a1cf023a6646967ae98335/markupsafe-3.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:9a1abfdc021a164803f4d485104931fb8f8c1efd55bc6b748d2f5774e78b62c5", size = 15113, upload-time = "2025-09-27T18:36:52.537Z" }, + { url = "https://files.pythonhosted.org/packages/f0/3a/fa34a0f7cfef23cf9500d68cb7c32dd64ffd58a12b09225fb03dd37d5b80/markupsafe-3.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:7e68f88e5b8799aa49c85cd116c932a1ac15caaa3f5db09087854d218359e485", size = 13911, upload-time = "2025-09-27T18:36:53.513Z" }, + { url = "https://files.pythonhosted.org/packages/e4/d7/e05cd7efe43a88a17a37b3ae96e79a19e846f3f456fe79c57ca61356ef01/markupsafe-3.0.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:218551f6df4868a8d527e3062d0fb968682fe92054e89978594c28e642c43a73", size = 11658, upload-time = "2025-09-27T18:36:54.819Z" }, + { url = "https://files.pythonhosted.org/packages/99/9e/e412117548182ce2148bdeacdda3bb494260c0b0184360fe0d56389b523b/markupsafe-3.0.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3524b778fe5cfb3452a09d31e7b5adefeea8c5be1d43c4f810ba09f2ceb29d37", size = 12066, upload-time = "2025-09-27T18:36:55.714Z" }, + { url = "https://files.pythonhosted.org/packages/bc/e6/fa0ffcda717ef64a5108eaa7b4f5ed28d56122c9a6d70ab8b72f9f715c80/markupsafe-3.0.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4e885a3d1efa2eadc93c894a21770e4bc67899e3543680313b09f139e149ab19", size = 25639, upload-time = "2025-09-27T18:36:56.908Z" }, + { url = "https://files.pythonhosted.org/packages/96/ec/2102e881fe9d25fc16cb4b25d5f5cde50970967ffa5dddafdb771237062d/markupsafe-3.0.3-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8709b08f4a89aa7586de0aadc8da56180242ee0ada3999749b183aa23df95025", size = 23569, upload-time = "2025-09-27T18:36:57.913Z" }, + { url = "https://files.pythonhosted.org/packages/4b/30/6f2fce1f1f205fc9323255b216ca8a235b15860c34b6798f810f05828e32/markupsafe-3.0.3-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b8512a91625c9b3da6f127803b166b629725e68af71f8184ae7e7d54686a56d6", size = 23284, upload-time = "2025-09-27T18:36:58.833Z" }, + { url = "https://files.pythonhosted.org/packages/58/47/4a0ccea4ab9f5dcb6f79c0236d954acb382202721e704223a8aafa38b5c8/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9b79b7a16f7fedff2495d684f2b59b0457c3b493778c9eed31111be64d58279f", size = 24801, upload-time = "2025-09-27T18:36:59.739Z" }, + { url = "https://files.pythonhosted.org/packages/6a/70/3780e9b72180b6fecb83a4814d84c3bf4b4ae4bf0b19c27196104149734c/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:12c63dfb4a98206f045aa9563db46507995f7ef6d83b2f68eda65c307c6829eb", size = 22769, upload-time = "2025-09-27T18:37:00.719Z" }, + { url = "https://files.pythonhosted.org/packages/98/c5/c03c7f4125180fc215220c035beac6b9cb684bc7a067c84fc69414d315f5/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8f71bc33915be5186016f675cd83a1e08523649b0e33efdb898db577ef5bb009", size = 23642, upload-time = "2025-09-27T18:37:01.673Z" }, + { url = "https://files.pythonhosted.org/packages/80/d6/2d1b89f6ca4bff1036499b1e29a1d02d282259f3681540e16563f27ebc23/markupsafe-3.0.3-cp313-cp313t-win32.whl", hash = "sha256:69c0b73548bc525c8cb9a251cddf1931d1db4d2258e9599c28c07ef3580ef354", size = 14612, upload-time = "2025-09-27T18:37:02.639Z" }, + { url = "https://files.pythonhosted.org/packages/2b/98/e48a4bfba0a0ffcf9925fe2d69240bfaa19c6f7507b8cd09c70684a53c1e/markupsafe-3.0.3-cp313-cp313t-win_amd64.whl", hash = "sha256:1b4b79e8ebf6b55351f0d91fe80f893b4743f104bff22e90697db1590e47a218", size = 15200, upload-time = "2025-09-27T18:37:03.582Z" }, + { url = "https://files.pythonhosted.org/packages/0e/72/e3cc540f351f316e9ed0f092757459afbc595824ca724cbc5a5d4263713f/markupsafe-3.0.3-cp313-cp313t-win_arm64.whl", hash = "sha256:ad2cf8aa28b8c020ab2fc8287b0f823d0a7d8630784c31e9ee5edea20f406287", size = 13973, upload-time = "2025-09-27T18:37:04.929Z" }, + { url = "https://files.pythonhosted.org/packages/33/8a/8e42d4838cd89b7dde187011e97fe6c3af66d8c044997d2183fbd6d31352/markupsafe-3.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:eaa9599de571d72e2daf60164784109f19978b327a3910d3e9de8c97b5b70cfe", size = 11619, upload-time = "2025-09-27T18:37:06.342Z" }, + { url = "https://files.pythonhosted.org/packages/b5/64/7660f8a4a8e53c924d0fa05dc3a55c9cee10bbd82b11c5afb27d44b096ce/markupsafe-3.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c47a551199eb8eb2121d4f0f15ae0f923d31350ab9280078d1e5f12b249e0026", size = 12029, upload-time = "2025-09-27T18:37:07.213Z" }, + { url = "https://files.pythonhosted.org/packages/da/ef/e648bfd021127bef5fa12e1720ffed0c6cbb8310c8d9bea7266337ff06de/markupsafe-3.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f34c41761022dd093b4b6896d4810782ffbabe30f2d443ff5f083e0cbbb8c737", size = 24408, upload-time = "2025-09-27T18:37:09.572Z" }, + { url = "https://files.pythonhosted.org/packages/41/3c/a36c2450754618e62008bf7435ccb0f88053e07592e6028a34776213d877/markupsafe-3.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:457a69a9577064c05a97c41f4e65148652db078a3a509039e64d3467b9e7ef97", size = 23005, upload-time = "2025-09-27T18:37:10.58Z" }, + { url = "https://files.pythonhosted.org/packages/bc/20/b7fdf89a8456b099837cd1dc21974632a02a999ec9bf7ca3e490aacd98e7/markupsafe-3.0.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e8afc3f2ccfa24215f8cb28dcf43f0113ac3c37c2f0f0806d8c70e4228c5cf4d", size = 22048, upload-time = "2025-09-27T18:37:11.547Z" }, + { url = "https://files.pythonhosted.org/packages/9a/a7/591f592afdc734f47db08a75793a55d7fbcc6902a723ae4cfbab61010cc5/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:ec15a59cf5af7be74194f7ab02d0f59a62bdcf1a537677ce67a2537c9b87fcda", size = 23821, upload-time = "2025-09-27T18:37:12.48Z" }, + { url = "https://files.pythonhosted.org/packages/7d/33/45b24e4f44195b26521bc6f1a82197118f74df348556594bd2262bda1038/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:0eb9ff8191e8498cca014656ae6b8d61f39da5f95b488805da4bb029cccbfbaf", size = 21606, upload-time = "2025-09-27T18:37:13.485Z" }, + { url = "https://files.pythonhosted.org/packages/ff/0e/53dfaca23a69fbfbbf17a4b64072090e70717344c52eaaaa9c5ddff1e5f0/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:2713baf880df847f2bece4230d4d094280f4e67b1e813eec43b4c0e144a34ffe", size = 23043, upload-time = "2025-09-27T18:37:14.408Z" }, + { url = "https://files.pythonhosted.org/packages/46/11/f333a06fc16236d5238bfe74daccbca41459dcd8d1fa952e8fbd5dccfb70/markupsafe-3.0.3-cp314-cp314-win32.whl", hash = "sha256:729586769a26dbceff69f7a7dbbf59ab6572b99d94576a5592625d5b411576b9", size = 14747, upload-time = "2025-09-27T18:37:15.36Z" }, + { url = "https://files.pythonhosted.org/packages/28/52/182836104b33b444e400b14f797212f720cbc9ed6ba34c800639d154e821/markupsafe-3.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:bdc919ead48f234740ad807933cdf545180bfbe9342c2bb451556db2ed958581", size = 15341, upload-time = "2025-09-27T18:37:16.496Z" }, + { url = "https://files.pythonhosted.org/packages/6f/18/acf23e91bd94fd7b3031558b1f013adfa21a8e407a3fdb32745538730382/markupsafe-3.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:5a7d5dc5140555cf21a6fefbdbf8723f06fcd2f63ef108f2854de715e4422cb4", size = 14073, upload-time = "2025-09-27T18:37:17.476Z" }, + { url = "https://files.pythonhosted.org/packages/3c/f0/57689aa4076e1b43b15fdfa646b04653969d50cf30c32a102762be2485da/markupsafe-3.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:1353ef0c1b138e1907ae78e2f6c63ff67501122006b0f9abad68fda5f4ffc6ab", size = 11661, upload-time = "2025-09-27T18:37:18.453Z" }, + { url = "https://files.pythonhosted.org/packages/89/c3/2e67a7ca217c6912985ec766c6393b636fb0c2344443ff9d91404dc4c79f/markupsafe-3.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1085e7fbddd3be5f89cc898938f42c0b3c711fdcb37d75221de2666af647c175", size = 12069, upload-time = "2025-09-27T18:37:19.332Z" }, + { url = "https://files.pythonhosted.org/packages/f0/00/be561dce4e6ca66b15276e184ce4b8aec61fe83662cce2f7d72bd3249d28/markupsafe-3.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1b52b4fb9df4eb9ae465f8d0c228a00624de2334f216f178a995ccdcf82c4634", size = 25670, upload-time = "2025-09-27T18:37:20.245Z" }, + { url = "https://files.pythonhosted.org/packages/50/09/c419f6f5a92e5fadde27efd190eca90f05e1261b10dbd8cbcb39cd8ea1dc/markupsafe-3.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fed51ac40f757d41b7c48425901843666a6677e3e8eb0abcff09e4ba6e664f50", size = 23598, upload-time = "2025-09-27T18:37:21.177Z" }, + { url = "https://files.pythonhosted.org/packages/22/44/a0681611106e0b2921b3033fc19bc53323e0b50bc70cffdd19f7d679bb66/markupsafe-3.0.3-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f190daf01f13c72eac4efd5c430a8de82489d9cff23c364c3ea822545032993e", size = 23261, upload-time = "2025-09-27T18:37:22.167Z" }, + { url = "https://files.pythonhosted.org/packages/5f/57/1b0b3f100259dc9fffe780cfb60d4be71375510e435efec3d116b6436d43/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e56b7d45a839a697b5eb268c82a71bd8c7f6c94d6fd50c3d577fa39a9f1409f5", size = 24835, upload-time = "2025-09-27T18:37:23.296Z" }, + { url = "https://files.pythonhosted.org/packages/26/6a/4bf6d0c97c4920f1597cc14dd720705eca0bf7c787aebc6bb4d1bead5388/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:f3e98bb3798ead92273dc0e5fd0f31ade220f59a266ffd8a4f6065e0a3ce0523", size = 22733, upload-time = "2025-09-27T18:37:24.237Z" }, + { url = "https://files.pythonhosted.org/packages/14/c7/ca723101509b518797fedc2fdf79ba57f886b4aca8a7d31857ba3ee8281f/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5678211cb9333a6468fb8d8be0305520aa073f50d17f089b5b4b477ea6e67fdc", size = 23672, upload-time = "2025-09-27T18:37:25.271Z" }, + { url = "https://files.pythonhosted.org/packages/fb/df/5bd7a48c256faecd1d36edc13133e51397e41b73bb77e1a69deab746ebac/markupsafe-3.0.3-cp314-cp314t-win32.whl", hash = "sha256:915c04ba3851909ce68ccc2b8e2cd691618c4dc4c4232fb7982bca3f41fd8c3d", size = 14819, upload-time = "2025-09-27T18:37:26.285Z" }, + { url = "https://files.pythonhosted.org/packages/1a/8a/0402ba61a2f16038b48b39bccca271134be00c5c9f0f623208399333c448/markupsafe-3.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4faffd047e07c38848ce017e8725090413cd80cbc23d86e55c587bf979e579c9", size = 15426, upload-time = "2025-09-27T18:37:27.316Z" }, + { url = "https://files.pythonhosted.org/packages/70/bc/6f1c2f612465f5fa89b95bead1f44dcb607670fd42891d8fdcd5d039f4f4/markupsafe-3.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:32001d6a8fc98c8cb5c947787c5d08b0a50663d139f1305bac5885d98d9b40fa", size = 14146, upload-time = "2025-09-27T18:37:28.327Z" }, +] + +[[package]] +name = "matplotlib" +version = "3.9.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "contourpy" }, + { name = "cycler" }, + { name = "fonttools" }, + { name = "kiwisolver" }, + { name = "numpy" }, + { name = "packaging" }, + { name = "pillow" }, + { name = "pyparsing" }, + { name = "python-dateutil" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c5/a4/a7236bf8b0137deff48737c6ccf2154ef4486e57c6a5b7c309bf515992bd/matplotlib-3.9.0.tar.gz", hash = "sha256:e6d29ea6c19e34b30fb7d88b7081f869a03014f66fe06d62cc77d5a6ea88ed7a", size = 36069890, upload-time = "2024-05-15T23:38:15.591Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/af/43/54b7dfd91ed33da92973dc5d50231ef7b2d0622c8ae72babbad26bc1a319/matplotlib-3.9.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:c79f3a585f1368da6049318bdf1f85568d8d04b2e89fc24b7e02cc9b62017382", size = 7884612, upload-time = "2024-05-15T23:37:35.246Z" }, + { url = "https://files.pythonhosted.org/packages/4c/88/15bbb864b0d871707294ff325f9ffd0dfa486db2637eb34dd5f8dcf5b9bf/matplotlib-3.9.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:bdd1ecbe268eb3e7653e04f451635f0fb0f77f07fd070242b44c076c9106da84", size = 7769852, upload-time = "2024-05-15T23:37:37.21Z" }, + { url = "https://files.pythonhosted.org/packages/57/af/8ed9b852fc041fc5bd101f9964682874ccbf24f9c08323edee6a1600eb04/matplotlib-3.9.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d38e85a1a6d732f645f1403ce5e6727fd9418cd4574521d5803d3d94911038e5", size = 8185646, upload-time = "2024-05-15T23:37:39.971Z" }, + { url = "https://files.pythonhosted.org/packages/f4/ff/da311c1e679eed54d3aed67754a4e859bd3b773060c2fa187962e60fcb85/matplotlib-3.9.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0a490715b3b9984fa609116481b22178348c1a220a4499cda79132000a79b4db", size = 8298411, upload-time = "2024-05-15T23:37:42.471Z" }, + { url = "https://files.pythonhosted.org/packages/db/8c/1014baa6776503914865d87e1e8a803ee9faa7b722ca5e655463b79c966e/matplotlib-3.9.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:8146ce83cbc5dc71c223a74a1996d446cd35cfb6a04b683e1446b7e6c73603b7", size = 8591196, upload-time = "2024-05-15T23:37:44.94Z" }, + { url = "https://files.pythonhosted.org/packages/17/91/febbb6c1063ae05a62fdbe038c2917b348b1b35f0482cee4738e6870a44a/matplotlib-3.9.0-cp312-cp312-win_amd64.whl", hash = "sha256:d91a4ffc587bacf5c4ce4ecfe4bcd23a4b675e76315f2866e588686cc97fccdf", size = 7968581, upload-time = "2024-05-15T23:37:47.839Z" }, +] + +[[package]] +name = "matplotlib-inline" +version = "0.2.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c7/74/97e72a36efd4ae2bccb3463284300f8953f199b5ffbc04cbbb0ec78f74b1/matplotlib_inline-0.2.1.tar.gz", hash = "sha256:e1ee949c340d771fc39e241ea75683deb94762c8fa5f2927ec57c83c4dffa9fe", size = 8110, upload-time = "2025-10-23T09:00:22.126Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/af/33/ee4519fa02ed11a94aef9559552f3b17bb863f2ecfe1a35dc7f548cde231/matplotlib_inline-0.2.1-py3-none-any.whl", hash = "sha256:d56ce5156ba6085e00a9d54fead6ed29a9c47e215cd1bba2e976ef39f5710a76", size = 9516, upload-time = "2025-10-23T09:00:20.675Z" }, +] + +[[package]] +name = "mdurl" +version = "0.1.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729, upload-time = "2022-08-14T12:40:10.846Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload-time = "2022-08-14T12:40:09.779Z" }, +] + +[[package]] +name = "ml-dtypes" +version = "0.5.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/0e/4a/c27b42ed9b1c7d13d9ba8b6905dece787d6259152f2309338aed29b2447b/ml_dtypes-0.5.4.tar.gz", hash = "sha256:8ab06a50fb9bf9666dd0fe5dfb4676fa2b0ac0f31ecff72a6c3af8e22c063453", size = 692314, upload-time = "2025-11-17T22:32:31.031Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a8/b8/3c70881695e056f8a32f8b941126cf78775d9a4d7feba8abcb52cb7b04f2/ml_dtypes-0.5.4-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:a174837a64f5b16cab6f368171a1a03a27936b31699d167684073ff1c4237dac", size = 676927, upload-time = "2025-11-17T22:31:48.182Z" }, + { url = "https://files.pythonhosted.org/packages/54/0f/428ef6881782e5ebb7eca459689448c0394fa0a80bea3aa9262cba5445ea/ml_dtypes-0.5.4-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a7f7c643e8b1320fd958bf098aa7ecf70623a42ec5154e3be3be673f4c34d900", size = 5028464, upload-time = "2025-11-17T22:31:50.135Z" }, + { url = "https://files.pythonhosted.org/packages/3a/cb/28ce52eb94390dda42599c98ea0204d74799e4d8047a0eb559b6fd648056/ml_dtypes-0.5.4-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9ad459e99793fa6e13bd5b7e6792c8f9190b4e5a1b45c63aba14a4d0a7f1d5ff", size = 5009002, upload-time = "2025-11-17T22:31:52.001Z" }, + { url = "https://files.pythonhosted.org/packages/f5/f0/0cfadd537c5470378b1b32bd859cf2824972174b51b873c9d95cfd7475a5/ml_dtypes-0.5.4-cp312-cp312-win_amd64.whl", hash = "sha256:c1a953995cccb9e25a4ae19e34316671e4e2edaebe4cf538229b1fc7109087b7", size = 212222, upload-time = "2025-11-17T22:31:53.742Z" }, + { url = "https://files.pythonhosted.org/packages/16/2e/9acc86985bfad8f2c2d30291b27cd2bb4c74cea08695bd540906ed744249/ml_dtypes-0.5.4-cp312-cp312-win_arm64.whl", hash = "sha256:9bad06436568442575beb2d03389aa7456c690a5b05892c471215bfd8cf39460", size = 160793, upload-time = "2025-11-17T22:31:55.358Z" }, + { url = "https://files.pythonhosted.org/packages/d9/a1/4008f14bbc616cfb1ac5b39ea485f9c63031c4634ab3f4cf72e7541f816a/ml_dtypes-0.5.4-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:8c760d85a2f82e2bed75867079188c9d18dae2ee77c25a54d60e9cc79be1bc48", size = 676888, upload-time = "2025-11-17T22:31:56.907Z" }, + { url = "https://files.pythonhosted.org/packages/d3/b7/dff378afc2b0d5a7d6cd9d3209b60474d9819d1189d347521e1688a60a53/ml_dtypes-0.5.4-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ce756d3a10d0c4067172804c9cc276ba9cc0ff47af9078ad439b075d1abdc29b", size = 5036993, upload-time = "2025-11-17T22:31:58.497Z" }, + { url = "https://files.pythonhosted.org/packages/eb/33/40cd74219417e78b97c47802037cf2d87b91973e18bb968a7da48a96ea44/ml_dtypes-0.5.4-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:533ce891ba774eabf607172254f2e7260ba5f57bdd64030c9a4fcfbd99815d0d", size = 5010956, upload-time = "2025-11-17T22:31:59.931Z" }, + { url = "https://files.pythonhosted.org/packages/e1/8b/200088c6859d8221454825959df35b5244fa9bdf263fd0249ac5fb75e281/ml_dtypes-0.5.4-cp313-cp313-win_amd64.whl", hash = "sha256:f21c9219ef48ca5ee78402d5cc831bd58ea27ce89beda894428bc67a52da5328", size = 212224, upload-time = "2025-11-17T22:32:01.349Z" }, + { url = "https://files.pythonhosted.org/packages/8f/75/dfc3775cb36367816e678f69a7843f6f03bd4e2bcd79941e01ea960a068e/ml_dtypes-0.5.4-cp313-cp313-win_arm64.whl", hash = "sha256:35f29491a3e478407f7047b8a4834e4640a77d2737e0b294d049746507af5175", size = 160798, upload-time = "2025-11-17T22:32:02.864Z" }, + { url = "https://files.pythonhosted.org/packages/4f/74/e9ddb35fd1dd43b1106c20ced3f53c2e8e7fc7598c15638e9f80677f81d4/ml_dtypes-0.5.4-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:304ad47faa395415b9ccbcc06a0350800bc50eda70f0e45326796e27c62f18b6", size = 702083, upload-time = "2025-11-17T22:32:04.08Z" }, + { url = "https://files.pythonhosted.org/packages/74/f5/667060b0aed1aa63166b22897fdf16dca9eb704e6b4bbf86848d5a181aa7/ml_dtypes-0.5.4-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6a0df4223b514d799b8a1629c65ddc351b3efa833ccf7f8ea0cf654a61d1e35d", size = 5354111, upload-time = "2025-11-17T22:32:05.546Z" }, + { url = "https://files.pythonhosted.org/packages/40/49/0f8c498a28c0efa5f5c95a9e374c83ec1385ca41d0e85e7cf40e5d519a21/ml_dtypes-0.5.4-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:531eff30e4d368cb6255bc2328d070e35836aa4f282a0fb5f3a0cd7260257298", size = 5366453, upload-time = "2025-11-17T22:32:07.115Z" }, + { url = "https://files.pythonhosted.org/packages/8c/27/12607423d0a9c6bbbcc780ad19f1f6baa2b68b18ce4bddcdc122c4c68dc9/ml_dtypes-0.5.4-cp313-cp313t-win_amd64.whl", hash = "sha256:cb73dccfc991691c444acc8c0012bee8f2470da826a92e3a20bb333b1a7894e6", size = 225612, upload-time = "2025-11-17T22:32:08.615Z" }, + { url = "https://files.pythonhosted.org/packages/e5/80/5a5929e92c72936d5b19872c5fb8fc09327c1da67b3b68c6a13139e77e20/ml_dtypes-0.5.4-cp313-cp313t-win_arm64.whl", hash = "sha256:3bbbe120b915090d9dd1375e4684dd17a20a2491ef25d640a908281da85e73f1", size = 164145, upload-time = "2025-11-17T22:32:09.782Z" }, + { url = "https://files.pythonhosted.org/packages/72/4e/1339dc6e2557a344f5ba5590872e80346f76f6cb2ac3dd16e4666e88818c/ml_dtypes-0.5.4-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:2b857d3af6ac0d39db1de7c706e69c7f9791627209c3d6dedbfca8c7e5faec22", size = 673781, upload-time = "2025-11-17T22:32:11.364Z" }, + { url = "https://files.pythonhosted.org/packages/04/f9/067b84365c7e83bda15bba2b06c6ca250ce27b20630b1128c435fb7a09aa/ml_dtypes-0.5.4-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:805cef3a38f4eafae3a5bf9ebdcdb741d0bcfd9e1bd90eb54abd24f928cd2465", size = 5036145, upload-time = "2025-11-17T22:32:12.783Z" }, + { url = "https://files.pythonhosted.org/packages/c6/bb/82c7dcf38070b46172a517e2334e665c5bf374a262f99a283ea454bece7c/ml_dtypes-0.5.4-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:14a4fd3228af936461db66faccef6e4f41c1d82fcc30e9f8d58a08916b1d811f", size = 5010230, upload-time = "2025-11-17T22:32:14.38Z" }, + { url = "https://files.pythonhosted.org/packages/e9/93/2bfed22d2498c468f6bcd0d9f56b033eaa19f33320389314c19ef6766413/ml_dtypes-0.5.4-cp314-cp314-win_amd64.whl", hash = "sha256:8c6a2dcebd6f3903e05d51960a8058d6e131fe69f952a5397e5dbabc841b6d56", size = 221032, upload-time = "2025-11-17T22:32:15.763Z" }, + { url = "https://files.pythonhosted.org/packages/76/a3/9c912fe6ea747bb10fe2f8f54d027eb265db05dfb0c6335e3e063e74e6e8/ml_dtypes-0.5.4-cp314-cp314-win_arm64.whl", hash = "sha256:5a0f68ca8fd8d16583dfa7793973feb86f2fbb56ce3966daf9c9f748f52a2049", size = 163353, upload-time = "2025-11-17T22:32:16.932Z" }, + { url = "https://files.pythonhosted.org/packages/cd/02/48aa7d84cc30ab4ee37624a2fd98c56c02326785750cd212bc0826c2f15b/ml_dtypes-0.5.4-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:bfc534409c5d4b0bf945af29e5d0ab075eae9eecbb549ff8a29280db822f34f9", size = 702085, upload-time = "2025-11-17T22:32:18.175Z" }, + { url = "https://files.pythonhosted.org/packages/5a/e7/85cb99fe80a7a5513253ec7faa88a65306be071163485e9a626fce1b6e84/ml_dtypes-0.5.4-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2314892cdc3fcf05e373d76d72aaa15fda9fb98625effa73c1d646f331fcecb7", size = 5355358, upload-time = "2025-11-17T22:32:19.7Z" }, + { url = "https://files.pythonhosted.org/packages/79/2b/a826ba18d2179a56e144aef69e57fb2ab7c464ef0b2111940ee8a3a223a2/ml_dtypes-0.5.4-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0d2ffd05a2575b1519dc928c0b93c06339eb67173ff53acb00724502cda231cf", size = 5366332, upload-time = "2025-11-17T22:32:21.193Z" }, + { url = "https://files.pythonhosted.org/packages/84/44/f4d18446eacb20ea11e82f133ea8f86e2bf2891785b67d9da8d0ab0ef525/ml_dtypes-0.5.4-cp314-cp314t-win_amd64.whl", hash = "sha256:4381fe2f2452a2d7589689693d3162e876b3ddb0a832cde7a414f8e1adf7eab1", size = 236612, upload-time = "2025-11-17T22:32:22.579Z" }, + { url = "https://files.pythonhosted.org/packages/ad/3f/3d42e9a78fe5edf792a83c074b13b9b770092a4fbf3462872f4303135f09/ml_dtypes-0.5.4-cp314-cp314t-win_arm64.whl", hash = "sha256:11942cbf2cf92157db91e5022633c0d9474d4dfd813a909383bd23ce828a4b7d", size = 168825, upload-time = "2025-11-17T22:32:23.766Z" }, +] + +[[package]] +name = "mpmath" +version = "1.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e0/47/dd32fa426cc72114383ac549964eecb20ecfd886d1e5ccf5340b55b02f57/mpmath-1.3.0.tar.gz", hash = "sha256:7a28eb2a9774d00c7bc92411c19a89209d5da7c4c9a9e227be8330a23a25b91f", size = 508106, upload-time = "2023-03-07T16:47:11.061Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/43/e3/7d92a15f894aa0c9c4b49b8ee9ac9850d6e63b03c9c32c0367a13ae62209/mpmath-1.3.0-py3-none-any.whl", hash = "sha256:a0b2b9fe80bbcd81a6647ff13108738cfb482d481d826cc0e02f5b35e5c88d2c", size = 536198, upload-time = "2023-03-07T16:47:09.197Z" }, +] + +[[package]] +name = "namex" +version = "0.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0c/c0/ee95b28f029c73f8d49d8f52edaed02a1d4a9acb8b69355737fdb1faa191/namex-0.1.0.tar.gz", hash = "sha256:117f03ccd302cc48e3f5c58a296838f6b89c83455ab8683a1e85f2a430aa4306", size = 6649, upload-time = "2025-05-26T23:17:38.918Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b2/bc/465daf1de06409cdd4532082806770ee0d8d7df434da79c76564d0f69741/namex-0.1.0-py3-none-any.whl", hash = "sha256:e2012a474502f1e2251267062aae3114611f07df4224b6e06334c57b0f2ce87c", size = 5905, upload-time = "2025-05-26T23:17:37.695Z" }, +] + +[[package]] +name = "nest-asyncio" +version = "1.6.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/83/f8/51569ac65d696c8ecbee95938f89d4abf00f47d58d48f6fbabfe8f0baefe/nest_asyncio-1.6.0.tar.gz", hash = "sha256:6f172d5449aca15afd6c646851f4e31e02c598d553a667e38cafa997cfec55fe", size = 7418, upload-time = "2024-01-21T14:25:19.227Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a0/c4/c2971a3ba4c6103a3d10c4b0f24f461ddc027f0f09763220cf35ca1401b3/nest_asyncio-1.6.0-py3-none-any.whl", hash = "sha256:87af6efd6b5e897c81050477ef65c62e2b2f35d51703cae01aff2905b1852e1c", size = 5195, upload-time = "2024-01-21T14:25:17.223Z" }, +] + +[[package]] +name = "netcdf4" +version = "1.7.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "cftime" }, + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/34/b6/0370bb3af66a12098da06dc5843f3b349b7c83ccbdf7306e7afa6248b533/netcdf4-1.7.4.tar.gz", hash = "sha256:cdbfdc92d6f4d7192ca8506c9b3d4c1d9892969ff28d8e8e1fc97ca08bf12164", size = 838352, upload-time = "2026-01-05T02:27:38.593Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/38/de/38ed7e1956943d28e8ea74161e97c3a00fb98d6d08943b4fd21bae32c240/netcdf4-1.7.4-cp311-abi3-macosx_13_0_x86_64.whl", hash = "sha256:dec70e809cc65b04ebe95113ee9c85ba46a51c3a37c058d2b2b0cadc4d3052d8", size = 23427499, upload-time = "2026-01-05T02:27:06.568Z" }, + { url = "https://files.pythonhosted.org/packages/e5/70/2f73c133b71709c412bc81d8b721e28dc6237ba9d7dad861b7bfbb70408a/netcdf4-1.7.4-cp311-abi3-macosx_14_0_arm64.whl", hash = "sha256:75cf59100f0775bc4d6b9d4aca7cbabd12e2b8cf3b9a4fb16d810b92743a315a", size = 22847667, upload-time = "2026-01-05T02:27:09.421Z" }, + { url = "https://files.pythonhosted.org/packages/77/ce/43a3c0c41a6e2e940d87feea79d29aa88302211ac122604838f8a5a48de6/netcdf4-1.7.4-cp311-abi3-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ddfc7e9d261125c74708119440c85ea288b5fee41db676d2ba1ce9be11f96932", size = 10274769, upload-time = "2026-01-05T21:31:19.243Z" }, + { url = "https://files.pythonhosted.org/packages/7b/7a/a8d32501bb95ecff342004a674720164f95ad616f269450b3bc13dc88ae3/netcdf4-1.7.4-cp311-abi3-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a72c9f58767779ec14cb7451c3b56bdd8fdc027a792fac2062b14e090c5617f3", size = 10123122, upload-time = "2026-01-05T21:31:22.773Z" }, + { url = "https://files.pythonhosted.org/packages/18/68/e89b4fa9242e59326c849c39ce0f49eb68499603c639405a8449900a4f15/netcdf4-1.7.4-cp311-abi3-win_amd64.whl", hash = "sha256:9476e1f23161ae5159cd1548c50c8a37922e77d76583e247133f256ef7b825fc", size = 21299637, upload-time = "2026-01-05T02:27:11.856Z" }, + { url = "https://files.pythonhosted.org/packages/6c/fc/edd41a3607241027aa4533e7f18e0cd647e74dde10a63274c65350f59967/netcdf4-1.7.4-cp311-abi3-win_arm64.whl", hash = "sha256:876ad9d58f09c98741c066c726164c45a098a58fb90e5fac9e74de4bb8a793fd", size = 2386377, upload-time = "2026-01-05T02:27:13.808Z" }, + { url = "https://files.pythonhosted.org/packages/d8/2b/684b15dd4791f8be295b2f6fa97377bbc07a768478a63b7d3c4951712e36/netcdf4-1.7.4-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a5841de0735e8e4875b367c668e81d334287858d64dd9f3e3e2261e808c84922", size = 10395635, upload-time = "2026-01-05T02:27:19.655Z" }, + { url = "https://files.pythonhosted.org/packages/37/dc/44d21524cf1b1c64254f92e22395a7a10f70c18f3a13a18ac9db258760f7/netcdf4-1.7.4-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:86fac03a8c5b250d57866e7d98918a64742e4b0de1681c5c86bac5726bab8aee", size = 10237725, upload-time = "2026-01-05T02:27:22.298Z" }, + { url = "https://files.pythonhosted.org/packages/d4/9d/c3ddf54296ad8f18f02f77f23452bdb0971aece1b87e84bab9d734bf72cc/netcdf4-1.7.4-cp314-cp314t-macosx_13_0_x86_64.whl", hash = "sha256:ad083d260301b5add74b1669c75ab0df03bdf986decfcc092cb45eec2615b5f1", size = 23515258, upload-time = "2026-01-05T02:27:24.837Z" }, + { url = "https://files.pythonhosted.org/packages/dd/44/bc0346e995d436d03fab682b7fbd2a9adcf0db6a05790b8f24853bf08170/netcdf4-1.7.4-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:7f22014092cc9da3f056b0368e2e38c42afd5725c87ad4843eb2f467e16dd4f6", size = 22910171, upload-time = "2026-01-05T02:27:27.166Z" }, + { url = "https://files.pythonhosted.org/packages/30/6b/f9bc3f43c55e2dac72ee9f98d77860789bdd5d50c29adf164a6bdb303078/netcdf4-1.7.4-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:224a15434c165a5e0225e5831f591edf62533044b1ce62fdfee815195bbd077d", size = 10567579, upload-time = "2026-01-05T02:27:29.382Z" }, + { url = "https://files.pythonhosted.org/packages/6d/d5/e7685c66b7f011c73cd746127f986358a26c642a4e4a1aa5ab51481b6586/netcdf4-1.7.4-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:31a2318305de6831a18df25ad0df9f03b6d68666af0356d4f6057d66c02ffeb6", size = 10255032, upload-time = "2026-01-05T02:27:31.744Z" }, + { url = "https://files.pythonhosted.org/packages/a6/14/7506738bb6c8bc373b01e5af8f3b727f83f4f496c6b108490ea2609dc2cf/netcdf4-1.7.4-cp314-cp314t-win_amd64.whl", hash = "sha256:6c4a0aa9446c3a616ef3be015b629dc6173643f8b09546de26a4e40e272cd1ed", size = 22289653, upload-time = "2026-01-05T02:27:34.294Z" }, + { url = "https://files.pythonhosted.org/packages/af/2e/39d5e9179c543f2e6e149a65908f83afd9b6d64379a90789b323111761db/netcdf4-1.7.4-cp314-cp314t-win_arm64.whl", hash = "sha256:034220887d48da032cb2db5958f69759dbb04eb33e279ec6390571d4aea734fe", size = 2531682, upload-time = "2026-01-05T02:27:37.062Z" }, +] + +[[package]] +name = "networkx" +version = "3.6.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6a/51/63fe664f3908c97be9d2e4f1158eb633317598cfa6e1fc14af5383f17512/networkx-3.6.1.tar.gz", hash = "sha256:26b7c357accc0c8cde558ad486283728b65b6a95d85ee1cd66bafab4c8168509", size = 2517025, upload-time = "2025-12-08T17:02:39.908Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9e/c9/b2622292ea83fbb4ec318f5b9ab867d0a28ab43c5717bb85b0a5f6b3b0a4/networkx-3.6.1-py3-none-any.whl", hash = "sha256:d47fbf302e7d9cbbb9e2555a0d267983d2aa476bac30e90dfbe5669bd57f3762", size = 2068504, upload-time = "2025-12-08T17:02:38.159Z" }, +] + +[[package]] +name = "numpy" +version = "2.4.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/10/8b/c265f4823726ab832de836cdd184d0986dcf94480f81e8739692a7ac7af2/numpy-2.4.3.tar.gz", hash = "sha256:483a201202b73495f00dbc83796c6ae63137a9bdade074f7648b3e32613412dd", size = 20727743, upload-time = "2026-03-09T07:58:53.426Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a9/ed/6388632536f9788cea23a3a1b629f25b43eaacd7d7377e5d6bc7b9deb69b/numpy-2.4.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:61b0cbabbb6126c8df63b9a3a0c4b1f44ebca5e12ff6997b80fcf267fb3150ef", size = 16669628, upload-time = "2026-03-09T07:56:24.252Z" }, + { url = "https://files.pythonhosted.org/packages/74/1b/ee2abfc68e1ce728b2958b6ba831d65c62e1b13ce3017c13943f8f9b5b2e/numpy-2.4.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7395e69ff32526710748f92cd8c9849b361830968ea3e24a676f272653e8983e", size = 14696872, upload-time = "2026-03-09T07:56:26.991Z" }, + { url = "https://files.pythonhosted.org/packages/ba/d1/780400e915ff5638166f11ca9dc2c5815189f3d7cf6f8759a1685e586413/numpy-2.4.3-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:abdce0f71dcb4a00e4e77f3faf05e4616ceccfe72ccaa07f47ee79cda3b7b0f4", size = 5203489, upload-time = "2026-03-09T07:56:29.414Z" }, + { url = "https://files.pythonhosted.org/packages/0b/bb/baffa907e9da4cc34a6e556d6d90e032f6d7a75ea47968ea92b4858826c4/numpy-2.4.3-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:48da3a4ee1336454b07497ff7ec83903efa5505792c4e6d9bf83d99dc07a1e18", size = 6550814, upload-time = "2026-03-09T07:56:32.225Z" }, + { url = "https://files.pythonhosted.org/packages/7b/12/8c9f0c6c95f76aeb20fc4a699c33e9f827fa0d0f857747c73bb7b17af945/numpy-2.4.3-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:32e3bef222ad6b052280311d1d60db8e259e4947052c3ae7dd6817451fc8a4c5", size = 15666601, upload-time = "2026-03-09T07:56:34.461Z" }, + { url = "https://files.pythonhosted.org/packages/bd/79/cc665495e4d57d0aa6fbcc0aa57aa82671dfc78fbf95fe733ed86d98f52a/numpy-2.4.3-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e7dd01a46700b1967487141a66ac1a3cf0dd8ebf1f08db37d46389401512ca97", size = 16621358, upload-time = "2026-03-09T07:56:36.852Z" }, + { url = "https://files.pythonhosted.org/packages/a8/40/b4ecb7224af1065c3539f5ecfff879d090de09608ad1008f02c05c770cb3/numpy-2.4.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:76f0f283506c28b12bba319c0fab98217e9f9b54e6160e9c79e9f7348ba32e9c", size = 17016135, upload-time = "2026-03-09T07:56:39.337Z" }, + { url = "https://files.pythonhosted.org/packages/f7/b1/6a88e888052eed951afed7a142dcdf3b149a030ca59b4c71eef085858e43/numpy-2.4.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:737f630a337364665aba3b5a77e56a68cc42d350edd010c345d65a3efa3addcc", size = 18345816, upload-time = "2026-03-09T07:56:42.31Z" }, + { url = "https://files.pythonhosted.org/packages/f3/8f/103a60c5f8c3d7fc678c19cd7b2476110da689ccb80bc18050efbaeae183/numpy-2.4.3-cp312-cp312-win32.whl", hash = "sha256:26952e18d82a1dbbc2f008d402021baa8d6fc8e84347a2072a25e08b46d698b9", size = 5960132, upload-time = "2026-03-09T07:56:44.851Z" }, + { url = "https://files.pythonhosted.org/packages/d7/7c/f5ee1bf6ed888494978046a809df2882aad35d414b622893322df7286879/numpy-2.4.3-cp312-cp312-win_amd64.whl", hash = "sha256:65f3c2455188f09678355f5cae1f959a06b778bc66d535da07bf2ef20cd319d5", size = 12316144, upload-time = "2026-03-09T07:56:47.057Z" }, + { url = "https://files.pythonhosted.org/packages/71/46/8d1cb3f7a00f2fb6394140e7e6623696e54c6318a9d9691bb4904672cf42/numpy-2.4.3-cp312-cp312-win_arm64.whl", hash = "sha256:2abad5c7fef172b3377502bde47892439bae394a71bc329f31df0fd829b41a9e", size = 10220364, upload-time = "2026-03-09T07:56:49.849Z" }, + { url = "https://files.pythonhosted.org/packages/b6/d0/1fe47a98ce0df229238b77611340aff92d52691bcbc10583303181abf7fc/numpy-2.4.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:b346845443716c8e542d54112966383b448f4a3ba5c66409771b8c0889485dd3", size = 16665297, upload-time = "2026-03-09T07:56:52.296Z" }, + { url = "https://files.pythonhosted.org/packages/27/d9/4e7c3f0e68dfa91f21c6fb6cf839bc829ec920688b1ce7ec722b1a6202fb/numpy-2.4.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2629289168f4897a3c4e23dc98d6f1731f0fc0fe52fb9db19f974041e4cc12b9", size = 14691853, upload-time = "2026-03-09T07:56:54.992Z" }, + { url = "https://files.pythonhosted.org/packages/3a/66/bd096b13a87549683812b53ab211e6d413497f84e794fb3c39191948da97/numpy-2.4.3-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:bb2e3cf95854233799013779216c57e153c1ee67a0bf92138acca0e429aefaee", size = 5198435, upload-time = "2026-03-09T07:56:57.184Z" }, + { url = "https://files.pythonhosted.org/packages/a2/2f/687722910b5a5601de2135c891108f51dfc873d8e43c8ed9f4ebb440b4a2/numpy-2.4.3-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:7f3408ff897f8ab07a07fbe2823d7aee6ff644c097cc1f90382511fe982f647f", size = 6546347, upload-time = "2026-03-09T07:56:59.531Z" }, + { url = "https://files.pythonhosted.org/packages/bf/ec/7971c4e98d86c564750393fab8d7d83d0a9432a9d78bb8a163a6dc59967a/numpy-2.4.3-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:decb0eb8a53c3b009b0962378065589685d66b23467ef5dac16cbe818afde27f", size = 15664626, upload-time = "2026-03-09T07:57:01.385Z" }, + { url = "https://files.pythonhosted.org/packages/7e/eb/7daecbea84ec935b7fc732e18f532073064a3816f0932a40a17f3349185f/numpy-2.4.3-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d5f51900414fc9204a0e0da158ba2ac52b75656e7dce7e77fb9f84bfa343b4cc", size = 16608916, upload-time = "2026-03-09T07:57:04.008Z" }, + { url = "https://files.pythonhosted.org/packages/df/58/2a2b4a817ffd7472dca4421d9f0776898b364154e30c95f42195041dc03b/numpy-2.4.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:6bd06731541f89cdc01b261ba2c9e037f1543df7472517836b78dfb15bd6e476", size = 17015824, upload-time = "2026-03-09T07:57:06.347Z" }, + { url = "https://files.pythonhosted.org/packages/4a/ca/627a828d44e78a418c55f82dd4caea8ea4a8ef24e5144d9e71016e52fb40/numpy-2.4.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:22654fe6be0e5206f553a9250762c653d3698e46686eee53b399ab90da59bd92", size = 18334581, upload-time = "2026-03-09T07:57:09.114Z" }, + { url = "https://files.pythonhosted.org/packages/cd/c0/76f93962fc79955fcba30a429b62304332345f22d4daec1cb33653425643/numpy-2.4.3-cp313-cp313-win32.whl", hash = "sha256:d71e379452a2f670ccb689ec801b1218cd3983e253105d6e83780967e899d687", size = 5958618, upload-time = "2026-03-09T07:57:11.432Z" }, + { url = "https://files.pythonhosted.org/packages/b1/3c/88af0040119209b9b5cb59485fa48b76f372c73068dbf9254784b975ac53/numpy-2.4.3-cp313-cp313-win_amd64.whl", hash = "sha256:0a60e17a14d640f49146cb38e3f105f571318db7826d9b6fef7e4dce758faecd", size = 12312824, upload-time = "2026-03-09T07:57:13.586Z" }, + { url = "https://files.pythonhosted.org/packages/58/ce/3d07743aced3d173f877c3ef6a454c2174ba42b584ab0b7e6d99374f51ed/numpy-2.4.3-cp313-cp313-win_arm64.whl", hash = "sha256:c9619741e9da2059cd9c3f206110b97583c7152c1dc9f8aafd4beb450ac1c89d", size = 10221218, upload-time = "2026-03-09T07:57:16.183Z" }, + { url = "https://files.pythonhosted.org/packages/62/09/d96b02a91d09e9d97862f4fc8bfebf5400f567d8eb1fe4b0cc4795679c15/numpy-2.4.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:7aa4e54f6469300ebca1d9eb80acd5253cdfa36f2c03d79a35883687da430875", size = 14819570, upload-time = "2026-03-09T07:57:18.564Z" }, + { url = "https://files.pythonhosted.org/packages/b5/ca/0b1aba3905fdfa3373d523b2b15b19029f4f3031c87f4066bd9d20ef6c6b/numpy-2.4.3-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:d1b90d840b25874cf5cd20c219af10bac3667db3876d9a495609273ebe679070", size = 5326113, upload-time = "2026-03-09T07:57:21.052Z" }, + { url = "https://files.pythonhosted.org/packages/c0/63/406e0fd32fcaeb94180fd6a4c41e55736d676c54346b7efbce548b94a914/numpy-2.4.3-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:a749547700de0a20a6718293396ec237bb38218049cfce788e08fcb716e8cf73", size = 6646370, upload-time = "2026-03-09T07:57:22.804Z" }, + { url = "https://files.pythonhosted.org/packages/b6/d0/10f7dc157d4b37af92720a196be6f54f889e90dcd30dce9dc657ed92c257/numpy-2.4.3-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:94f3c4a151a2e529adf49c1d54f0f57ff8f9b233ee4d44af623a81553ab86368", size = 15723499, upload-time = "2026-03-09T07:57:24.693Z" }, + { url = "https://files.pythonhosted.org/packages/66/f1/d1c2bf1161396629701bc284d958dc1efa3a5a542aab83cf11ee6eb4cba5/numpy-2.4.3-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:22c31dc07025123aedf7f2db9e91783df13f1776dc52c6b22c620870dc0fab22", size = 16657164, upload-time = "2026-03-09T07:57:27.676Z" }, + { url = "https://files.pythonhosted.org/packages/1a/be/cca19230b740af199ac47331a21c71e7a3d0ba59661350483c1600d28c37/numpy-2.4.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:148d59127ac95979d6f07e4d460f934ebdd6eed641db9c0db6c73026f2b2101a", size = 17081544, upload-time = "2026-03-09T07:57:30.664Z" }, + { url = "https://files.pythonhosted.org/packages/b9/c5/9602b0cbb703a0936fb40f8a95407e8171935b15846de2f0776e08af04c7/numpy-2.4.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:a97cbf7e905c435865c2d939af3d93f99d18eaaa3cabe4256f4304fb51604349", size = 18380290, upload-time = "2026-03-09T07:57:33.763Z" }, + { url = "https://files.pythonhosted.org/packages/ed/81/9f24708953cd30be9ee36ec4778f4b112b45165812f2ada4cc5ea1c1f254/numpy-2.4.3-cp313-cp313t-win32.whl", hash = "sha256:be3b8487d725a77acccc9924f65fd8bce9af7fac8c9820df1049424a2115af6c", size = 6082814, upload-time = "2026-03-09T07:57:36.491Z" }, + { url = "https://files.pythonhosted.org/packages/e2/9e/52f6eaa13e1a799f0ab79066c17f7016a4a8ae0c1aefa58c82b4dab690b4/numpy-2.4.3-cp313-cp313t-win_amd64.whl", hash = "sha256:1ec84fd7c8e652b0f4aaaf2e6e9cc8eaa9b1b80a537e06b2e3a2fb176eedcb26", size = 12452673, upload-time = "2026-03-09T07:57:38.281Z" }, + { url = "https://files.pythonhosted.org/packages/c4/04/b8cece6ead0b30c9fbd99bb835ad7ea0112ac5f39f069788c5558e3b1ab2/numpy-2.4.3-cp313-cp313t-win_arm64.whl", hash = "sha256:120df8c0a81ebbf5b9020c91439fccd85f5e018a927a39f624845be194a2be02", size = 10290907, upload-time = "2026-03-09T07:57:40.747Z" }, + { url = "https://files.pythonhosted.org/packages/70/ae/3936f79adebf8caf81bd7a599b90a561334a658be4dcc7b6329ebf4ee8de/numpy-2.4.3-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:5884ce5c7acfae1e4e1b6fde43797d10aa506074d25b531b4f54bde33c0c31d4", size = 16664563, upload-time = "2026-03-09T07:57:43.817Z" }, + { url = "https://files.pythonhosted.org/packages/9b/62/760f2b55866b496bb1fa7da2a6db076bef908110e568b02fcfc1422e2a3a/numpy-2.4.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:297837823f5bc572c5f9379b0c9f3a3365f08492cbdc33bcc3af174372ebb168", size = 14702161, upload-time = "2026-03-09T07:57:46.169Z" }, + { url = "https://files.pythonhosted.org/packages/32/af/a7a39464e2c0a21526fb4fb76e346fb172ebc92f6d1c7a07c2c139cc17b1/numpy-2.4.3-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:a111698b4a3f8dcbe54c64a7708f049355abd603e619013c346553c1fd4ca90b", size = 5208738, upload-time = "2026-03-09T07:57:48.506Z" }, + { url = "https://files.pythonhosted.org/packages/29/8c/2a0cf86a59558fa078d83805589c2de490f29ed4fb336c14313a161d358a/numpy-2.4.3-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:4bd4741a6a676770e0e97fe9ab2e51de01183df3dcbcec591d26d331a40de950", size = 6543618, upload-time = "2026-03-09T07:57:50.591Z" }, + { url = "https://files.pythonhosted.org/packages/aa/b8/612ce010c0728b1c363fa4ea3aa4c22fe1c5da1de008486f8c2f5cb92fae/numpy-2.4.3-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:54f29b877279d51e210e0c80709ee14ccbbad647810e8f3d375561c45ef613dd", size = 15680676, upload-time = "2026-03-09T07:57:52.34Z" }, + { url = "https://files.pythonhosted.org/packages/a9/7e/4f120ecc54ba26ddf3dc348eeb9eb063f421de65c05fc961941798feea18/numpy-2.4.3-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:679f2a834bae9020f81534671c56fd0cc76dd7e5182f57131478e23d0dc59e24", size = 16613492, upload-time = "2026-03-09T07:57:54.91Z" }, + { url = "https://files.pythonhosted.org/packages/2c/86/1b6020db73be330c4b45d5c6ee4295d59cfeef0e3ea323959d053e5a6909/numpy-2.4.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:d84f0f881cb2225c2dfd7f78a10a5645d487a496c6668d6cc39f0f114164f3d0", size = 17031789, upload-time = "2026-03-09T07:57:57.641Z" }, + { url = "https://files.pythonhosted.org/packages/07/3a/3b90463bf41ebc21d1b7e06079f03070334374208c0f9a1f05e4ae8455e7/numpy-2.4.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:d213c7e6e8d211888cc359bab7199670a00f5b82c0978b9d1c75baf1eddbeac0", size = 18339941, upload-time = "2026-03-09T07:58:00.577Z" }, + { url = "https://files.pythonhosted.org/packages/a8/74/6d736c4cd962259fd8bae9be27363eb4883a2f9069763747347544c2a487/numpy-2.4.3-cp314-cp314-win32.whl", hash = "sha256:52077feedeff7c76ed7c9f1a0428558e50825347b7545bbb8523da2cd55c547a", size = 6007503, upload-time = "2026-03-09T07:58:03.331Z" }, + { url = "https://files.pythonhosted.org/packages/48/39/c56ef87af669364356bb011922ef0734fc49dad51964568634c72a009488/numpy-2.4.3-cp314-cp314-win_amd64.whl", hash = "sha256:0448e7f9caefb34b4b7dd2b77f21e8906e5d6f0365ad525f9f4f530b13df2afc", size = 12444915, upload-time = "2026-03-09T07:58:06.353Z" }, + { url = "https://files.pythonhosted.org/packages/9d/1f/ab8528e38d295fd349310807496fabb7cf9fe2e1f70b97bc20a483ea9d4a/numpy-2.4.3-cp314-cp314-win_arm64.whl", hash = "sha256:b44fd60341c4d9783039598efadd03617fa28d041fc37d22b62d08f2027fa0e7", size = 10494875, upload-time = "2026-03-09T07:58:08.734Z" }, + { url = "https://files.pythonhosted.org/packages/e6/ef/b7c35e4d5ef141b836658ab21a66d1a573e15b335b1d111d31f26c8ef80f/numpy-2.4.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:0a195f4216be9305a73c0e91c9b026a35f2161237cf1c6de9b681637772ea657", size = 14822225, upload-time = "2026-03-09T07:58:11.034Z" }, + { url = "https://files.pythonhosted.org/packages/cd/8d/7730fa9278cf6648639946cc816e7cc89f0d891602584697923375f801ed/numpy-2.4.3-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:cd32fbacb9fd1bf041bf8e89e4576b6f00b895f06d00914820ae06a616bdfef7", size = 5328769, upload-time = "2026-03-09T07:58:13.67Z" }, + { url = "https://files.pythonhosted.org/packages/47/01/d2a137317c958b074d338807c1b6a383406cdf8b8e53b075d804cc3d211d/numpy-2.4.3-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:2e03c05abaee1f672e9d67bc858f300b5ccba1c21397211e8d77d98350972093", size = 6649461, upload-time = "2026-03-09T07:58:15.912Z" }, + { url = "https://files.pythonhosted.org/packages/5c/34/812ce12bc0f00272a4b0ec0d713cd237cb390666eb6206323d1cc9cedbb2/numpy-2.4.3-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7d1ce23cce91fcea443320a9d0ece9b9305d4368875bab09538f7a5b4131938a", size = 15725809, upload-time = "2026-03-09T07:58:17.787Z" }, + { url = "https://files.pythonhosted.org/packages/25/c0/2aed473a4823e905e765fee3dc2cbf504bd3e68ccb1150fbdabd5c39f527/numpy-2.4.3-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c59020932feb24ed49ffd03704fbab89f22aa9c0d4b180ff45542fe8918f5611", size = 16655242, upload-time = "2026-03-09T07:58:20.476Z" }, + { url = "https://files.pythonhosted.org/packages/f2/c8/7e052b2fc87aa0e86de23f20e2c42bd261c624748aa8efd2c78f7bb8d8c6/numpy-2.4.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:9684823a78a6cd6ad7511fc5e25b07947d1d5b5e2812c93fe99d7d4195130720", size = 17080660, upload-time = "2026-03-09T07:58:23.067Z" }, + { url = "https://files.pythonhosted.org/packages/f3/3d/0876746044db2adcb11549f214d104f2e1be00f07a67edbb4e2812094847/numpy-2.4.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:0200b25c687033316fb39f0ff4e3e690e8957a2c3c8d22499891ec58c37a3eb5", size = 18380384, upload-time = "2026-03-09T07:58:25.839Z" }, + { url = "https://files.pythonhosted.org/packages/07/12/8160bea39da3335737b10308df4f484235fd297f556745f13092aa039d3b/numpy-2.4.3-cp314-cp314t-win32.whl", hash = "sha256:5e10da9e93247e554bb1d22f8edc51847ddd7dde52d85ce31024c1b4312bfba0", size = 6154547, upload-time = "2026-03-09T07:58:28.289Z" }, + { url = "https://files.pythonhosted.org/packages/42/f3/76534f61f80d74cc9cdf2e570d3d4eeb92c2280a27c39b0aaf471eda7b48/numpy-2.4.3-cp314-cp314t-win_amd64.whl", hash = "sha256:45f003dbdffb997a03da2d1d0cb41fbd24a87507fb41605c0420a3db5bd4667b", size = 12633645, upload-time = "2026-03-09T07:58:30.384Z" }, + { url = "https://files.pythonhosted.org/packages/1f/b6/7c0d4334c15983cec7f92a69e8ce9b1e6f31857e5ee3a413ac424e6bd63d/numpy-2.4.3-cp314-cp314t-win_arm64.whl", hash = "sha256:4d382735cecd7bcf090172489a525cd7d4087bc331f7df9f60ddc9a296cf208e", size = 10565454, upload-time = "2026-03-09T07:58:33.031Z" }, +] + +[[package]] +name = "nvidia-cublas" +version = "13.1.0.3" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e1/a5/fce49e2ae977e0ccc084e5adafceb4f0ac0c8333cb6863501618a7277f67/nvidia_cublas-13.1.0.3-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:c86fc7f7ae36d7528288c5d88098edcb7b02c633d262e7ddbb86b0ad91be5df2", size = 542851226, upload-time = "2025-10-09T08:59:04.818Z" }, + { url = "https://files.pythonhosted.org/packages/e7/44/423ac00af4dd95a5aeb27207e2c0d9b7118702149bf4704c3ddb55bb7429/nvidia_cublas-13.1.0.3-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:ee8722c1f0145ab246bccb9e452153b5e0515fd094c3678df50b2a0888b8b171", size = 423133236, upload-time = "2025-10-09T08:59:32.536Z" }, +] + +[[package]] +name = "nvidia-cuda-cupti" +version = "13.0.85" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2a/2a/80353b103fc20ce05ef51e928daed4b6015db4aaa9162ed0997090fe2250/nvidia_cuda_cupti-13.0.85-py3-none-manylinux_2_25_aarch64.whl", hash = "sha256:796bd679890ee55fb14a94629b698b6db54bcfd833d391d5e94017dd9d7d3151", size = 10310827, upload-time = "2025-09-04T08:26:42.012Z" }, + { url = "https://files.pythonhosted.org/packages/33/6d/737d164b4837a9bbd202f5ae3078975f0525a55730fe871d8ed4e3b952b0/nvidia_cuda_cupti-13.0.85-py3-none-manylinux_2_25_x86_64.whl", hash = "sha256:4eb01c08e859bf924d222250d2e8f8b8ff6d3db4721288cf35d14252a4d933c8", size = 10715597, upload-time = "2025-09-04T08:26:51.312Z" }, +] + +[[package]] +name = "nvidia-cuda-nvrtc" +version = "13.0.88" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c3/68/483a78f5e8f31b08fb1bb671559968c0ca3a065ac7acabfc7cee55214fd6/nvidia_cuda_nvrtc-13.0.88-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl", hash = "sha256:ad9b6d2ead2435f11cbb6868809d2adeeee302e9bb94bcf0539c7a40d80e8575", size = 90215200, upload-time = "2025-09-04T08:28:44.204Z" }, + { url = "https://files.pythonhosted.org/packages/b7/dc/6bb80850e0b7edd6588d560758f17e0550893a1feaf436807d64d2da040f/nvidia_cuda_nvrtc-13.0.88-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d27f20a0ca67a4bb34268a5e951033496c5b74870b868bacd046b1b8e0c3267b", size = 43015449, upload-time = "2025-09-04T08:28:20.239Z" }, +] + +[[package]] +name = "nvidia-cuda-runtime" +version = "13.0.96" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/87/4f/17d7b9b8e285199c58ce28e31b5c5bbaa4d8271af06a89b6405258245de2/nvidia_cuda_runtime-13.0.96-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ef9bcbe90493a2b9d810e43d249adb3d02e98dd30200d86607d8d02687c43f55", size = 2261060, upload-time = "2025-10-09T08:55:15.78Z" }, + { url = "https://files.pythonhosted.org/packages/2e/24/d1558f3b68b1d26e706813b1d10aa1d785e4698c425af8db8edc3dced472/nvidia_cuda_runtime-13.0.96-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7f82250d7782aa23b6cfe765ecc7db554bd3c2870c43f3d1821f1d18aebf0548", size = 2243632, upload-time = "2025-10-09T08:55:36.117Z" }, +] + +[[package]] +name = "nvidia-cudnn-cu13" +version = "9.19.0.56" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "nvidia-cublas", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/f1/84/26025437c1e6b61a707442184fa0c03d083b661adf3a3eecfd6d21677740/nvidia_cudnn_cu13-9.19.0.56-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:6ed29ffaee1176c612daf442e4dd6cfeb6a0caa43ddcbeb59da94953030b1be4", size = 433781201, upload-time = "2026-02-03T20:40:53.805Z" }, + { url = "https://files.pythonhosted.org/packages/a3/22/0b4b932655d17a6da1b92fa92ab12844b053bb2ac2475e179ba6f043da1e/nvidia_cudnn_cu13-9.19.0.56-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:d20e1734305e9d68889a96e3f35094d733ff1f83932ebe462753973e53a572bf", size = 366066321, upload-time = "2026-02-03T20:44:52.837Z" }, +] + +[[package]] +name = "nvidia-cufft" +version = "12.0.0.61" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "nvidia-nvjitlink", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/8b/ae/f417a75c0259e85c1d2f83ca4e960289a5f814ed0cea74d18c353d3e989d/nvidia_cufft-12.0.0.61-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:2708c852ef8cd89d1d2068bdbece0aa188813a0c934db3779b9b1faa8442e5f5", size = 214053554, upload-time = "2025-09-04T08:31:38.196Z" }, + { url = "https://files.pythonhosted.org/packages/a8/2f/7b57e29836ea8714f81e9898409196f47d772d5ddedddf1592eadb8ab743/nvidia_cufft-12.0.0.61-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:6c44f692dce8fd5ffd3e3df134b6cdb9c2f72d99cf40b62c32dde45eea9ddad3", size = 214085489, upload-time = "2025-09-04T08:31:56.044Z" }, +] + +[[package]] +name = "nvidia-cufile" +version = "1.15.1.6" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3f/70/4f193de89a48b71714e74602ee14d04e4019ad36a5a9f20c425776e72cd6/nvidia_cufile-1.15.1.6-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:08a3ecefae5a01c7f5117351c64f17c7c62efa5fffdbe24fc7d298da19cd0b44", size = 1223672, upload-time = "2025-09-04T08:32:22.779Z" }, + { url = "https://files.pythonhosted.org/packages/ab/73/cc4a14c9813a8a0d509417cf5f4bdaba76e924d58beb9864f5a7baceefbf/nvidia_cufile-1.15.1.6-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:bdc0deedc61f548bddf7733bdc216456c2fdb101d020e1ab4b88d232d5e2f6d1", size = 1136992, upload-time = "2025-09-04T08:32:14.119Z" }, +] + +[[package]] +name = "nvidia-curand" +version = "10.4.0.35" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1e/72/7c2ae24fb6b63a32e6ae5d241cc65263ea18d08802aaae087d9f013335a2/nvidia_curand-10.4.0.35-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:133df5a7509c3e292aaa2b477afd0194f06ce4ea24d714d616ff36439cee349a", size = 61962106, upload-time = "2025-08-04T10:21:41.128Z" }, + { url = "https://files.pythonhosted.org/packages/a5/9f/be0a41ca4a4917abf5cb9ae0daff1a6060cc5de950aec0396de9f3b52bc5/nvidia_curand-10.4.0.35-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:1aee33a5da6e1db083fe2b90082def8915f30f3248d5896bcec36a579d941bfc", size = 59544258, upload-time = "2025-08-04T10:22:03.992Z" }, +] + +[[package]] +name = "nvidia-cusolver" +version = "12.0.4.66" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "nvidia-cublas", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, + { name = "nvidia-cusparse", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, + { name = "nvidia-nvjitlink", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/c8/c3/b30c9e935fc01e3da443ec0116ed1b2a009bb867f5324d3f2d7e533e776b/nvidia_cusolver-12.0.4.66-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:02c2457eaa9e39de20f880f4bd8820e6a1cfb9f9a34f820eb12a155aa5bc92d2", size = 223467760, upload-time = "2025-09-04T08:33:04.222Z" }, + { url = "https://files.pythonhosted.org/packages/5f/67/cba3777620cdacb99102da4042883709c41c709f4b6323c10781a9c3aa34/nvidia_cusolver-12.0.4.66-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:0a759da5dea5c0ea10fd307de75cdeb59e7ea4fcb8add0924859b944babf1112", size = 200941980, upload-time = "2025-09-04T08:33:22.767Z" }, +] + +[[package]] +name = "nvidia-cusparse" +version = "12.6.3.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "nvidia-nvjitlink", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/f8/94/5c26f33738ae35276672f12615a64bd008ed5be6d1ebcb23579285d960a9/nvidia_cusparse-12.6.3.3-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:80bcc4662f23f1054ee334a15c72b8940402975e0eab63178fc7e670aa59472c", size = 162155568, upload-time = "2025-09-04T08:33:42.864Z" }, + { url = "https://files.pythonhosted.org/packages/fa/18/623c77619c31d62efd55302939756966f3ecc8d724a14dab2b75f1508850/nvidia_cusparse-12.6.3.3-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:2b3c89c88d01ee0e477cb7f82ef60a11a4bcd57b6b87c33f789350b59759360b", size = 145942937, upload-time = "2025-09-04T08:33:58.029Z" }, +] + +[[package]] +name = "nvidia-cusparselt-cu13" +version = "0.8.0" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/46/10/8dcd1175260706a2fc92a16a52e306b71d4c1ea0b0cc4a9484183399818a/nvidia_cusparselt_cu13-0.8.0-py3-none-manylinux2014_aarch64.whl", hash = "sha256:400c6ed1cf6780fc6efedd64ec9f1345871767e6a1a0a552a1ea0578117ea77c", size = 220791277, upload-time = "2025-08-13T19:22:40.982Z" }, + { url = "https://files.pythonhosted.org/packages/fd/53/43b0d71f4e702fa9733f8b4571fdca50a8813f1e450b656c239beff12315/nvidia_cusparselt_cu13-0.8.0-py3-none-manylinux2014_x86_64.whl", hash = "sha256:25e30a8a7323935d4ad0340b95a0b69926eee755767e8e0b1cf8dd85b197d3fd", size = 169884119, upload-time = "2025-08-13T19:23:41.967Z" }, +] + +[[package]] +name = "nvidia-nccl-cu13" +version = "2.28.9" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/39/55/1920646a2e43ffd4fc958536b276197ed740e9e0c54105b4bb3521591fc7/nvidia_nccl_cu13-2.28.9-py3-none-manylinux_2_18_aarch64.whl", hash = "sha256:01c873ba1626b54caa12272ed228dc5b2781545e0ae8ba3f432a8ef1c6d78643", size = 196561677, upload-time = "2025-11-18T05:49:03.45Z" }, + { url = "https://files.pythonhosted.org/packages/b0/b4/878fefaad5b2bcc6fcf8d474a25e3e3774bc5133e4b58adff4d0bca238bc/nvidia_nccl_cu13-2.28.9-py3-none-manylinux_2_18_x86_64.whl", hash = "sha256:e4553a30f34195f3fa1da02a6da3d6337d28f2003943aa0a3d247bbc25fefc42", size = 196493177, upload-time = "2025-11-18T05:49:17.677Z" }, +] + +[[package]] +name = "nvidia-nvjitlink" +version = "13.0.88" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/56/7a/123e033aaff487c77107195fa5a2b8686795ca537935a24efae476c41f05/nvidia_nvjitlink-13.0.88-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl", hash = "sha256:13a74f429e23b921c1109976abefacc69835f2f433ebd323d3946e11d804e47b", size = 40713933, upload-time = "2025-09-04T08:35:43.553Z" }, + { url = "https://files.pythonhosted.org/packages/ab/2c/93c5250e64df4f894f1cbb397c6fd71f79813f9fd79d7cd61de3f97b3c2d/nvidia_nvjitlink-13.0.88-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:e931536ccc7d467a98ba1d8b89ff7fa7f1fa3b13f2b0069118cd7f47bff07d0c", size = 38768748, upload-time = "2025-09-04T08:35:20.008Z" }, +] + +[[package]] +name = "nvidia-nvshmem-cu13" +version = "3.4.5" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/dc/0f/05cc9c720236dcd2db9c1ab97fff629e96821be2e63103569da0c9b72f19/nvidia_nvshmem_cu13-3.4.5-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:6dc2a197f38e5d0376ad52cd1a2a3617d3cdc150fd5966f4aee9bcebb1d68fe9", size = 60215947, upload-time = "2025-09-06T00:32:20.022Z" }, + { url = "https://files.pythonhosted.org/packages/3c/35/a9bf80a609e74e3b000fef598933235c908fcefcef9026042b8e6dfde2a9/nvidia_nvshmem_cu13-3.4.5-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:290f0a2ee94c9f3687a02502f3b9299a9f9fe826e6d0287ee18482e78d495b80", size = 60412546, upload-time = "2025-09-06T00:32:41.564Z" }, ] [[package]] -name = "kiwisolver" -version = "1.5.0" +name = "nvidia-nvtx" +version = "13.0.85" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/d0/67/9c61eccb13f0bdca9307614e782fec49ffdde0f7a2314935d489fa93cd9c/kiwisolver-1.5.0.tar.gz", hash = "sha256:d4193f3d9dc3f6f79aaed0e5637f45d98850ebf01f7ca20e69457f3e8946b66a", size = 103482, upload-time = "2026-03-09T13:15:53.382Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/12/dd/a495a9c104be1c476f0386e714252caf2b7eca883915422a64c50b88c6f5/kiwisolver-1.5.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:9eed0f7edbb274413b6ee781cca50541c8c0facd3d6fd289779e494340a2b85c", size = 122798, upload-time = "2026-03-09T13:12:58.963Z" }, - { url = "https://files.pythonhosted.org/packages/11/60/37b4047a2af0cf5ef6d8b4b26e91829ae6fc6a2d1f74524bcb0e7cd28a32/kiwisolver-1.5.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:3c4923e404d6bcd91b6779c009542e5647fef32e4a5d75e115e3bbac6f2335eb", size = 66216, upload-time = "2026-03-09T13:13:00.155Z" }, - { url = "https://files.pythonhosted.org/packages/0a/aa/510dc933d87767584abfe03efa445889996c70c2990f6f87c3ebaa0a18c5/kiwisolver-1.5.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:0df54df7e686afa55e6f21fb86195224a6d9beb71d637e8d7920c95cf0f89aac", size = 63911, upload-time = "2026-03-09T13:13:01.671Z" }, - { url = "https://files.pythonhosted.org/packages/80/46/bddc13df6c2a40741e0cc7865bb1c9ed4796b6760bd04ce5fae3928ef917/kiwisolver-1.5.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:2517e24d7315eb51c10664cdb865195df38ab74456c677df67bb47f12d088a27", size = 1438209, upload-time = "2026-03-09T13:13:03.385Z" }, - { url = "https://files.pythonhosted.org/packages/fd/d6/76621246f5165e5372f02f5e6f3f48ea336a8f9e96e43997d45b240ed8cd/kiwisolver-1.5.0-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ff710414307fefa903e0d9bdf300972f892c23477829f49504e59834f4195398", size = 1248888, upload-time = "2026-03-09T13:13:05.231Z" }, - { url = "https://files.pythonhosted.org/packages/b2/c1/31559ec6fb39a5b48035ce29bb63ade628f321785f38c384dee3e2c08bc1/kiwisolver-1.5.0-cp311-cp311-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6176c1811d9d5a04fa391c490cc44f451e240697a16977f11c6f722efb9041db", size = 1266304, upload-time = "2026-03-09T13:13:06.743Z" }, - { url = "https://files.pythonhosted.org/packages/5e/ef/1cb8276f2d29cc6a41e0a042f27946ca347d3a4a75acf85d0a16aa6dcc82/kiwisolver-1.5.0-cp311-cp311-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:50847dca5d197fcbd389c805aa1a1cf32f25d2e7273dc47ab181a517666b68cc", size = 1319650, upload-time = "2026-03-09T13:13:08.607Z" }, - { url = "https://files.pythonhosted.org/packages/4c/e4/5ba3cecd7ce6236ae4a80f67e5d5531287337d0e1f076ca87a5abe4cd5d0/kiwisolver-1.5.0-cp311-cp311-manylinux_2_39_riscv64.whl", hash = "sha256:01808c6d15f4c3e8559595d6d1fe6411c68e4a3822b4b9972b44473b24f4e679", size = 970949, upload-time = "2026-03-09T13:13:10.299Z" }, - { url = "https://files.pythonhosted.org/packages/5a/69/dc61f7ae9a2f071f26004ced87f078235b5507ab6e5acd78f40365655034/kiwisolver-1.5.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:f1f9f4121ec58628c96baa3de1a55a4e3a333c5102c8e94b64e23bf7b2083309", size = 2199125, upload-time = "2026-03-09T13:13:11.841Z" }, - { url = "https://files.pythonhosted.org/packages/e5/7b/abbe0f1b5afa85f8d084b73e90e5f801c0939eba16ac2e49af7c61a6c28d/kiwisolver-1.5.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:b7d335370ae48a780c6e6a6bbfa97342f563744c39c35562f3f367665f5c1de2", size = 2293783, upload-time = "2026-03-09T13:13:14.399Z" }, - { url = "https://files.pythonhosted.org/packages/8a/80/5908ae149d96d81580d604c7f8aefd0e98f4fd728cf172f477e9f2a81744/kiwisolver-1.5.0-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:800ee55980c18545af444d93fdd60c56b580db5cc54867d8cbf8a1dc0829938c", size = 1960726, upload-time = "2026-03-09T13:13:16.047Z" }, - { url = "https://files.pythonhosted.org/packages/84/08/a78cb776f8c085b7143142ce479859cfec086bd09ee638a317040b6ef420/kiwisolver-1.5.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:c438f6ca858697c9ab67eb28246c92508af972e114cac34e57a6d4ba17a3ac08", size = 2464738, upload-time = "2026-03-09T13:13:17.897Z" }, - { url = "https://files.pythonhosted.org/packages/b1/e1/65584da5356ed6cb12c63791a10b208860ac40a83de165cb6a6751a686e3/kiwisolver-1.5.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:8c63c91f95173f9c2a67c7c526b2cea976828a0e7fced9cdcead2802dc10f8a4", size = 2270718, upload-time = "2026-03-09T13:13:19.421Z" }, - { url = "https://files.pythonhosted.org/packages/be/6c/28f17390b62b8f2f520e2915095b3c94d88681ecf0041e75389d9667f202/kiwisolver-1.5.0-cp311-cp311-win_amd64.whl", hash = "sha256:beb7f344487cdcb9e1efe4b7a29681b74d34c08f0043a327a74da852a6749e7b", size = 73480, upload-time = "2026-03-09T13:13:20.818Z" }, - { url = "https://files.pythonhosted.org/packages/d8/0e/2ee5debc4f77a625778fec5501ff3e8036fe361b7ee28ae402a485bb9694/kiwisolver-1.5.0-cp311-cp311-win_arm64.whl", hash = "sha256:ad4ae4ffd1ee9cd11357b4c66b612da9888f4f4daf2f36995eda64bd45370cac", size = 64930, upload-time = "2026-03-09T13:13:21.997Z" }, - { url = "https://files.pythonhosted.org/packages/4d/b2/818b74ebea34dabe6d0c51cb1c572e046730e64844da6ed646d5298c40ce/kiwisolver-1.5.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:4e9750bc21b886308024f8a54ccb9a2cc38ac9fa813bf4348434e3d54f337ff9", size = 123158, upload-time = "2026-03-09T13:13:23.127Z" }, - { url = "https://files.pythonhosted.org/packages/bf/d9/405320f8077e8e1c5c4bd6adc45e1e6edf6d727b6da7f2e2533cf58bff71/kiwisolver-1.5.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:72ec46b7eba5b395e0a7b63025490d3214c11013f4aacb4f5e8d6c3041829588", size = 66388, upload-time = "2026-03-09T13:13:24.765Z" }, - { url = "https://files.pythonhosted.org/packages/99/9f/795fedf35634f746151ca8839d05681ceb6287fbed6cc1c9bf235f7887c2/kiwisolver-1.5.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ed3a984b31da7481b103f68776f7128a89ef26ed40f4dc41a2223cda7fb24819", size = 64068, upload-time = "2026-03-09T13:13:25.878Z" }, - { url = "https://files.pythonhosted.org/packages/c4/13/680c54afe3e65767bed7ec1a15571e1a2f1257128733851ade24abcefbcc/kiwisolver-1.5.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:bb5136fb5352d3f422df33f0c879a1b0c204004324150cc3b5e3c4f310c9049f", size = 1477934, upload-time = "2026-03-09T13:13:27.166Z" }, - { url = "https://files.pythonhosted.org/packages/c8/2f/cebfcdb60fd6a9b0f6b47a9337198bcbad6fbe15e68189b7011fd914911f/kiwisolver-1.5.0-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b2af221f268f5af85e776a73d62b0845fc8baf8ef0abfae79d29c77d0e776aaf", size = 1278537, upload-time = "2026-03-09T13:13:28.707Z" }, - { url = "https://files.pythonhosted.org/packages/f2/0d/9b782923aada3fafb1d6b84e13121954515c669b18af0c26e7d21f579855/kiwisolver-1.5.0-cp312-cp312-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b0f172dc8ffaccb8522d7c5d899de00133f2f1ca7b0a49b7da98e901de87bf2d", size = 1296685, upload-time = "2026-03-09T13:13:30.528Z" }, - { url = "https://files.pythonhosted.org/packages/27/70/83241b6634b04fe44e892688d5208332bde130f38e610c0418f9ede47ded/kiwisolver-1.5.0-cp312-cp312-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6ab8ba9152203feec73758dad83af9a0bbe05001eb4639e547207c40cfb52083", size = 1346024, upload-time = "2026-03-09T13:13:32.818Z" }, - { url = "https://files.pythonhosted.org/packages/e4/db/30ed226fb271ae1a6431fc0fe0edffb2efe23cadb01e798caeb9f2ceae8f/kiwisolver-1.5.0-cp312-cp312-manylinux_2_39_riscv64.whl", hash = "sha256:cdee07c4d7f6d72008d3f73b9bf027f4e11550224c7c50d8df1ae4a37c1402a6", size = 987241, upload-time = "2026-03-09T13:13:34.435Z" }, - { url = "https://files.pythonhosted.org/packages/ec/bd/c314595208e4c9587652d50959ead9e461995389664e490f4dce7ff0f782/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:7c60d3c9b06fb23bd9c6139281ccbdc384297579ae037f08ae90c69f6845c0b1", size = 2227742, upload-time = "2026-03-09T13:13:36.4Z" }, - { url = "https://files.pythonhosted.org/packages/c1/43/0499cec932d935229b5543d073c2b87c9c22846aab48881e9d8d6e742a2d/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:e315e5ec90d88e140f57696ff85b484ff68bb311e36f2c414aa4286293e6dee0", size = 2323966, upload-time = "2026-03-09T13:13:38.204Z" }, - { url = "https://files.pythonhosted.org/packages/3d/6f/79b0d760907965acfd9d61826a3d41f8f093c538f55cd2633d3f0db269f6/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:1465387ac63576c3e125e5337a6892b9e99e0627d52317f3ca79e6930d889d15", size = 1977417, upload-time = "2026-03-09T13:13:39.966Z" }, - { url = "https://files.pythonhosted.org/packages/ab/31/01d0537c41cb75a551a438c3c7a80d0c60d60b81f694dac83dd436aec0d0/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:530a3fd64c87cffa844d4b6b9768774763d9caa299e9b75d8eca6a4423b31314", size = 2491238, upload-time = "2026-03-09T13:13:41.698Z" }, - { url = "https://files.pythonhosted.org/packages/e4/34/8aefdd0be9cfd00a44509251ba864f5caf2991e36772e61c408007e7f417/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1d9daea4ea6b9be74fe2f01f7fbade8d6ffab263e781274cffca0dba9be9eec9", size = 2294947, upload-time = "2026-03-09T13:13:43.343Z" }, - { url = "https://files.pythonhosted.org/packages/ad/cf/0348374369ca588f8fe9c338fae49fa4e16eeb10ffb3d012f23a54578a9e/kiwisolver-1.5.0-cp312-cp312-win_amd64.whl", hash = "sha256:f18c2d9782259a6dc132fdc7a63c168cbc74b35284b6d75c673958982a378384", size = 73569, upload-time = "2026-03-09T13:13:45.792Z" }, - { url = "https://files.pythonhosted.org/packages/28/26/192b26196e2316e2bd29deef67e37cdf9870d9af8e085e521afff0fed526/kiwisolver-1.5.0-cp312-cp312-win_arm64.whl", hash = "sha256:f7c7553b13f69c1b29a5bde08ddc6d9d0c8bfb84f9ed01c30db25944aeb852a7", size = 64997, upload-time = "2026-03-09T13:13:46.878Z" }, - { url = "https://files.pythonhosted.org/packages/1c/fa/2910df836372d8761bb6eff7d8bdcb1613b5c2e03f260efe7abe34d388a7/kiwisolver-1.5.0-graalpy312-graalpy250_312_native-macosx_10_13_x86_64.whl", hash = "sha256:5ae8e62c147495b01a0f4765c878e9bfdf843412446a247e28df59936e99e797", size = 130262, upload-time = "2026-03-09T13:15:35.629Z" }, - { url = "https://files.pythonhosted.org/packages/0f/41/c5f71f9f00aabcc71fee8b7475e3f64747282580c2fe748961ba29b18385/kiwisolver-1.5.0-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:f6764a4ccab3078db14a632420930f6186058750df066b8ea2a7106df91d3203", size = 138036, upload-time = "2026-03-09T13:15:36.894Z" }, - { url = "https://files.pythonhosted.org/packages/fa/06/7399a607f434119c6e1fdc8ec89a8d51ccccadf3341dee4ead6bd14caaf5/kiwisolver-1.5.0-graalpy312-graalpy250_312_native-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c31c13da98624f957b0fb1b5bae5383b2333c2c3f6793d9825dd5ce79b525cb7", size = 194295, upload-time = "2026-03-09T13:15:38.22Z" }, - { url = "https://files.pythonhosted.org/packages/b5/91/53255615acd2a1eaca307ede3c90eb550bae9c94581f8c00081b6b1c8f44/kiwisolver-1.5.0-graalpy312-graalpy250_312_native-win_amd64.whl", hash = "sha256:1f1489f769582498610e015a8ef2d36f28f505ab3096d0e16b4858a9ec214f57", size = 75987, upload-time = "2026-03-09T13:15:39.65Z" }, - { url = "https://files.pythonhosted.org/packages/e9/eb/5fcbbbf9a0e2c3a35effb88831a483345326bbc3a030a3b5b69aee647f84/kiwisolver-1.5.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:ec4c85dc4b687c7f7f15f553ff26a98bfe8c58f5f7f0ac8905f0ba4c7be60232", size = 59532, upload-time = "2026-03-09T13:15:47.047Z" }, - { url = "https://files.pythonhosted.org/packages/c3/9b/e17104555bb4db148fd52327feea1e96be4b88e8e008b029002c281a21ab/kiwisolver-1.5.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:12e91c215a96e39f57989c8912ae761286ac5a9584d04030ceb3368a357f017a", size = 57420, upload-time = "2026-03-09T13:15:48.199Z" }, - { url = "https://files.pythonhosted.org/packages/48/44/2b5b95b7aa39fb2d8d9d956e0f3d5d45aef2ae1d942d4c3ffac2f9cfed1a/kiwisolver-1.5.0-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:be4a51a55833dc29ab5d7503e7bcb3b3af3402d266018137127450005cdfe737", size = 79892, upload-time = "2026-03-09T13:15:49.694Z" }, - { url = "https://files.pythonhosted.org/packages/52/7d/7157f9bba6b455cfb4632ed411e199fc8b8977642c2b12082e1bd9e6d173/kiwisolver-1.5.0-pp311-pypy311_pp73-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:daae526907e262de627d8f70058a0f64acc9e2641c164c99c8f594b34a799a16", size = 77603, upload-time = "2026-03-09T13:15:50.945Z" }, - { url = "https://files.pythonhosted.org/packages/0a/dd/8050c947d435c8d4bc94e3252f4d8bb8a76cfb424f043a8680be637a57f1/kiwisolver-1.5.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:59cd8683f575d96df5bb48f6add94afc055012c29e28124fcae2b63661b9efb1", size = 73558, upload-time = "2026-03-09T13:15:52.112Z" }, + { url = "https://files.pythonhosted.org/packages/c2/f3/d86c845465a2723ad7e1e5c36dcd75ddb82898b3f53be47ebd429fb2fa5d/nvidia_nvtx-13.0.85-py3-none-manylinux1_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:4936d1d6780fbe68db454f5e72a42ff64d1fd6397df9f363ae786930fd5c1cd4", size = 148047, upload-time = "2025-09-04T08:29:01.761Z" }, + { url = "https://files.pythonhosted.org/packages/a8/64/3708a90d1ebe202ffdeb7185f878a3c84d15c2b2c31858da2ce0583e2def/nvidia_nvtx-13.0.85-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:cb7780edb6b14107373c835bf8b72e7a178bac7367e23da7acb108f973f157a6", size = 148878, upload-time = "2025-09-04T08:28:53.627Z" }, ] [[package]] -name = "matplotlib" -version = "3.9.0" +name = "opt-einsum" +version = "3.4.0" source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "contourpy" }, - { name = "cycler" }, - { name = "fonttools" }, - { name = "kiwisolver" }, - { name = "numpy" }, - { name = "packaging" }, - { name = "pillow" }, - { name = "pyparsing" }, - { name = "python-dateutil" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/c5/a4/a7236bf8b0137deff48737c6ccf2154ef4486e57c6a5b7c309bf515992bd/matplotlib-3.9.0.tar.gz", hash = "sha256:e6d29ea6c19e34b30fb7d88b7081f869a03014f66fe06d62cc77d5a6ea88ed7a", size = 36069890, upload-time = "2024-05-15T23:38:15.591Z" } +sdist = { url = "https://files.pythonhosted.org/packages/8c/b9/2ac072041e899a52f20cf9510850ff58295003aa75525e58343591b0cbfb/opt_einsum-3.4.0.tar.gz", hash = "sha256:96ca72f1b886d148241348783498194c577fa30a8faac108586b14f1ba4473ac", size = 63004, upload-time = "2024-09-26T14:33:24.483Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/09/49/569b50eb5e5a75b61f7a0bacb6029e9ea9c8a1190df55a39a31789244e09/matplotlib-3.9.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:063af8587fceeac13b0936c42a2b6c732c2ab1c98d38abc3337e430e1ff75e38", size = 7893678, upload-time = "2024-05-15T23:37:20.035Z" }, - { url = "https://files.pythonhosted.org/packages/f4/b4/c1700c8b2ff8d379c187f37055e61bd7a611eb2c544466600a7734793d54/matplotlib-3.9.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:9a2fa6d899e17ddca6d6526cf6e7ba677738bf2a6a9590d702c277204a7c6152", size = 7775027, upload-time = "2024-05-15T23:37:22.783Z" }, - { url = "https://files.pythonhosted.org/packages/bc/9e/b09513717f60071fefcb28c7c783aa658f939f3d4ba1cefb6c05138c6657/matplotlib-3.9.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:550cdda3adbd596078cca7d13ed50b77879104e2e46392dcd7c75259d8f00e85", size = 8192694, upload-time = "2024-05-15T23:37:24.789Z" }, - { url = "https://files.pythonhosted.org/packages/41/f1/115e7c79b4506b4f0533acba742babd9718ff92eeca6d4205843173b6173/matplotlib-3.9.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:76cce0f31b351e3551d1f3779420cf8f6ec0d4a8cf9c0237a3b549fd28eb4abb", size = 8307002, upload-time = "2024-05-15T23:37:27.243Z" }, - { url = "https://files.pythonhosted.org/packages/7a/a2/5c1a64d188c4cae7368ebb8c28a354e3f262cb86b28c38ffa6ee3ad532ba/matplotlib-3.9.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:c53aeb514ccbbcbab55a27f912d79ea30ab21ee0531ee2c09f13800efb272674", size = 8600548, upload-time = "2024-05-15T23:37:29.701Z" }, - { url = "https://files.pythonhosted.org/packages/c6/c8/6936e8c7b279a5abac82f399d8d72ac25da530cf5f78a0e40063e492558c/matplotlib-3.9.0-cp311-cp311-win_amd64.whl", hash = "sha256:a5be985db2596d761cdf0c2eaf52396f26e6a64ab46bd8cd810c48972349d1be", size = 7963606, upload-time = "2024-05-15T23:37:32.803Z" }, - { url = "https://files.pythonhosted.org/packages/af/43/54b7dfd91ed33da92973dc5d50231ef7b2d0622c8ae72babbad26bc1a319/matplotlib-3.9.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:c79f3a585f1368da6049318bdf1f85568d8d04b2e89fc24b7e02cc9b62017382", size = 7884612, upload-time = "2024-05-15T23:37:35.246Z" }, - { url = "https://files.pythonhosted.org/packages/4c/88/15bbb864b0d871707294ff325f9ffd0dfa486db2637eb34dd5f8dcf5b9bf/matplotlib-3.9.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:bdd1ecbe268eb3e7653e04f451635f0fb0f77f07fd070242b44c076c9106da84", size = 7769852, upload-time = "2024-05-15T23:37:37.21Z" }, - { url = "https://files.pythonhosted.org/packages/57/af/8ed9b852fc041fc5bd101f9964682874ccbf24f9c08323edee6a1600eb04/matplotlib-3.9.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d38e85a1a6d732f645f1403ce5e6727fd9418cd4574521d5803d3d94911038e5", size = 8185646, upload-time = "2024-05-15T23:37:39.971Z" }, - { url = "https://files.pythonhosted.org/packages/f4/ff/da311c1e679eed54d3aed67754a4e859bd3b773060c2fa187962e60fcb85/matplotlib-3.9.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0a490715b3b9984fa609116481b22178348c1a220a4499cda79132000a79b4db", size = 8298411, upload-time = "2024-05-15T23:37:42.471Z" }, - { url = "https://files.pythonhosted.org/packages/db/8c/1014baa6776503914865d87e1e8a803ee9faa7b722ca5e655463b79c966e/matplotlib-3.9.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:8146ce83cbc5dc71c223a74a1996d446cd35cfb6a04b683e1446b7e6c73603b7", size = 8591196, upload-time = "2024-05-15T23:37:44.94Z" }, - { url = "https://files.pythonhosted.org/packages/17/91/febbb6c1063ae05a62fdbe038c2917b348b1b35f0482cee4738e6870a44a/matplotlib-3.9.0-cp312-cp312-win_amd64.whl", hash = "sha256:d91a4ffc587bacf5c4ce4ecfe4bcd23a4b675e76315f2866e588686cc97fccdf", size = 7968581, upload-time = "2024-05-15T23:37:47.839Z" }, + { url = "https://files.pythonhosted.org/packages/23/cd/066e86230ae37ed0be70aae89aabf03ca8d9f39c8aea0dec8029455b5540/opt_einsum-3.4.0-py3-none-any.whl", hash = "sha256:69bb92469f86a1565195ece4ac0323943e83477171b91d24c35afe028a90d7cd", size = 71932, upload-time = "2024-09-26T14:33:23.039Z" }, ] [[package]] -name = "numpy" -version = "2.4.3" +name = "optree" +version = "0.19.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/10/8b/c265f4823726ab832de836cdd184d0986dcf94480f81e8739692a7ac7af2/numpy-2.4.3.tar.gz", hash = "sha256:483a201202b73495f00dbc83796c6ae63137a9bdade074f7648b3e32613412dd", size = 20727743, upload-time = "2026-03-09T07:58:53.426Z" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/3d/63/7b078bc36d5a206c21b03565a818ede38ff0fbf014e92085ec467ef10adb/optree-0.19.0.tar.gz", hash = "sha256:bc1991a948590756409e76be4e29efd4a487a185056d35db6c67619c19ea27a1", size = 175199, upload-time = "2026-02-23T01:56:37.752Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/f9/51/5093a2df15c4dc19da3f79d1021e891f5dcf1d9d1db6ba38891d5590f3fe/numpy-2.4.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:33b3bf58ee84b172c067f56aeadc7ee9ab6de69c5e800ab5b10295d54c581adb", size = 16957183, upload-time = "2026-03-09T07:55:57.774Z" }, - { url = "https://files.pythonhosted.org/packages/b5/7c/c061f3de0630941073d2598dc271ac2f6cbcf5c83c74a5870fea07488333/numpy-2.4.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:8ba7b51e71c05aa1f9bc3641463cd82308eab40ce0d5c7e1fd4038cbf9938147", size = 14968734, upload-time = "2026-03-09T07:56:00.494Z" }, - { url = "https://files.pythonhosted.org/packages/ef/27/d26c85cbcd86b26e4f125b0668e7a7c0542d19dd7d23ee12e87b550e95b5/numpy-2.4.3-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:a1988292870c7cb9d0ebb4cc96b4d447513a9644801de54606dc7aabf2b7d920", size = 5475288, upload-time = "2026-03-09T07:56:02.857Z" }, - { url = "https://files.pythonhosted.org/packages/2b/09/3c4abbc1dcd8010bf1a611d174c7aa689fc505585ec806111b4406f6f1b1/numpy-2.4.3-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:23b46bb6d8ecb68b58c09944483c135ae5f0e9b8d8858ece5e4ead783771d2a9", size = 6805253, upload-time = "2026-03-09T07:56:04.53Z" }, - { url = "https://files.pythonhosted.org/packages/21/bc/e7aa3f6817e40c3f517d407742337cbb8e6fc4b83ce0b55ab780c829243b/numpy-2.4.3-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a016db5c5dba78fa8fe9f5d80d6708f9c42ab087a739803c0ac83a43d686a470", size = 15969479, upload-time = "2026-03-09T07:56:06.638Z" }, - { url = "https://files.pythonhosted.org/packages/78/51/9f5d7a41f0b51649ddf2f2320595e15e122a40610b233d51928dd6c92353/numpy-2.4.3-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:715de7f82e192e8cae5a507a347d97ad17598f8e026152ca97233e3666daaa71", size = 16901035, upload-time = "2026-03-09T07:56:09.405Z" }, - { url = "https://files.pythonhosted.org/packages/64/6e/b221dd847d7181bc5ee4857bfb026182ef69499f9305eb1371cbb1aea626/numpy-2.4.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:2ddb7919366ee468342b91dea2352824c25b55814a987847b6c52003a7c97f15", size = 17325657, upload-time = "2026-03-09T07:56:12.067Z" }, - { url = "https://files.pythonhosted.org/packages/eb/b8/8f3fd2da596e1063964b758b5e3c970aed1949a05200d7e3d46a9d46d643/numpy-2.4.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:a315e5234d88067f2d97e1f2ef670a7569df445d55400f1e33d117418d008d52", size = 18635512, upload-time = "2026-03-09T07:56:14.629Z" }, - { url = "https://files.pythonhosted.org/packages/5c/24/2993b775c37e39d2f8ab4125b44337ab0b2ba106c100980b7c274a22bee7/numpy-2.4.3-cp311-cp311-win32.whl", hash = "sha256:2b3f8d2c4589b1a2028d2a770b0fc4d1f332fb5e01521f4de3199a896d158ddd", size = 6238100, upload-time = "2026-03-09T07:56:17.243Z" }, - { url = "https://files.pythonhosted.org/packages/76/1d/edccf27adedb754db7c4511d5eac8b83f004ae948fe2d3509e8b78097d4c/numpy-2.4.3-cp311-cp311-win_amd64.whl", hash = "sha256:77e76d932c49a75617c6d13464e41203cd410956614d0a0e999b25e9e8d27eec", size = 12609816, upload-time = "2026-03-09T07:56:19.089Z" }, - { url = "https://files.pythonhosted.org/packages/92/82/190b99153480076c8dce85f4cfe7d53ea84444145ffa54cb58dcd460d66b/numpy-2.4.3-cp311-cp311-win_arm64.whl", hash = "sha256:eb610595dd91560905c132c709412b512135a60f1851ccbd2c959e136431ff67", size = 10485757, upload-time = "2026-03-09T07:56:21.753Z" }, - { url = "https://files.pythonhosted.org/packages/a9/ed/6388632536f9788cea23a3a1b629f25b43eaacd7d7377e5d6bc7b9deb69b/numpy-2.4.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:61b0cbabbb6126c8df63b9a3a0c4b1f44ebca5e12ff6997b80fcf267fb3150ef", size = 16669628, upload-time = "2026-03-09T07:56:24.252Z" }, - { url = "https://files.pythonhosted.org/packages/74/1b/ee2abfc68e1ce728b2958b6ba831d65c62e1b13ce3017c13943f8f9b5b2e/numpy-2.4.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7395e69ff32526710748f92cd8c9849b361830968ea3e24a676f272653e8983e", size = 14696872, upload-time = "2026-03-09T07:56:26.991Z" }, - { url = "https://files.pythonhosted.org/packages/ba/d1/780400e915ff5638166f11ca9dc2c5815189f3d7cf6f8759a1685e586413/numpy-2.4.3-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:abdce0f71dcb4a00e4e77f3faf05e4616ceccfe72ccaa07f47ee79cda3b7b0f4", size = 5203489, upload-time = "2026-03-09T07:56:29.414Z" }, - { url = "https://files.pythonhosted.org/packages/0b/bb/baffa907e9da4cc34a6e556d6d90e032f6d7a75ea47968ea92b4858826c4/numpy-2.4.3-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:48da3a4ee1336454b07497ff7ec83903efa5505792c4e6d9bf83d99dc07a1e18", size = 6550814, upload-time = "2026-03-09T07:56:32.225Z" }, - { url = "https://files.pythonhosted.org/packages/7b/12/8c9f0c6c95f76aeb20fc4a699c33e9f827fa0d0f857747c73bb7b17af945/numpy-2.4.3-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:32e3bef222ad6b052280311d1d60db8e259e4947052c3ae7dd6817451fc8a4c5", size = 15666601, upload-time = "2026-03-09T07:56:34.461Z" }, - { url = "https://files.pythonhosted.org/packages/bd/79/cc665495e4d57d0aa6fbcc0aa57aa82671dfc78fbf95fe733ed86d98f52a/numpy-2.4.3-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e7dd01a46700b1967487141a66ac1a3cf0dd8ebf1f08db37d46389401512ca97", size = 16621358, upload-time = "2026-03-09T07:56:36.852Z" }, - { url = "https://files.pythonhosted.org/packages/a8/40/b4ecb7224af1065c3539f5ecfff879d090de09608ad1008f02c05c770cb3/numpy-2.4.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:76f0f283506c28b12bba319c0fab98217e9f9b54e6160e9c79e9f7348ba32e9c", size = 17016135, upload-time = "2026-03-09T07:56:39.337Z" }, - { url = "https://files.pythonhosted.org/packages/f7/b1/6a88e888052eed951afed7a142dcdf3b149a030ca59b4c71eef085858e43/numpy-2.4.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:737f630a337364665aba3b5a77e56a68cc42d350edd010c345d65a3efa3addcc", size = 18345816, upload-time = "2026-03-09T07:56:42.31Z" }, - { url = "https://files.pythonhosted.org/packages/f3/8f/103a60c5f8c3d7fc678c19cd7b2476110da689ccb80bc18050efbaeae183/numpy-2.4.3-cp312-cp312-win32.whl", hash = "sha256:26952e18d82a1dbbc2f008d402021baa8d6fc8e84347a2072a25e08b46d698b9", size = 5960132, upload-time = "2026-03-09T07:56:44.851Z" }, - { url = "https://files.pythonhosted.org/packages/d7/7c/f5ee1bf6ed888494978046a809df2882aad35d414b622893322df7286879/numpy-2.4.3-cp312-cp312-win_amd64.whl", hash = "sha256:65f3c2455188f09678355f5cae1f959a06b778bc66d535da07bf2ef20cd319d5", size = 12316144, upload-time = "2026-03-09T07:56:47.057Z" }, - { url = "https://files.pythonhosted.org/packages/71/46/8d1cb3f7a00f2fb6394140e7e6623696e54c6318a9d9691bb4904672cf42/numpy-2.4.3-cp312-cp312-win_arm64.whl", hash = "sha256:2abad5c7fef172b3377502bde47892439bae394a71bc329f31df0fd829b41a9e", size = 10220364, upload-time = "2026-03-09T07:56:49.849Z" }, - { url = "https://files.pythonhosted.org/packages/64/e4/4dab9fb43c83719c29241c535d9e07be73bea4bc0c6686c5816d8e1b6689/numpy-2.4.3-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:c6b124bfcafb9e8d3ed09130dbee44848c20b3e758b6bbf006e641778927c028", size = 16834892, upload-time = "2026-03-09T07:58:35.334Z" }, - { url = "https://files.pythonhosted.org/packages/c9/29/f8b6d4af90fed3dfda84ebc0df06c9833d38880c79ce954e5b661758aa31/numpy-2.4.3-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:76dbb9d4e43c16cf9aa711fcd8de1e2eeb27539dcefb60a1d5e9f12fae1d1ed8", size = 14893070, upload-time = "2026-03-09T07:58:37.7Z" }, - { url = "https://files.pythonhosted.org/packages/9a/04/a19b3c91dbec0a49269407f15d5753673a09832daed40c45e8150e6fa558/numpy-2.4.3-pp311-pypy311_pp73-macosx_14_0_arm64.whl", hash = "sha256:29363fbfa6f8ee855d7569c96ce524845e3d726d6c19b29eceec7dd555dab152", size = 5399609, upload-time = "2026-03-09T07:58:39.853Z" }, - { url = "https://files.pythonhosted.org/packages/79/34/4d73603f5420eab89ea8a67097b31364bf7c30f811d4dd84b1659c7476d9/numpy-2.4.3-pp311-pypy311_pp73-macosx_14_0_x86_64.whl", hash = "sha256:bc71942c789ef415a37f0d4eab90341425a00d538cd0642445d30b41023d3395", size = 6714355, upload-time = "2026-03-09T07:58:42.365Z" }, - { url = "https://files.pythonhosted.org/packages/58/ad/1100d7229bb248394939a12a8074d485b655e8ed44207d328fdd7fcebc7b/numpy-2.4.3-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7e58765ad74dcebd3ef0208a5078fba32dc8ec3578fe84a604432950cd043d79", size = 15800434, upload-time = "2026-03-09T07:58:44.837Z" }, - { url = "https://files.pythonhosted.org/packages/0c/fd/16d710c085d28ba4feaf29ac60c936c9d662e390344f94a6beaa2ac9899b/numpy-2.4.3-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8e236dbda4e1d319d681afcbb136c0c4a8e0f1a5c58ceec2adebb547357fe857", size = 16729409, upload-time = "2026-03-09T07:58:47.972Z" }, - { url = "https://files.pythonhosted.org/packages/57/a7/b35835e278c18b85206834b3aa3abe68e77a98769c59233d1f6300284781/numpy-2.4.3-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:4b42639cdde6d24e732ff823a3fa5b701d8acad89c4142bc1d0bd6dc85200ba5", size = 12504685, upload-time = "2026-03-09T07:58:50.525Z" }, + { url = "https://files.pythonhosted.org/packages/2d/bf/5cbbf61a27f94797c3d9786f6230223023a943b60f5e893d52368f10b8b1/optree-0.19.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7ec4b2ce49622c6be2c8634712b6c63cc274835bac89a56e3ab2ca863a32ff4b", size = 418100, upload-time = "2026-02-23T01:55:05.282Z" }, + { url = "https://files.pythonhosted.org/packages/00/9e/65899e6470f5df289ccdbe9e228fb0cd0ae45ccda8e32c92d6efae1530ef/optree-0.19.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f0978603623b4b1f794f05f6bbed0645cb7e219f4a5a349b2a2bd4514d84ac82", size = 388582, upload-time = "2026-02-23T01:55:06.628Z" }, + { url = "https://files.pythonhosted.org/packages/d1/dc/f4826835be660181f1b4444ac92b51dda96d4634d3c2271e14598da7bf2a/optree-0.19.0-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8c9e52c50ed3f3f8b1cf4e47a20a7c5e77175b4f84b2ecf390a76f0d1dd91da6", size = 407457, upload-time = "2026-02-23T01:55:07.713Z" }, + { url = "https://files.pythonhosted.org/packages/ce/b0/89283ac1dd1ead3aa3d7a6b45a26846f457bded79a83b6828fc1ed9a6db3/optree-0.19.0-cp312-cp312-manylinux_2_26_i686.manylinux_2_28_i686.whl", hash = "sha256:3fe3e5f7a30a7d08ddba0a34e48f5483f6c4d7bb710375434ad3633170c73c48", size = 471230, upload-time = "2026-02-23T01:55:09.244Z" }, + { url = "https://files.pythonhosted.org/packages/2a/a2/47f620f87b0544b2e0eb0b3c661682bd0ea1c79f6e38f9147bc0f835c973/optree-0.19.0-cp312-cp312-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8315527e1f14a91173fe6871847da7b949048ec61ff8b3e507fc286e75b0aa3c", size = 469442, upload-time = "2026-02-23T01:55:10.387Z" }, + { url = "https://files.pythonhosted.org/packages/84/e9/b9ae18404135de53809fb994b754ac0eac838d8c4dfa8a10a811d8dec91d/optree-0.19.0-cp312-cp312-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:938fb15d140ab65148f4e6975048facbef83a9210353fbedd471ac39e7544339", size = 468840, upload-time = "2026-02-23T01:55:11.419Z" }, + { url = "https://files.pythonhosted.org/packages/0a/e5/a77df15a62b37bb14c81b5757e2a0573f57e7c06d125a410ad2cd7cefb72/optree-0.19.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2b8209570340135a7e586c90f393f3c6359e8a49c40d783196721cc487e51d9c", size = 451408, upload-time = "2026-02-23T01:55:12.501Z" }, + { url = "https://files.pythonhosted.org/packages/8c/43/1aa431cee19cd98c4229e468767021f9a92195d9431857e28198a3a3ce2f/optree-0.19.0-cp312-cp312-manylinux_2_39_riscv64.whl", hash = "sha256:1397dc925026917531a43fda32054ae1e77e5ed9bf8284bcae6354c19c26e14a", size = 412544, upload-time = "2026-02-23T01:55:14.048Z" }, + { url = "https://files.pythonhosted.org/packages/5b/b9/b94fd3a116b80951d692a82f4135ae84b3d78bd1b092250aff76a3366138/optree-0.19.0-cp312-cp312-win32.whl", hash = "sha256:68f58e8f8b75c76c51e61e3dc2d9e94609bafb0e1a6459e6d525ced905cd9a74", size = 312033, upload-time = "2026-02-23T01:55:15.101Z" }, + { url = "https://files.pythonhosted.org/packages/9e/7f/31fa1b2311038bfc355ad6e4e4e63d028719cb67fb3ebe6fb76ff2124105/optree-0.19.0-cp312-cp312-win_amd64.whl", hash = "sha256:5c44ca0f579ed3e0ca777a5711d4a6c1b374feacf1bb4fe9cfe85297b0c8d237", size = 335374, upload-time = "2026-02-23T01:55:16.094Z" }, + { url = "https://files.pythonhosted.org/packages/09/86/863bc3f42f83113f5c6a5beaf4fec3c3481a76872f3244d0e64fb9ebd3b0/optree-0.19.0-cp312-cp312-win_arm64.whl", hash = "sha256:0461f796b4ade3fab519d821b0fa521f07e2af70206b76aac75fcfdc2e051fca", size = 345868, upload-time = "2026-02-23T01:55:18.006Z" }, + { url = "https://files.pythonhosted.org/packages/ee/61/d79c7eeb87e98d08bc8d95ed08dee83bedb4e55371a7d2ae3c874ec02608/optree-0.19.0-cp313-cp313-android_24_arm64_v8a.whl", hash = "sha256:1eea5b7be833c6d555d08ff68046d3dd2112dfb39e6f1eb09887ab6c617a6d64", size = 923043, upload-time = "2026-02-23T01:55:19.018Z" }, + { url = "https://files.pythonhosted.org/packages/2d/ed/e80504f65e7e80fdcd129258428d7976ea9f03bf9dad56a5293c44d563ad/optree-0.19.0-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:4d9cf9dfa0ac051e0ed82869d782f0affdbdb1daa5f2e851d37ea8625c60071a", size = 385597, upload-time = "2026-02-23T01:55:20.586Z" }, + { url = "https://files.pythonhosted.org/packages/65/e5/d1926a2f0e0240f6800ff385c8486879f7da0a5a030b7aa5d84e44e9c9ca/optree-0.19.0-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:43c4f8ba5755d56d046be2cb1380cbc362234ad93fd9933384c6dd7fdebe6c4a", size = 392265, upload-time = "2026-02-23T01:55:21.662Z" }, + { url = "https://files.pythonhosted.org/packages/61/88/9c598325e89bbed29b37a381ebb2b94f1d9d769c973b879b3e9766b4b16d/optree-0.19.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:36b1134680ee3f9768ede290da653e1604a8083bce69fef8fb4e46863346d5c8", size = 423763, upload-time = "2026-02-23T01:55:22.97Z" }, + { url = "https://files.pythonhosted.org/packages/6b/d2/fcba2a1826d362a64cb36ec9f675ed6dcddee47099948913122b0aafbe44/optree-0.19.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:c9f7e7e7bf2ef011d0be1c2e87c96f5dc543dad1ac34430c2f606938c9ec5135", size = 392720, upload-time = "2026-02-23T01:55:24.107Z" }, + { url = "https://files.pythonhosted.org/packages/eb/43/5e6d51d8c203a79cff084efa9f04a745b8ef5cf4c86dbb127e7b192f14d9/optree-0.19.0-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bb5752f17afa017b08b0cbac8a383d4bb90035b353bef7a25fe03cda69a21d33", size = 411481, upload-time = "2026-02-23T01:55:25.215Z" }, + { url = "https://files.pythonhosted.org/packages/4b/dc/dc09347136876287b463b8599239d6fa338298fd322ac629817bd2f4def4/optree-0.19.0-cp313-cp313-manylinux_2_26_i686.manylinux_2_28_i686.whl", hash = "sha256:e9b6245993494b1aa54529eb7356aeefa6704c8b436e6e5f20b25c30f7af7620", size = 476695, upload-time = "2026-02-23T01:55:26.23Z" }, + { url = "https://files.pythonhosted.org/packages/ee/cc/5d2c9cf906bd3ae357e7221450bacefd0321d7b94e6171dec39552b346e6/optree-0.19.0-cp313-cp313-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7351a24b30568c963a92b19f543c9562b36b3222caed2a5ac3209ef910972bec", size = 471846, upload-time = "2026-02-23T01:55:27.288Z" }, + { url = "https://files.pythonhosted.org/packages/64/7f/75b10f88da994fc3da3dc1ab7d54bab7bd3a6fa5eb81b586f13f8bd6ab0e/optree-0.19.0-cp313-cp313-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2c6610a1d1d74af0f53c9bbabb7c265679a9a07e03783c8cc4a678ba3bb6f9a5", size = 473145, upload-time = "2026-02-23T01:55:28.941Z" }, + { url = "https://files.pythonhosted.org/packages/78/fc/753bf69b907652d54b7c6012ccb320d8c1a3161454e415331058b6f04246/optree-0.19.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:37e07a5233be64329cbf41e20ab07c50da53bdc374109a2b376be49c4a34a37f", size = 456160, upload-time = "2026-02-23T01:55:30.515Z" }, + { url = "https://files.pythonhosted.org/packages/e2/a8/70640f9998438f50a0a1c57f2a12aac856cd937f2c4c4feef5a3cfe8e9c7/optree-0.19.0-cp313-cp313-manylinux_2_39_riscv64.whl", hash = "sha256:c23a25caff6b096b62379adb99e2c401805141497ebb8131f271a4c93f5ed5dc", size = 417116, upload-time = "2026-02-23T01:55:31.591Z" }, + { url = "https://files.pythonhosted.org/packages/ad/05/0b8bf4abf5d1a7cd9a19ba680e1ec64ad38eec3204e4e16a769e8aeaa4a2/optree-0.19.0-cp313-cp313-win32.whl", hash = "sha256:045cf112adaebc76c9c7cabde857c01babfc9fae8aa0a28d48f7c565fadf0cb9", size = 312101, upload-time = "2026-02-23T01:55:33.002Z" }, + { url = "https://files.pythonhosted.org/packages/b1/c7/9ce83f115d7f4a47741827a037067b9026c29996ad7913bc40277924c773/optree-0.19.0-cp313-cp313-win_amd64.whl", hash = "sha256:bc0c6c9f99fb90e3a20a8b94c219e6b03e585f65ab9a11c9acd1511a5f885f79", size = 337944, upload-time = "2026-02-23T01:55:34.3Z" }, + { url = "https://files.pythonhosted.org/packages/17/fd/97c27d6e51c8b958b29f5c7b4cdcae4f2e7c9ef5b5465be459811a48876b/optree-0.19.0-cp313-cp313-win_arm64.whl", hash = "sha256:48f492363fa0f9ffe5029d0ecafd2fa30ffe0d5d52c8dd414123f47b743bd42e", size = 347153, upload-time = "2026-02-23T01:55:35.331Z" }, + { url = "https://files.pythonhosted.org/packages/46/45/9a2f05b5d033482b58ca36df6f41b0b28af3ccfa43267a82254c973dcd14/optree-0.19.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:d6362b9e9a0f4dd7c5b88debe182a90541aba7f1ad02d00922d01c4df4b3c933", size = 463985, upload-time = "2026-02-23T01:55:36.681Z" }, + { url = "https://files.pythonhosted.org/packages/20/b7/5d0a013c5461e0933ce7385a06eed625358de12216c80da935138e6af205/optree-0.19.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:381096a293d385fd3135e5c707bb7e58c584bc9bd50f458237b49da21a621df3", size = 431307, upload-time = "2026-02-23T01:55:37.754Z" }, + { url = "https://files.pythonhosted.org/packages/d6/2c/d3f2674411c8e3338e91e7446af239597ae6efd23f14e2039f29ced3d73e/optree-0.19.0-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a9675007cc54371be544bb33fd7eb07b0773d88deacf8aa4cc72fa735c4a4d33", size = 426917, upload-time = "2026-02-23T01:55:39.122Z" }, + { url = "https://files.pythonhosted.org/packages/e9/e9/009964734f19d6996291e77f2c1da5d35a743defc4e89aefb01260e2f9d6/optree-0.19.0-cp313-cp313t-manylinux_2_26_i686.manylinux_2_28_i686.whl", hash = "sha256:406b355d6f29f99535efa97ea16eda70414968271a894c99f48cd91848723706", size = 490603, upload-time = "2026-02-23T01:55:40.123Z" }, + { url = "https://files.pythonhosted.org/packages/2b/4c/96706f855c6b623259e754f751020acfb3452e412f7c85330629ab4b9ecc/optree-0.19.0-cp313-cp313t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:d05e5bf6ce30258cda643ea50cc424038e5107905e9fc11d19a04453a8d2ee27", size = 486388, upload-time = "2026-02-23T01:55:41.746Z" }, + { url = "https://files.pythonhosted.org/packages/b5/e4/9b23a27c9bd211d22a2e55a5a66e62afe5c75ff98b81fc7d000d879e75e6/optree-0.19.0-cp313-cp313t-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b6e11479d98690fc9efd15d65195af37608269bb1e176b5a836b066440f9c52f", size = 489090, upload-time = "2026-02-23T01:55:42.913Z" }, + { url = "https://files.pythonhosted.org/packages/15/3b/462582f0050508f1ce0734f1dffd19078fb013fa12ccf0761c208ab6f756/optree-0.19.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8d523ffc6d3e22851ed25bec806a6c78d68340259e79941059752209b07a75ec", size = 469601, upload-time = "2026-02-23T01:55:44.084Z" }, + { url = "https://files.pythonhosted.org/packages/d6/c6/843c6a33b700ef88407bd5840813e53c6986b6130d94c75c49ff7a2e31f9/optree-0.19.0-cp313-cp313t-manylinux_2_39_riscv64.whl", hash = "sha256:ca148527b6e5d59c25c733e66d4165fbcf85102f4ea10f096370fda533fe77d1", size = 436195, upload-time = "2026-02-23T01:55:45.147Z" }, + { url = "https://files.pythonhosted.org/packages/e3/ed/13f938444de70bec2ff0edef8917a08160d41436a3cad976e541d21747f5/optree-0.19.0-cp313-cp313t-win32.whl", hash = "sha256:40d067cf87e76ad21b8ee2e6ba0347c517c88c2ce7190d666b30b4057e4de5ba", size = 343123, upload-time = "2026-02-23T01:55:46.201Z" }, + { url = "https://files.pythonhosted.org/packages/e1/a2/5074dedbc1be5deca76fe57285ec3e7d5d475922572f92a90f3b3a4f21c5/optree-0.19.0-cp313-cp313t-win_amd64.whl", hash = "sha256:b133e1b9a30ec0bca3f875cfa68c2ce88c0b9e08b21f97f687bb669266411f4a", size = 376560, upload-time = "2026-02-23T01:55:47.58Z" }, + { url = "https://files.pythonhosted.org/packages/49/3a/ea23a29f63d8eadab4e030ebc1329906d44f631076cd1da4751388649960/optree-0.19.0-cp313-cp313t-win_arm64.whl", hash = "sha256:45184b3c73e2147b26b139f34f15c2111cde54b8893b1104a00281c3f283b209", size = 381649, upload-time = "2026-02-23T01:55:48.709Z" }, + { url = "https://files.pythonhosted.org/packages/81/46/643ea3d06c24d351888edfef387e611e550b64a14758169eaeb1d285e658/optree-0.19.0-cp314-cp314-android_24_arm64_v8a.whl", hash = "sha256:adf611b95d3159209c5d1eafcb2eb669733aaf75f9b6754f92d2d8b749192579", size = 921595, upload-time = "2026-02-23T01:55:49.779Z" }, + { url = "https://files.pythonhosted.org/packages/d7/10/8717b93d93fcc3c42a6ee0e0a1a222fe25bc749b32a9e353b039dab836ce/optree-0.19.0-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:bad7bb78baa83f950bb3c59b09d7ca93d30f6bb975a1a7ce8c5f3dfe65fc834d", size = 384552, upload-time = "2026-02-23T01:55:51.244Z" }, + { url = "https://files.pythonhosted.org/packages/a1/5e/8263600ef51ae2decb3e31776c810b8c6b5f8927697046c4434b17346d9d/optree-0.19.0-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:73f122e8acf2f1fd346e9c08f771bc1f7394359793fe632a8e1040733bdbcbec", size = 391280, upload-time = "2026-02-23T01:55:52.681Z" }, + { url = "https://files.pythonhosted.org/packages/04/3c/40774378ebf423d7f074dfd7169f0466eb9de734f0ea5fbb368eddcb1e49/optree-0.19.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:36e426e96b3e1773e879189b12c306b58ae70052efc4087e3f14545701c7ac35", size = 421408, upload-time = "2026-02-23T01:55:54.171Z" }, + { url = "https://files.pythonhosted.org/packages/08/67/2e19866a03a6e75eb62194a5b55e1e3154ca1517478c300232b0229f8c2a/optree-0.19.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:d22b947603be4768c2bd73a59652c94d63465f928b3099e9035f9c48dfc61953", size = 391712, upload-time = "2026-02-23T01:55:55.249Z" }, + { url = "https://files.pythonhosted.org/packages/45/a5/7c059f643bc34c70cc5ebe63c82ae6c33b6b746219f96757d840ea1e2dcd/optree-0.19.0-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:14cc72d0c3a3c0d0b13c66801f2adc6583a01f8499fd151caaa649aabb7f99b9", size = 413471, upload-time = "2026-02-23T01:55:56.371Z" }, + { url = "https://files.pythonhosted.org/packages/67/1a/2c5041cf476fb4b2a27f6644934ac2d079e3e4491f609cba411b3d890291/optree-0.19.0-cp314-cp314-manylinux_2_26_i686.manylinux_2_28_i686.whl", hash = "sha256:5369ac9584ef3fbb703699be694e84dbc78b730bd6d00c48c0c5a588617a1980", size = 477335, upload-time = "2026-02-23T01:55:57.478Z" }, + { url = "https://files.pythonhosted.org/packages/40/a0/abcd7bc3218e1108d253d6783f3e610f0ac3d0e63b2720bff94eb4ed4689/optree-0.19.0-cp314-cp314-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:80b3dca5607f04316a9dcb2bb46df2f04abf4da71731bd4a53a1559c0bee6181", size = 473739, upload-time = "2026-02-23T01:55:58.842Z" }, + { url = "https://files.pythonhosted.org/packages/82/49/7983e66210c78965bc75e386c329ec34854370d337a9ebdc4c8aede3a0b3/optree-0.19.0-cp314-cp314-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:1bb36da9b95b165c7b77fd3ff0af36a30b802cd1c020da3bcdc8aa029991c4ea", size = 475459, upload-time = "2026-02-23T01:55:59.882Z" }, + { url = "https://files.pythonhosted.org/packages/fe/16/00261f20f467b9e8950a76ec1749f01359bf47f2fc3dac5e206de99835c0/optree-0.19.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fb220bb85128c8de71aeffb9c38be817569e4bca413b38d5e0de11ba6471ef4a", size = 456859, upload-time = "2026-02-23T01:56:01.181Z" }, + { url = "https://files.pythonhosted.org/packages/18/31/5e78a451ba9a6ed4b0903b10080dc028e3c9b9c5797cce0ca73990fb5604/optree-0.19.0-cp314-cp314-manylinux_2_39_riscv64.whl", hash = "sha256:5d2b83a37f150f827b8b0bc2c486056f9b2203e7b0bee699d2ee96a36c090f3a", size = 418187, upload-time = "2026-02-23T01:56:02.474Z" }, + { url = "https://files.pythonhosted.org/packages/9c/03/1516cb4fdb753cd76e5dc595217f84df48372bdabe1a7fb740a5b2530f5c/optree-0.19.0-cp314-cp314-win32.whl", hash = "sha256:b0c23d50b7f6a7c80f642307c87eee841cf513239706f2f60bd9480304170054", size = 319744, upload-time = "2026-02-23T01:56:03.493Z" }, + { url = "https://files.pythonhosted.org/packages/7e/c3/587cc9aa8d4742cd690da79460081e7d834499e07e8b2bd2ccc4c66928df/optree-0.19.0-cp314-cp314-win_amd64.whl", hash = "sha256:ff773c852122cef6dcae68b5e252a20aaf5d2986f78e278d747e226e7829d44e", size = 345744, upload-time = "2026-02-23T01:56:04.898Z" }, + { url = "https://files.pythonhosted.org/packages/e6/9b/c17c74ef6b85ad1a2687de8a08d1b56e3a27154b4db6c3ef1e9c2c53a96c/optree-0.19.0-cp314-cp314-win_arm64.whl", hash = "sha256:259ac2a426816d53d576c143b8dca87176af45fc8efd5dfe09db50d74a2fa0a5", size = 355307, upload-time = "2026-02-23T01:56:06.115Z" }, + { url = "https://files.pythonhosted.org/packages/ef/4c/e881fb840cef2cead7582ee36c0e0348e66730cb2a2af1938338c72b1bf3/optree-0.19.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:428fdc8cf5dc43fa32496be6aa84fc0d8f549f899062dd9dd0aa7e3aa7f77ae9", size = 463079, upload-time = "2026-02-23T01:56:07.234Z" }, + { url = "https://files.pythonhosted.org/packages/b6/6b/0a8538815abe28e4307dd98385d4991d36555b841b060df3295a8408b856/optree-0.19.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:d1b497032b5823a09625b118fd4df84199fb0895afb78af536d638ce7645beb6", size = 431401, upload-time = "2026-02-23T01:56:08.336Z" }, + { url = "https://files.pythonhosted.org/packages/71/0c/d70a513fa93dbaa0e3e8c9b218b3805efb7083369cd14e1340bd2c0bc910/optree-0.19.0-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e5f05fecbca17b48451ba3455198cec9db20802c0ffbbba51eaeb421bd846a1c", size = 426111, upload-time = "2026-02-23T01:56:09.376Z" }, + { url = "https://files.pythonhosted.org/packages/77/04/bd30c9f4e694f7b6585f333208ac7894578c1fa30dc5c938f22155df7859/optree-0.19.0-cp314-cp314t-manylinux_2_26_i686.manylinux_2_28_i686.whl", hash = "sha256:a51d0ad4e9dd089f317c94d95b7fa360e87491324e2bfa83d9c4f18dd928d4e1", size = 489872, upload-time = "2026-02-23T01:56:10.538Z" }, + { url = "https://files.pythonhosted.org/packages/e5/17/aba83aa0e8bf31c00cdd3863c2a05854ce414426a69c094ae51210b76677/optree-0.19.0-cp314-cp314t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:108ab83937d91658ef96c4f70a6c76b36038754f4779907ee8f127780575740f", size = 485172, upload-time = "2026-02-23T01:56:11.629Z" }, + { url = "https://files.pythonhosted.org/packages/e0/da/52e684c42dc29d3b4d52f2029545742ef43e151cea112d9093d2ad164f53/optree-0.19.0-cp314-cp314t-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a39fdd614f46bcaf810b2bb1ed940e82b8a19e654bc325df0cc6554e25c3b7eb", size = 484506, upload-time = "2026-02-23T01:56:12.723Z" }, + { url = "https://files.pythonhosted.org/packages/2d/f7/0d41edf484e11ba5357f91dba8d85ce06ca9d840ac7d95e58b856a49b13b/optree-0.19.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bfc1bcba22f182f39f1a80ae3ac511ebfa4daea62c3058edd021ce7a5cda3009", size = 468846, upload-time = "2026-02-23T01:56:13.826Z" }, + { url = "https://files.pythonhosted.org/packages/79/5e/a8f49cfd6c3ae0e59dcb1155cd49f1e5ba41889c9388360264c8369589c6/optree-0.19.0-cp314-cp314t-manylinux_2_39_riscv64.whl", hash = "sha256:afe595a052cc45d3addb6045f04a3ca7e1fb664de032ecbbb2bfd76dfe1fcb61", size = 433899, upload-time = "2026-02-23T01:56:14.889Z" }, + { url = "https://files.pythonhosted.org/packages/9a/1b/4105e562d86b2de7eb3f240164a7dd3948e268878a9ee8925bfe1ad1da4f/optree-0.19.0-cp314-cp314t-win32.whl", hash = "sha256:b15ab972e2133e70570259386684624a17128daab7fb353a0a7435e9dd2c7354", size = 351719, upload-time = "2026-02-23T01:56:15.946Z" }, + { url = "https://files.pythonhosted.org/packages/c4/43/bbc4c7a1f37f1a0ed6efe07a5c44b2835e81d1f6ce1cca6a395a2339e60f/optree-0.19.0-cp314-cp314t-win_amd64.whl", hash = "sha256:c90c15a80c325c2c6e03e20c95350df5db4591d35e8e4a35a40d2f865c260193", size = 391937, upload-time = "2026-02-23T01:56:17.04Z" }, + { url = "https://files.pythonhosted.org/packages/62/12/6758b43dbddc6911e3225a15ca686c913959fb63c267840b54f0002be503/optree-0.19.0-cp314-cp314t-win_arm64.whl", hash = "sha256:a1e7b358df8fc4b97a05380d446e87b08eac899c1f34d9846b9afa0be7f96bc7", size = 389259, upload-time = "2026-02-23T01:56:18.237Z" }, ] [[package]] @@ -335,14 +1564,6 @@ dependencies = [ ] sdist = { url = "https://files.pythonhosted.org/packages/2e/0c/b28ed414f080ee0ad153f848586d61d1878f91689950f037f976ce15f6c8/pandas-3.0.1.tar.gz", hash = "sha256:4186a699674af418f655dbd420ed87f50d56b4cd6603784279d9eef6627823c8", size = 4641901, upload-time = "2026-02-17T22:20:16.434Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/ff/07/c7087e003ceee9b9a82539b40414ec557aa795b584a1a346e89180853d79/pandas-3.0.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:de09668c1bf3b925c07e5762291602f0d789eca1b3a781f99c1c78f6cac0e7ea", size = 10323380, upload-time = "2026-02-17T22:18:16.133Z" }, - { url = "https://files.pythonhosted.org/packages/c1/27/90683c7122febeefe84a56f2cde86a9f05f68d53885cebcc473298dfc33e/pandas-3.0.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:24ba315ba3d6e5806063ac6eb717504e499ce30bd8c236d8693a5fd3f084c796", size = 9923455, upload-time = "2026-02-17T22:18:19.13Z" }, - { url = "https://files.pythonhosted.org/packages/0e/f1/ed17d927f9950643bc7631aa4c99ff0cc83a37864470bc419345b656a41f/pandas-3.0.1-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:406ce835c55bac912f2a0dcfaf27c06d73c6b04a5dde45f1fd3169ce31337389", size = 10753464, upload-time = "2026-02-17T22:18:21.134Z" }, - { url = "https://files.pythonhosted.org/packages/2e/7c/870c7e7daec2a6c7ff2ac9e33b23317230d4e4e954b35112759ea4a924a7/pandas-3.0.1-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:830994d7e1f31dd7e790045235605ab61cff6c94defc774547e8b7fdfbff3dc7", size = 11255234, upload-time = "2026-02-17T22:18:24.175Z" }, - { url = "https://files.pythonhosted.org/packages/5c/39/3653fe59af68606282b989c23d1a543ceba6e8099cbcc5f1d506a7bae2aa/pandas-3.0.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:a64ce8b0f2de1d2efd2ae40b0abe7f8ae6b29fbfb3812098ed5a6f8e235ad9bf", size = 11767299, upload-time = "2026-02-17T22:18:26.824Z" }, - { url = "https://files.pythonhosted.org/packages/9b/31/1daf3c0c94a849c7a8dab8a69697b36d313b229918002ba3e409265c7888/pandas-3.0.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9832c2c69da24b602c32e0c7b1b508a03949c18ba08d4d9f1c1033426685b447", size = 12333292, upload-time = "2026-02-17T22:18:28.996Z" }, - { url = "https://files.pythonhosted.org/packages/1f/67/af63f83cd6ca603a00fe8530c10a60f0879265b8be00b5930e8e78c5b30b/pandas-3.0.1-cp311-cp311-win_amd64.whl", hash = "sha256:84f0904a69e7365f79a0c77d3cdfccbfb05bf87847e3a51a41e1426b0edb9c79", size = 9892176, upload-time = "2026-02-17T22:18:31.79Z" }, - { url = "https://files.pythonhosted.org/packages/79/ab/9c776b14ac4b7b4140788eca18468ea39894bc7340a408f1d1e379856a6b/pandas-3.0.1-cp311-cp311-win_arm64.whl", hash = "sha256:4a68773d5a778afb31d12e34f7dd4612ab90de8c6fb1d8ffe5d4a03b955082a1", size = 9151328, upload-time = "2026-02-17T22:18:35.721Z" }, { url = "https://files.pythonhosted.org/packages/37/51/b467209c08dae2c624873d7491ea47d2b47336e5403309d433ea79c38571/pandas-3.0.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:476f84f8c20c9f5bc47252b66b4bb25e1a9fc2fa98cead96744d8116cb85771d", size = 10344357, upload-time = "2026-02-17T22:18:38.262Z" }, { url = "https://files.pythonhosted.org/packages/7c/f1/e2567ffc8951ab371db2e40b2fe068e36b81d8cf3260f06ae508700e5504/pandas-3.0.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0ab749dfba921edf641d4036c4c21c0b3ea70fea478165cb98a998fb2a261955", size = 9884543, upload-time = "2026-02-17T22:18:41.476Z" }, { url = "https://files.pythonhosted.org/packages/d7/39/327802e0b6d693182403c144edacbc27eb82907b57062f23ef5a4c4a5ea7/pandas-3.0.1-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b8e36891080b87823aff3640c78649b91b8ff6eea3c0d70aeabd72ea43ab069b", size = 10396030, upload-time = "2026-02-17T22:18:43.822Z" }, @@ -351,6 +1572,58 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/58/53/1d68fafb2e02d7881df66aa53be4cd748d25cbe311f3b3c85c93ea5d30ca/pandas-3.0.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:9d810036895f9ad6345b8f2a338dd6998a74e8483847403582cab67745bff821", size = 11932065, upload-time = "2026-02-17T22:18:50.837Z" }, { url = "https://files.pythonhosted.org/packages/75/08/67cc404b3a966b6df27b38370ddd96b3b023030b572283d035181854aac5/pandas-3.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:536232a5fe26dd989bd633e7a0c450705fdc86a207fec7254a55e9a22950fe43", size = 9741627, upload-time = "2026-02-17T22:18:53.905Z" }, { url = "https://files.pythonhosted.org/packages/86/4f/caf9952948fb00d23795f09b893d11f1cacb384e666854d87249530f7cbe/pandas-3.0.1-cp312-cp312-win_arm64.whl", hash = "sha256:0f463ebfd8de7f326d38037c7363c6dacb857c5881ab8961fb387804d6daf2f7", size = 9052483, upload-time = "2026-02-17T22:18:57.31Z" }, + { url = "https://files.pythonhosted.org/packages/0b/48/aad6ec4f8d007534c091e9a7172b3ec1b1ee6d99a9cbb936b5eab6c6cf58/pandas-3.0.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5272627187b5d9c20e55d27caf5f2cd23e286aba25cadf73c8590e432e2b7262", size = 10317509, upload-time = "2026-02-17T22:18:59.498Z" }, + { url = "https://files.pythonhosted.org/packages/a8/14/5990826f779f79148ae9d3a2c39593dc04d61d5d90541e71b5749f35af95/pandas-3.0.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:661e0f665932af88c7877f31da0dc743fe9c8f2524bdffe23d24fdcb67ef9d56", size = 9860561, upload-time = "2026-02-17T22:19:02.265Z" }, + { url = "https://files.pythonhosted.org/packages/fa/80/f01ff54664b6d70fed71475543d108a9b7c888e923ad210795bef04ffb7d/pandas-3.0.1-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:75e6e292ff898679e47a2199172593d9f6107fd2dd3617c22c2946e97d5df46e", size = 10365506, upload-time = "2026-02-17T22:19:05.017Z" }, + { url = "https://files.pythonhosted.org/packages/f2/85/ab6d04733a7d6ff32bfc8382bf1b07078228f5d6ebec5266b91bfc5c4ff7/pandas-3.0.1-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1ff8cf1d2896e34343197685f432450ec99a85ba8d90cce2030c5eee2ef98791", size = 10873196, upload-time = "2026-02-17T22:19:07.204Z" }, + { url = "https://files.pythonhosted.org/packages/48/a9/9301c83d0b47c23ac5deab91c6b39fd98d5b5db4d93b25df8d381451828f/pandas-3.0.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:eca8b4510f6763f3d37359c2105df03a7a221a508f30e396a51d0713d462e68a", size = 11370859, upload-time = "2026-02-17T22:19:09.436Z" }, + { url = "https://files.pythonhosted.org/packages/59/fe/0c1fc5bd2d29c7db2ab372330063ad555fb83e08422829c785f5ec2176ca/pandas-3.0.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:06aff2ad6f0b94a17822cf8b83bbb563b090ed82ff4fe7712db2ce57cd50d9b8", size = 11924584, upload-time = "2026-02-17T22:19:11.562Z" }, + { url = "https://files.pythonhosted.org/packages/d6/7d/216a1588b65a7aa5f4535570418a599d943c85afb1d95b0876fc00aa1468/pandas-3.0.1-cp313-cp313-win_amd64.whl", hash = "sha256:9fea306c783e28884c29057a1d9baa11a349bbf99538ec1da44c8476563d1b25", size = 9742769, upload-time = "2026-02-17T22:19:13.926Z" }, + { url = "https://files.pythonhosted.org/packages/c4/cb/810a22a6af9a4e97c8ab1c946b47f3489c5bca5adc483ce0ffc84c9cc768/pandas-3.0.1-cp313-cp313-win_arm64.whl", hash = "sha256:a8d37a43c52917427e897cb2e429f67a449327394396a81034a4449b99afda59", size = 9043855, upload-time = "2026-02-17T22:19:16.09Z" }, + { url = "https://files.pythonhosted.org/packages/92/fa/423c89086cca1f039cf1253c3ff5b90f157b5b3757314aa635f6bf3e30aa/pandas-3.0.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:d54855f04f8246ed7b6fc96b05d4871591143c46c0b6f4af874764ed0d2d6f06", size = 10752673, upload-time = "2026-02-17T22:19:18.304Z" }, + { url = "https://files.pythonhosted.org/packages/22/23/b5a08ec1f40020397f0faba72f1e2c11f7596a6169c7b3e800abff0e433f/pandas-3.0.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:4e1b677accee34a09e0dc2ce5624e4a58a1870ffe56fc021e9caf7f23cd7668f", size = 10404967, upload-time = "2026-02-17T22:19:20.726Z" }, + { url = "https://files.pythonhosted.org/packages/5c/81/94841f1bb4afdc2b52a99daa895ac2c61600bb72e26525ecc9543d453ebc/pandas-3.0.1-cp313-cp313t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a9cabbdcd03f1b6cd254d6dda8ae09b0252524be1592594c00b7895916cb1324", size = 10320575, upload-time = "2026-02-17T22:19:24.919Z" }, + { url = "https://files.pythonhosted.org/packages/0a/8b/2ae37d66a5342a83adadfd0cb0b4bf9c3c7925424dd5f40d15d6cfaa35ee/pandas-3.0.1-cp313-cp313t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5ae2ab1f166668b41e770650101e7090824fd34d17915dd9cd479f5c5e0065e9", size = 10710921, upload-time = "2026-02-17T22:19:27.181Z" }, + { url = "https://files.pythonhosted.org/packages/a2/61/772b2e2757855e232b7ccf7cb8079a5711becb3a97f291c953def15a833f/pandas-3.0.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:6bf0603c2e30e2cafac32807b06435f28741135cb8697eae8b28c7d492fc7d76", size = 11334191, upload-time = "2026-02-17T22:19:29.411Z" }, + { url = "https://files.pythonhosted.org/packages/1b/08/b16c6df3ef555d8495d1d265a7963b65be166785d28f06a350913a4fac78/pandas-3.0.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6c426422973973cae1f4a23e51d4ae85974f44871b24844e4f7de752dd877098", size = 11782256, upload-time = "2026-02-17T22:19:32.34Z" }, + { url = "https://files.pythonhosted.org/packages/55/80/178af0594890dee17e239fca96d3d8670ba0f5ff59b7d0439850924a9c09/pandas-3.0.1-cp313-cp313t-win_amd64.whl", hash = "sha256:b03f91ae8c10a85c1613102c7bef5229b5379f343030a3ccefeca8a33414cf35", size = 10485047, upload-time = "2026-02-17T22:19:34.605Z" }, + { url = "https://files.pythonhosted.org/packages/bb/8b/4bb774a998b97e6c2fd62a9e6cfdaae133b636fd1c468f92afb4ae9a447a/pandas-3.0.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:99d0f92ed92d3083d140bf6b97774f9f13863924cf3f52a70711f4e7588f9d0a", size = 10322465, upload-time = "2026-02-17T22:19:36.803Z" }, + { url = "https://files.pythonhosted.org/packages/72/3a/5b39b51c64159f470f1ca3b1c2a87da290657ca022f7cd11442606f607d1/pandas-3.0.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:3b66857e983208654294bb6477b8a63dee26b37bdd0eb34d010556e91261784f", size = 9910632, upload-time = "2026-02-17T22:19:39.001Z" }, + { url = "https://files.pythonhosted.org/packages/4e/f7/b449ffb3f68c11da12fc06fbf6d2fa3a41c41e17d0284d23a79e1c13a7e4/pandas-3.0.1-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:56cf59638bf24dc9bdf2154c81e248b3289f9a09a6d04e63608c159022352749", size = 10440535, upload-time = "2026-02-17T22:19:41.157Z" }, + { url = "https://files.pythonhosted.org/packages/55/77/6ea82043db22cb0f2bbfe7198da3544000ddaadb12d26be36e19b03a2dc5/pandas-3.0.1-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c1a9f55e0f46951874b863d1f3906dcb57df2d9be5c5847ba4dfb55b2c815249", size = 10893940, upload-time = "2026-02-17T22:19:43.493Z" }, + { url = "https://files.pythonhosted.org/packages/03/30/f1b502a72468c89412c1b882a08f6eed8a4ee9dc033f35f65d0663df6081/pandas-3.0.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:1849f0bba9c8a2fb0f691d492b834cc8dadf617e29015c66e989448d58d011ee", size = 11442711, upload-time = "2026-02-17T22:19:46.074Z" }, + { url = "https://files.pythonhosted.org/packages/0d/f0/ebb6ddd8fc049e98cabac5c2924d14d1dda26a20adb70d41ea2e428d3ec4/pandas-3.0.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:c3d288439e11b5325b02ae6e9cc83e6805a62c40c5a6220bea9beb899c073b1c", size = 11963918, upload-time = "2026-02-17T22:19:48.838Z" }, + { url = "https://files.pythonhosted.org/packages/09/f8/8ce132104074f977f907442790eaae24e27bce3b3b454e82faa3237ff098/pandas-3.0.1-cp314-cp314-win_amd64.whl", hash = "sha256:93325b0fe372d192965f4cca88d97667f49557398bbf94abdda3bf1b591dbe66", size = 9862099, upload-time = "2026-02-17T22:19:51.081Z" }, + { url = "https://files.pythonhosted.org/packages/e6/b7/6af9aac41ef2456b768ef0ae60acf8abcebb450a52043d030a65b4b7c9bd/pandas-3.0.1-cp314-cp314-win_arm64.whl", hash = "sha256:97ca08674e3287c7148f4858b01136f8bdfe7202ad25ad04fec602dd1d29d132", size = 9185333, upload-time = "2026-02-17T22:19:53.266Z" }, + { url = "https://files.pythonhosted.org/packages/66/fc/848bb6710bc6061cb0c5badd65b92ff75c81302e0e31e496d00029fe4953/pandas-3.0.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:58eeb1b2e0fb322befcf2bbc9ba0af41e616abadb3d3414a6bc7167f6cbfce32", size = 10772664, upload-time = "2026-02-17T22:19:55.806Z" }, + { url = "https://files.pythonhosted.org/packages/69/5c/866a9bbd0f79263b4b0db6ec1a341be13a1473323f05c122388e0f15b21d/pandas-3.0.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:cd9af1276b5ca9e298bd79a26bda32fa9cc87ed095b2a9a60978d2ca058eaf87", size = 10421286, upload-time = "2026-02-17T22:19:58.091Z" }, + { url = "https://files.pythonhosted.org/packages/51/a4/2058fb84fb1cfbfb2d4a6d485e1940bb4ad5716e539d779852494479c580/pandas-3.0.1-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:94f87a04984d6b63788327cd9f79dda62b7f9043909d2440ceccf709249ca988", size = 10342050, upload-time = "2026-02-17T22:20:01.376Z" }, + { url = "https://files.pythonhosted.org/packages/22/1b/674e89996cc4be74db3c4eb09240c4bb549865c9c3f5d9b086ff8fcfbf00/pandas-3.0.1-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:85fe4c4df62e1e20f9db6ebfb88c844b092c22cd5324bdcf94bfa2fc1b391221", size = 10740055, upload-time = "2026-02-17T22:20:04.328Z" }, + { url = "https://files.pythonhosted.org/packages/d0/f8/e954b750764298c22fa4614376531fe63c521ef517e7059a51f062b87dca/pandas-3.0.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:331ca75a2f8672c365ae25c0b29e46f5ac0c6551fdace8eec4cd65e4fac271ff", size = 11357632, upload-time = "2026-02-17T22:20:06.647Z" }, + { url = "https://files.pythonhosted.org/packages/6d/02/c6e04b694ffd68568297abd03588b6d30295265176a5c01b7459d3bc35a3/pandas-3.0.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:15860b1fdb1973fffade772fdb931ccf9b2f400a3f5665aef94a00445d7d8dd5", size = 11810974, upload-time = "2026-02-17T22:20:08.946Z" }, + { url = "https://files.pythonhosted.org/packages/89/41/d7dfb63d2407f12055215070c42fc6ac41b66e90a2946cdc5e759058398b/pandas-3.0.1-cp314-cp314t-win_amd64.whl", hash = "sha256:44f1364411d5670efa692b146c748f4ed013df91ee91e9bec5677fb1fd58b937", size = 10884622, upload-time = "2026-02-17T22:20:11.711Z" }, + { url = "https://files.pythonhosted.org/packages/68/b0/34937815889fa982613775e4b97fddd13250f11012d769949c5465af2150/pandas-3.0.1-cp314-cp314t-win_arm64.whl", hash = "sha256:108dd1790337a494aa80e38def654ca3f0968cf4f362c85f44c15e471667102d", size = 9452085, upload-time = "2026-02-17T22:20:14.331Z" }, +] + +[[package]] +name = "parso" +version = "0.8.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/81/76/a1e769043c0c0c9fe391b702539d594731a4362334cdf4dc25d0c09761e7/parso-0.8.6.tar.gz", hash = "sha256:2b9a0332696df97d454fa67b81618fd69c35a7b90327cbe6ba5c92d2c68a7bfd", size = 401621, upload-time = "2026-02-09T15:45:24.425Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b6/61/fae042894f4296ec49e3f193aff5d7c18440da9e48102c3315e1bc4519a7/parso-0.8.6-py2.py3-none-any.whl", hash = "sha256:2c549f800b70a5c4952197248825584cb00f033b29c692671d3bf08bf380baff", size = 106894, upload-time = "2026-02-09T15:45:21.391Z" }, +] + +[[package]] +name = "pexpect" +version = "4.9.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ptyprocess", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/42/92/cc564bf6381ff43ce1f4d06852fc19a2f11d180f23dc32d9588bee2f149d/pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f", size = 166450, upload-time = "2023-11-25T09:07:26.339Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9e/c3/059298687310d527a58bb01f3b1965787ee3b40dce76752eda8b44e9a2c5/pexpect-4.9.0-py2.py3-none-any.whl", hash = "sha256:7236d1e080e4936be2dc3e326cec0af72acf9212a7e1d060210e70a47e253523", size = 63772, upload-time = "2023-11-25T06:56:14.81Z" }, ] [[package]] @@ -359,17 +1632,6 @@ version = "12.1.1" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/1f/42/5c74462b4fd957fcd7b13b04fb3205ff8349236ea74c7c375766d6c82288/pillow-12.1.1.tar.gz", hash = "sha256:9ad8fa5937ab05218e2b6a4cff30295ad35afd2f83ac592e68c0d871bb0fdbc4", size = 46980264, upload-time = "2026-02-11T04:23:07.146Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/2b/46/5da1ec4a5171ee7bf1a0efa064aba70ba3d6e0788ce3f5acd1375d23c8c0/pillow-12.1.1-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:e879bb6cd5c73848ef3b2b48b8af9ff08c5b71ecda8048b7dd22d8a33f60be32", size = 5304084, upload-time = "2026-02-11T04:20:27.501Z" }, - { url = "https://files.pythonhosted.org/packages/78/93/a29e9bc02d1cf557a834da780ceccd54e02421627200696fcf805ebdc3fb/pillow-12.1.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:365b10bb9417dd4498c0e3b128018c4a624dc11c7b97d8cc54effe3b096f4c38", size = 4657866, upload-time = "2026-02-11T04:20:29.827Z" }, - { url = "https://files.pythonhosted.org/packages/13/84/583a4558d492a179d31e4aae32eadce94b9acf49c0337c4ce0b70e0a01f2/pillow-12.1.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d4ce8e329c93845720cd2014659ca67eac35f6433fd3050393d85f3ecef0dad5", size = 6232148, upload-time = "2026-02-11T04:20:31.329Z" }, - { url = "https://files.pythonhosted.org/packages/d5/e2/53c43334bbbb2d3b938978532fbda8e62bb6e0b23a26ce8592f36bcc4987/pillow-12.1.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fc354a04072b765eccf2204f588a7a532c9511e8b9c7f900e1b64e3e33487090", size = 8038007, upload-time = "2026-02-11T04:20:34.225Z" }, - { url = "https://files.pythonhosted.org/packages/b8/a6/3d0e79c8a9d58150dd98e199d7c1c56861027f3829a3a60b3c2784190180/pillow-12.1.1-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7e7976bf1910a8116b523b9f9f58bf410f3e8aa330cd9a2bb2953f9266ab49af", size = 6345418, upload-time = "2026-02-11T04:20:35.858Z" }, - { url = "https://files.pythonhosted.org/packages/a2/c8/46dfeac5825e600579157eea177be43e2f7ff4a99da9d0d0a49533509ac5/pillow-12.1.1-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:597bd9c8419bc7c6af5604e55847789b69123bbe25d65cc6ad3012b4f3c98d8b", size = 7034590, upload-time = "2026-02-11T04:20:37.91Z" }, - { url = "https://files.pythonhosted.org/packages/af/bf/e6f65d3db8a8bbfeaf9e13cc0417813f6319863a73de934f14b2229ada18/pillow-12.1.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:2c1fc0f2ca5f96a3c8407e41cca26a16e46b21060fe6d5b099d2cb01412222f5", size = 6458655, upload-time = "2026-02-11T04:20:39.496Z" }, - { url = "https://files.pythonhosted.org/packages/f9/c2/66091f3f34a25894ca129362e510b956ef26f8fb67a0e6417bc5744e56f1/pillow-12.1.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:578510d88c6229d735855e1f278aa305270438d36a05031dfaae5067cc8eb04d", size = 7159286, upload-time = "2026-02-11T04:20:41.139Z" }, - { url = "https://files.pythonhosted.org/packages/7b/5a/24bc8eb526a22f957d0cec6243146744966d40857e3d8deb68f7902ca6c1/pillow-12.1.1-cp311-cp311-win32.whl", hash = "sha256:7311c0a0dcadb89b36b7025dfd8326ecfa36964e29913074d47382706e516a7c", size = 6328663, upload-time = "2026-02-11T04:20:43.184Z" }, - { url = "https://files.pythonhosted.org/packages/31/03/bef822e4f2d8f9d7448c133d0a18185d3cce3e70472774fffefe8b0ed562/pillow-12.1.1-cp311-cp311-win_amd64.whl", hash = "sha256:fbfa2a7c10cc2623f412753cddf391c7f971c52ca40a3f65dc5039b2939e8563", size = 7031448, upload-time = "2026-02-11T04:20:44.696Z" }, - { url = "https://files.pythonhosted.org/packages/49/70/f76296f53610bd17b2e7d31728b8b7825e3ac3b5b3688b51f52eab7c0818/pillow-12.1.1-cp311-cp311-win_arm64.whl", hash = "sha256:b81b5e3511211631b3f672a595e3221252c90af017e399056d0faabb9538aa80", size = 2453651, upload-time = "2026-02-11T04:20:46.243Z" }, { url = "https://files.pythonhosted.org/packages/07/d3/8df65da0d4df36b094351dce696f2989bec731d4f10e743b1c5f4da4d3bf/pillow-12.1.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:ab323b787d6e18b3d91a72fc99b1a2c28651e4358749842b8f8dfacd28ef2052", size = 5262803, upload-time = "2026-02-11T04:20:47.653Z" }, { url = "https://files.pythonhosted.org/packages/d6/71/5026395b290ff404b836e636f51d7297e6c83beceaa87c592718747e670f/pillow-12.1.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:adebb5bee0f0af4909c30db0d890c773d1a92ffe83da908e2e9e720f8edf3984", size = 4657601, upload-time = "2026-02-11T04:20:49.328Z" }, { url = "https://files.pythonhosted.org/packages/b1/2e/1001613d941c67442f745aff0f7cc66dd8df9a9c084eb497e6a543ee6f7e/pillow-12.1.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:bb66b7cc26f50977108790e2456b7921e773f23db5630261102233eb355a3b79", size = 6234995, upload-time = "2026-02-11T04:20:51.032Z" }, @@ -381,13 +1643,65 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/1f/e7/7c4552d80052337eb28653b617eafdef39adfb137c49dd7e831b8dc13bc5/pillow-12.1.1-cp312-cp312-win32.whl", hash = "sha256:5d1f9575a12bed9e9eedd9a4972834b08c97a352bd17955ccdebfeca5913fa0a", size = 6328823, upload-time = "2026-02-11T04:21:01.385Z" }, { url = "https://files.pythonhosted.org/packages/3d/17/688626d192d7261bbbf98846fc98995726bddc2c945344b65bec3a29d731/pillow-12.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:21329ec8c96c6e979cd0dfd29406c40c1d52521a90544463057d2aaa937d66a6", size = 7033367, upload-time = "2026-02-11T04:21:03.536Z" }, { url = "https://files.pythonhosted.org/packages/ed/fe/a0ef1f73f939b0eca03ee2c108d0043a87468664770612602c63266a43c4/pillow-12.1.1-cp312-cp312-win_arm64.whl", hash = "sha256:af9a332e572978f0218686636610555ae3defd1633597be015ed50289a03c523", size = 2453811, upload-time = "2026-02-11T04:21:05.116Z" }, - { url = "https://files.pythonhosted.org/packages/56/11/5d43209aa4cb58e0cc80127956ff1796a68b928e6324bbf06ef4db34367b/pillow-12.1.1-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:600fd103672b925fe62ed08e0d874ea34d692474df6f4bf7ebe148b30f89f39f", size = 5228606, upload-time = "2026-02-11T04:22:52.106Z" }, - { url = "https://files.pythonhosted.org/packages/5f/d5/3b005b4e4fda6698b371fa6c21b097d4707585d7db99e98d9b0b87ac612a/pillow-12.1.1-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:665e1b916b043cef294bc54d47bf02d87e13f769bc4bc5fa225a24b3a6c5aca9", size = 4622321, upload-time = "2026-02-11T04:22:53.827Z" }, - { url = "https://files.pythonhosted.org/packages/df/36/ed3ea2d594356fd8037e5a01f6156c74bc8d92dbb0fa60746cc96cabb6e8/pillow-12.1.1-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:495c302af3aad1ca67420ddd5c7bd480c8867ad173528767d906428057a11f0e", size = 5247579, upload-time = "2026-02-11T04:22:56.094Z" }, - { url = "https://files.pythonhosted.org/packages/54/9a/9cc3e029683cf6d20ae5085da0dafc63148e3252c2f13328e553aaa13cfb/pillow-12.1.1-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8fd420ef0c52c88b5a035a0886f367748c72147b2b8f384c9d12656678dfdfa9", size = 6989094, upload-time = "2026-02-11T04:22:58.288Z" }, - { url = "https://files.pythonhosted.org/packages/00/98/fc53ab36da80b88df0967896b6c4b4cd948a0dc5aa40a754266aa3ae48b3/pillow-12.1.1-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f975aa7ef9684ce7e2c18a3aa8f8e2106ce1e46b94ab713d156b2898811651d3", size = 5313850, upload-time = "2026-02-11T04:23:00.554Z" }, - { url = "https://files.pythonhosted.org/packages/30/02/00fa585abfd9fe9d73e5f6e554dc36cc2b842898cbfc46d70353dae227f8/pillow-12.1.1-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8089c852a56c2966cf18835db62d9b34fef7ba74c726ad943928d494fa7f4735", size = 5963343, upload-time = "2026-02-11T04:23:02.934Z" }, - { url = "https://files.pythonhosted.org/packages/f2/26/c56ce33ca856e358d27fda9676c055395abddb82c35ac0f593877ed4562e/pillow-12.1.1-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:cb9bb857b2d057c6dfc72ac5f3b44836924ba15721882ef103cecb40d002d80e", size = 7029880, upload-time = "2026-02-11T04:23:04.783Z" }, + { url = "https://files.pythonhosted.org/packages/d5/11/6db24d4bd7685583caeae54b7009584e38da3c3d4488ed4cd25b439de486/pillow-12.1.1-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:d242e8ac078781f1de88bf823d70c1a9b3c7950a44cdf4b7c012e22ccbcd8e4e", size = 4062689, upload-time = "2026-02-11T04:21:06.804Z" }, + { url = "https://files.pythonhosted.org/packages/33/c0/ce6d3b1fe190f0021203e0d9b5b99e57843e345f15f9ef22fcd43842fd21/pillow-12.1.1-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:02f84dfad02693676692746df05b89cf25597560db2857363a208e393429f5e9", size = 4138535, upload-time = "2026-02-11T04:21:08.452Z" }, + { url = "https://files.pythonhosted.org/packages/a0/c6/d5eb6a4fb32a3f9c21a8c7613ec706534ea1cf9f4b3663e99f0d83f6fca8/pillow-12.1.1-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:e65498daf4b583091ccbb2556c7000abf0f3349fcd57ef7adc9a84a394ed29f6", size = 3601364, upload-time = "2026-02-11T04:21:10.194Z" }, + { url = "https://files.pythonhosted.org/packages/14/a1/16c4b823838ba4c9c52c0e6bbda903a3fe5a1bdbf1b8eb4fff7156f3e318/pillow-12.1.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:6c6db3b84c87d48d0088943bf33440e0c42370b99b1c2a7989216f7b42eede60", size = 5262561, upload-time = "2026-02-11T04:21:11.742Z" }, + { url = "https://files.pythonhosted.org/packages/bb/ad/ad9dc98ff24f485008aa5cdedaf1a219876f6f6c42a4626c08bc4e80b120/pillow-12.1.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:8b7e5304e34942bf62e15184219a7b5ad4ff7f3bb5cca4d984f37df1a0e1aee2", size = 4657460, upload-time = "2026-02-11T04:21:13.786Z" }, + { url = "https://files.pythonhosted.org/packages/9e/1b/f1a4ea9a895b5732152789326202a82464d5254759fbacae4deea3069334/pillow-12.1.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:18e5bddd742a44b7e6b1e773ab5db102bd7a94c32555ba656e76d319d19c3850", size = 6232698, upload-time = "2026-02-11T04:21:15.949Z" }, + { url = "https://files.pythonhosted.org/packages/95/f4/86f51b8745070daf21fd2e5b1fe0eb35d4db9ca26e6d58366562fb56a743/pillow-12.1.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fc44ef1f3de4f45b50ccf9136999d71abb99dca7706bc75d222ed350b9fd2289", size = 8041706, upload-time = "2026-02-11T04:21:17.723Z" }, + { url = "https://files.pythonhosted.org/packages/29/9b/d6ecd956bb1266dd1045e995cce9b8d77759e740953a1c9aad9502a0461e/pillow-12.1.1-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5a8eb7ed8d4198bccbd07058416eeec51686b498e784eda166395a23eb99138e", size = 6346621, upload-time = "2026-02-11T04:21:19.547Z" }, + { url = "https://files.pythonhosted.org/packages/71/24/538bff45bde96535d7d998c6fed1a751c75ac7c53c37c90dc2601b243893/pillow-12.1.1-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:47b94983da0c642de92ced1702c5b6c292a84bd3a8e1d1702ff923f183594717", size = 7038069, upload-time = "2026-02-11T04:21:21.378Z" }, + { url = "https://files.pythonhosted.org/packages/94/0e/58cb1a6bc48f746bc4cb3adb8cabff73e2742c92b3bf7a220b7cf69b9177/pillow-12.1.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:518a48c2aab7ce596d3bf79d0e275661b846e86e4d0e7dec34712c30fe07f02a", size = 6460040, upload-time = "2026-02-11T04:21:23.148Z" }, + { url = "https://files.pythonhosted.org/packages/6c/57/9045cb3ff11eeb6c1adce3b2d60d7d299d7b273a2e6c8381a524abfdc474/pillow-12.1.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a550ae29b95c6dc13cf69e2c9dc5747f814c54eeb2e32d683e5e93af56caa029", size = 7164523, upload-time = "2026-02-11T04:21:25.01Z" }, + { url = "https://files.pythonhosted.org/packages/73/f2/9be9cb99f2175f0d4dbadd6616ce1bf068ee54a28277ea1bf1fbf729c250/pillow-12.1.1-cp313-cp313-win32.whl", hash = "sha256:a003d7422449f6d1e3a34e3dd4110c22148336918ddbfc6a32581cd54b2e0b2b", size = 6332552, upload-time = "2026-02-11T04:21:27.238Z" }, + { url = "https://files.pythonhosted.org/packages/3f/eb/b0834ad8b583d7d9d42b80becff092082a1c3c156bb582590fcc973f1c7c/pillow-12.1.1-cp313-cp313-win_amd64.whl", hash = "sha256:344cf1e3dab3be4b1fa08e449323d98a2a3f819ad20f4b22e77a0ede31f0faa1", size = 7040108, upload-time = "2026-02-11T04:21:29.462Z" }, + { url = "https://files.pythonhosted.org/packages/d5/7d/fc09634e2aabdd0feabaff4a32f4a7d97789223e7c2042fd805ea4b4d2c2/pillow-12.1.1-cp313-cp313-win_arm64.whl", hash = "sha256:5c0dd1636633e7e6a0afe7bf6a51a14992b7f8e60de5789018ebbdfae55b040a", size = 2453712, upload-time = "2026-02-11T04:21:31.072Z" }, + { url = "https://files.pythonhosted.org/packages/19/2a/b9d62794fc8a0dd14c1943df68347badbd5511103e0d04c035ffe5cf2255/pillow-12.1.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0330d233c1a0ead844fc097a7d16c0abff4c12e856c0b325f231820fee1f39da", size = 5264880, upload-time = "2026-02-11T04:21:32.865Z" }, + { url = "https://files.pythonhosted.org/packages/26/9d/e03d857d1347fa5ed9247e123fcd2a97b6220e15e9cb73ca0a8d91702c6e/pillow-12.1.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:5dae5f21afb91322f2ff791895ddd8889e5e947ff59f71b46041c8ce6db790bc", size = 4660616, upload-time = "2026-02-11T04:21:34.97Z" }, + { url = "https://files.pythonhosted.org/packages/f7/ec/8a6d22afd02570d30954e043f09c32772bfe143ba9285e2fdb11284952cd/pillow-12.1.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:2e0c664be47252947d870ac0d327fea7e63985a08794758aa8af5b6cb6ec0c9c", size = 6269008, upload-time = "2026-02-11T04:21:36.623Z" }, + { url = "https://files.pythonhosted.org/packages/3d/1d/6d875422c9f28a4a361f495a5f68d9de4a66941dc2c619103ca335fa6446/pillow-12.1.1-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:691ab2ac363b8217f7d31b3497108fb1f50faab2f75dfb03284ec2f217e87bf8", size = 8073226, upload-time = "2026-02-11T04:21:38.585Z" }, + { url = "https://files.pythonhosted.org/packages/a1/cd/134b0b6ee5eda6dc09e25e24b40fdafe11a520bc725c1d0bbaa5e00bf95b/pillow-12.1.1-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e9e8064fb1cc019296958595f6db671fba95209e3ceb0c4734c9baf97de04b20", size = 6380136, upload-time = "2026-02-11T04:21:40.562Z" }, + { url = "https://files.pythonhosted.org/packages/7a/a9/7628f013f18f001c1b98d8fffe3452f306a70dc6aba7d931019e0492f45e/pillow-12.1.1-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:472a8d7ded663e6162dafdf20015c486a7009483ca671cece7a9279b512fcb13", size = 7067129, upload-time = "2026-02-11T04:21:42.521Z" }, + { url = "https://files.pythonhosted.org/packages/1e/f8/66ab30a2193b277785601e82ee2d49f68ea575d9637e5e234faaa98efa4c/pillow-12.1.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:89b54027a766529136a06cfebeecb3a04900397a3590fd252160b888479517bf", size = 6491807, upload-time = "2026-02-11T04:21:44.22Z" }, + { url = "https://files.pythonhosted.org/packages/da/0b/a877a6627dc8318fdb84e357c5e1a758c0941ab1ddffdafd231983788579/pillow-12.1.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:86172b0831b82ce4f7877f280055892b31179e1576aa00d0df3bb1bbf8c3e524", size = 7190954, upload-time = "2026-02-11T04:21:46.114Z" }, + { url = "https://files.pythonhosted.org/packages/83/43/6f732ff85743cf746b1361b91665d9f5155e1483817f693f8d57ea93147f/pillow-12.1.1-cp313-cp313t-win32.whl", hash = "sha256:44ce27545b6efcf0fdbdceb31c9a5bdea9333e664cda58a7e674bb74608b3986", size = 6336441, upload-time = "2026-02-11T04:21:48.22Z" }, + { url = "https://files.pythonhosted.org/packages/3b/44/e865ef3986611bb75bfabdf94a590016ea327833f434558801122979cd0e/pillow-12.1.1-cp313-cp313t-win_amd64.whl", hash = "sha256:a285e3eb7a5a45a2ff504e31f4a8d1b12ef62e84e5411c6804a42197c1cf586c", size = 7045383, upload-time = "2026-02-11T04:21:50.015Z" }, + { url = "https://files.pythonhosted.org/packages/a8/c6/f4fb24268d0c6908b9f04143697ea18b0379490cb74ba9e8d41b898bd005/pillow-12.1.1-cp313-cp313t-win_arm64.whl", hash = "sha256:cc7d296b5ea4d29e6570dabeaed58d31c3fea35a633a69679fb03d7664f43fb3", size = 2456104, upload-time = "2026-02-11T04:21:51.633Z" }, + { url = "https://files.pythonhosted.org/packages/03/d0/bebb3ffbf31c5a8e97241476c4cf8b9828954693ce6744b4a2326af3e16b/pillow-12.1.1-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:417423db963cb4be8bac3fc1204fe61610f6abeed1580a7a2cbb2fbda20f12af", size = 4062652, upload-time = "2026-02-11T04:21:53.19Z" }, + { url = "https://files.pythonhosted.org/packages/2d/c0/0e16fb0addda4851445c28f8350d8c512f09de27bbb0d6d0bbf8b6709605/pillow-12.1.1-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:b957b71c6b2387610f556a7eb0828afbe40b4a98036fc0d2acfa5a44a0c2036f", size = 4138823, upload-time = "2026-02-11T04:22:03.088Z" }, + { url = "https://files.pythonhosted.org/packages/6b/fb/6170ec655d6f6bb6630a013dd7cf7bc218423d7b5fa9071bf63dc32175ae/pillow-12.1.1-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:097690ba1f2efdeb165a20469d59d8bb03c55fb6621eb2041a060ae8ea3e9642", size = 3601143, upload-time = "2026-02-11T04:22:04.909Z" }, + { url = "https://files.pythonhosted.org/packages/59/04/dc5c3f297510ba9a6837cbb318b87dd2b8f73eb41a43cc63767f65cb599c/pillow-12.1.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:2815a87ab27848db0321fb78c7f0b2c8649dee134b7f2b80c6a45c6831d75ccd", size = 5266254, upload-time = "2026-02-11T04:22:07.656Z" }, + { url = "https://files.pythonhosted.org/packages/05/30/5db1236b0d6313f03ebf97f5e17cda9ca060f524b2fcc875149a8360b21c/pillow-12.1.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:f7ed2c6543bad5a7d5530eb9e78c53132f93dfa44a28492db88b41cdab885202", size = 4657499, upload-time = "2026-02-11T04:22:09.613Z" }, + { url = "https://files.pythonhosted.org/packages/6f/18/008d2ca0eb612e81968e8be0bbae5051efba24d52debf930126d7eaacbba/pillow-12.1.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:652a2c9ccfb556235b2b501a3a7cf3742148cd22e04b5625c5fe057ea3e3191f", size = 6232137, upload-time = "2026-02-11T04:22:11.434Z" }, + { url = "https://files.pythonhosted.org/packages/70/f1/f14d5b8eeb4b2cd62b9f9f847eb6605f103df89ef619ac68f92f748614ea/pillow-12.1.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d6e4571eedf43af33d0fc233a382a76e849badbccdf1ac438841308652a08e1f", size = 8042721, upload-time = "2026-02-11T04:22:13.321Z" }, + { url = "https://files.pythonhosted.org/packages/5a/d6/17824509146e4babbdabf04d8171491fa9d776f7061ff6e727522df9bd03/pillow-12.1.1-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b574c51cf7d5d62e9be37ba446224b59a2da26dc4c1bb2ecbe936a4fb1a7cb7f", size = 6347798, upload-time = "2026-02-11T04:22:15.449Z" }, + { url = "https://files.pythonhosted.org/packages/d1/ee/c85a38a9ab92037a75615aba572c85ea51e605265036e00c5b67dfafbfe2/pillow-12.1.1-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a37691702ed687799de29a518d63d4682d9016932db66d4e90c345831b02fb4e", size = 7039315, upload-time = "2026-02-11T04:22:17.24Z" }, + { url = "https://files.pythonhosted.org/packages/ec/f3/bc8ccc6e08a148290d7523bde4d9a0d6c981db34631390dc6e6ec34cacf6/pillow-12.1.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:f95c00d5d6700b2b890479664a06e754974848afaae5e21beb4d83c106923fd0", size = 6462360, upload-time = "2026-02-11T04:22:19.111Z" }, + { url = "https://files.pythonhosted.org/packages/f6/ab/69a42656adb1d0665ab051eec58a41f169ad295cf81ad45406963105408f/pillow-12.1.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:559b38da23606e68681337ad74622c4dbba02254fc9cb4488a305dd5975c7eeb", size = 7165438, upload-time = "2026-02-11T04:22:21.041Z" }, + { url = "https://files.pythonhosted.org/packages/02/46/81f7aa8941873f0f01d4b55cc543b0a3d03ec2ee30d617a0448bf6bd6dec/pillow-12.1.1-cp314-cp314-win32.whl", hash = "sha256:03edcc34d688572014ff223c125a3f77fb08091e4607e7745002fc214070b35f", size = 6431503, upload-time = "2026-02-11T04:22:22.833Z" }, + { url = "https://files.pythonhosted.org/packages/40/72/4c245f7d1044b67affc7f134a09ea619d4895333d35322b775b928180044/pillow-12.1.1-cp314-cp314-win_amd64.whl", hash = "sha256:50480dcd74fa63b8e78235957d302d98d98d82ccbfac4c7e12108ba9ecbdba15", size = 7176748, upload-time = "2026-02-11T04:22:24.64Z" }, + { url = "https://files.pythonhosted.org/packages/e4/ad/8a87bdbe038c5c698736e3348af5c2194ffb872ea52f11894c95f9305435/pillow-12.1.1-cp314-cp314-win_arm64.whl", hash = "sha256:5cb1785d97b0c3d1d1a16bc1d710c4a0049daefc4935f3a8f31f827f4d3d2e7f", size = 2544314, upload-time = "2026-02-11T04:22:26.685Z" }, + { url = "https://files.pythonhosted.org/packages/6c/9d/efd18493f9de13b87ede7c47e69184b9e859e4427225ea962e32e56a49bc/pillow-12.1.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:1f90cff8aa76835cba5769f0b3121a22bd4eb9e6884cfe338216e557a9a548b8", size = 5268612, upload-time = "2026-02-11T04:22:29.884Z" }, + { url = "https://files.pythonhosted.org/packages/f8/f1/4f42eb2b388eb2ffc660dcb7f7b556c1015c53ebd5f7f754965ef997585b/pillow-12.1.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1f1be78ce9466a7ee64bfda57bdba0f7cc499d9794d518b854816c41bf0aa4e9", size = 4660567, upload-time = "2026-02-11T04:22:31.799Z" }, + { url = "https://files.pythonhosted.org/packages/01/54/df6ef130fa43e4b82e32624a7b821a2be1c5653a5fdad8469687a7db4e00/pillow-12.1.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:42fc1f4677106188ad9a55562bbade416f8b55456f522430fadab3cef7cd4e60", size = 6269951, upload-time = "2026-02-11T04:22:33.921Z" }, + { url = "https://files.pythonhosted.org/packages/a9/48/618752d06cc44bb4aae8ce0cd4e6426871929ed7b46215638088270d9b34/pillow-12.1.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:98edb152429ab62a1818039744d8fbb3ccab98a7c29fc3d5fcef158f3f1f68b7", size = 8074769, upload-time = "2026-02-11T04:22:35.877Z" }, + { url = "https://files.pythonhosted.org/packages/c3/bd/f1d71eb39a72fa088d938655afba3e00b38018d052752f435838961127d8/pillow-12.1.1-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d470ab1178551dd17fdba0fef463359c41aaa613cdcd7ff8373f54be629f9f8f", size = 6381358, upload-time = "2026-02-11T04:22:37.698Z" }, + { url = "https://files.pythonhosted.org/packages/64/ef/c784e20b96674ed36a5af839305f55616f8b4f8aa8eeccf8531a6e312243/pillow-12.1.1-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6408a7b064595afcab0a49393a413732a35788f2a5092fdc6266952ed67de586", size = 7068558, upload-time = "2026-02-11T04:22:39.597Z" }, + { url = "https://files.pythonhosted.org/packages/73/cb/8059688b74422ae61278202c4e1ad992e8a2e7375227be0a21c6b87ca8d5/pillow-12.1.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:5d8c41325b382c07799a3682c1c258469ea2ff97103c53717b7893862d0c98ce", size = 6493028, upload-time = "2026-02-11T04:22:42.73Z" }, + { url = "https://files.pythonhosted.org/packages/c6/da/e3c008ed7d2dd1f905b15949325934510b9d1931e5df999bb15972756818/pillow-12.1.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:c7697918b5be27424e9ce568193efd13d925c4481dd364e43f5dff72d33e10f8", size = 7191940, upload-time = "2026-02-11T04:22:44.543Z" }, + { url = "https://files.pythonhosted.org/packages/01/4a/9202e8d11714c1fc5951f2e1ef362f2d7fbc595e1f6717971d5dd750e969/pillow-12.1.1-cp314-cp314t-win32.whl", hash = "sha256:d2912fd8114fc5545aa3a4b5576512f64c55a03f3ebcca4c10194d593d43ea36", size = 6438736, upload-time = "2026-02-11T04:22:46.347Z" }, + { url = "https://files.pythonhosted.org/packages/f3/ca/cbce2327eb9885476b3957b2e82eb12c866a8b16ad77392864ad601022ce/pillow-12.1.1-cp314-cp314t-win_amd64.whl", hash = "sha256:4ceb838d4bd9dab43e06c363cab2eebf63846d6a4aeaea283bbdfd8f1a8ed58b", size = 7182894, upload-time = "2026-02-11T04:22:48.114Z" }, + { url = "https://files.pythonhosted.org/packages/ec/d2/de599c95ba0a973b94410477f8bf0b6f0b5e67360eb89bcb1ad365258beb/pillow-12.1.1-cp314-cp314t-win_arm64.whl", hash = "sha256:7b03048319bfc6170e93bd60728a1af51d3dd7704935feb228c4d4faab35d334", size = 2546446, upload-time = "2026-02-11T04:22:50.342Z" }, +] + +[[package]] +name = "platformdirs" +version = "4.9.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/19/56/8d4c30c8a1d07013911a8fdbd8f89440ef9f08d07a1b50ab8ca8be5a20f9/platformdirs-4.9.4.tar.gz", hash = "sha256:1ec356301b7dc906d83f371c8f487070e99d3ccf9e501686456394622a01a934", size = 28737, upload-time = "2026-03-05T18:34:13.271Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/63/d7/97f7e3a6abb67d8080dd406fd4df842c2be0efaf712d1c899c32a075027c/platformdirs-4.9.4-py3-none-any.whl", hash = "sha256:68a9a4619a666ea6439f2ff250c12a853cd1cbd5158d258bd824a7df6be2f868", size = 21216, upload-time = "2026-03-05T18:34:12.172Z" }, ] [[package]] @@ -399,6 +1713,88 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" }, ] +[[package]] +name = "prompt-toolkit" +version = "3.0.52" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "wcwidth" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a1/96/06e01a7b38dce6fe1db213e061a4602dd6032a8a97ef6c1a862537732421/prompt_toolkit-3.0.52.tar.gz", hash = "sha256:28cde192929c8e7321de85de1ddbe736f1375148b02f2e17edd840042b1be855", size = 434198, upload-time = "2025-08-27T15:24:02.057Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/84/03/0d3ce49e2505ae70cf43bc5bb3033955d2fc9f932163e84dc0779cc47f48/prompt_toolkit-3.0.52-py3-none-any.whl", hash = "sha256:9aac639a3bbd33284347de5ad8d68ecc044b91a762dc39b7c21095fcd6a19955", size = 391431, upload-time = "2025-08-27T15:23:59.498Z" }, +] + +[[package]] +name = "protobuf" +version = "7.34.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6b/6b/a0e95cad1ad7cc3f2c6821fcab91671bd5b78bd42afb357bb4765f29bc41/protobuf-7.34.1.tar.gz", hash = "sha256:9ce42245e704cc5027be797c1db1eb93184d44d1cdd71811fb2d9b25ad541280", size = 454708, upload-time = "2026-03-20T17:34:47.036Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ec/11/3325d41e6ee15bf1125654301211247b042563bcc898784351252549a8ad/protobuf-7.34.1-cp310-abi3-macosx_10_9_universal2.whl", hash = "sha256:d8b2cc79c4d8f62b293ad9b11ec3aebce9af481fa73e64556969f7345ebf9fc7", size = 429247, upload-time = "2026-03-20T17:34:37.024Z" }, + { url = "https://files.pythonhosted.org/packages/eb/9d/aa69df2724ff63efa6f72307b483ce0827f4347cc6d6df24b59e26659fef/protobuf-7.34.1-cp310-abi3-manylinux2014_aarch64.whl", hash = "sha256:5185e0e948d07abe94bb76ec9b8416b604cfe5da6f871d67aad30cbf24c3110b", size = 325753, upload-time = "2026-03-20T17:34:38.751Z" }, + { url = "https://files.pythonhosted.org/packages/92/e8/d174c91fd48e50101943f042b09af9029064810b734e4160bbe282fa1caa/protobuf-7.34.1-cp310-abi3-manylinux2014_s390x.whl", hash = "sha256:403b093a6e28a960372b44e5eb081775c9b056e816a8029c61231743d63f881a", size = 340198, upload-time = "2026-03-20T17:34:39.871Z" }, + { url = "https://files.pythonhosted.org/packages/53/1b/3b431694a4dc6d37b9f653f0c64b0a0d9ec074ee810710c0c3da21d67ba7/protobuf-7.34.1-cp310-abi3-manylinux2014_x86_64.whl", hash = "sha256:8ff40ce8cd688f7265326b38d5a1bed9bfdf5e6723d49961432f83e21d5713e4", size = 324267, upload-time = "2026-03-20T17:34:41.1Z" }, + { url = "https://files.pythonhosted.org/packages/85/29/64de04a0ac142fb685fd09999bc3d337943fb386f3a0ec57f92fd8203f97/protobuf-7.34.1-cp310-abi3-win32.whl", hash = "sha256:34b84ce27680df7cca9f231043ada0daa55d0c44a2ddfaa58ec1d0d89d8bf60a", size = 426628, upload-time = "2026-03-20T17:34:42.536Z" }, + { url = "https://files.pythonhosted.org/packages/4d/87/cb5e585192a22b8bd457df5a2c16a75ea0db9674c3a0a39fc9347d84e075/protobuf-7.34.1-cp310-abi3-win_amd64.whl", hash = "sha256:e97b55646e6ce5cbb0954a8c28cd39a5869b59090dfaa7df4598a7fba869468c", size = 437901, upload-time = "2026-03-20T17:34:44.112Z" }, + { url = "https://files.pythonhosted.org/packages/88/95/608f665226bca68b736b79e457fded9a2a38c4f4379a4a7614303d9db3bc/protobuf-7.34.1-py3-none-any.whl", hash = "sha256:bb3812cd53aefea2b028ef42bd780f5b96407247f20c6ef7c679807e9d188f11", size = 170715, upload-time = "2026-03-20T17:34:45.384Z" }, +] + +[[package]] +name = "psutil" +version = "7.2.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/aa/c6/d1ddf4abb55e93cebc4f2ed8b5d6dbad109ecb8d63748dd2b20ab5e57ebe/psutil-7.2.2.tar.gz", hash = "sha256:0746f5f8d406af344fd547f1c8daa5f5c33dbc293bb8d6a16d80b4bb88f59372", size = 493740, upload-time = "2026-01-28T18:14:54.428Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/51/08/510cbdb69c25a96f4ae523f733cdc963ae654904e8db864c07585ef99875/psutil-7.2.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:2edccc433cbfa046b980b0df0171cd25bcaeb3a68fe9022db0979e7aa74a826b", size = 130595, upload-time = "2026-01-28T18:14:57.293Z" }, + { url = "https://files.pythonhosted.org/packages/d6/f5/97baea3fe7a5a9af7436301f85490905379b1c6f2dd51fe3ecf24b4c5fbf/psutil-7.2.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e78c8603dcd9a04c7364f1a3e670cea95d51ee865e4efb3556a3a63adef958ea", size = 131082, upload-time = "2026-01-28T18:14:59.732Z" }, + { url = "https://files.pythonhosted.org/packages/37/d6/246513fbf9fa174af531f28412297dd05241d97a75911ac8febefa1a53c6/psutil-7.2.2-cp313-cp313t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1a571f2330c966c62aeda00dd24620425d4b0cc86881c89861fbc04549e5dc63", size = 181476, upload-time = "2026-01-28T18:15:01.884Z" }, + { url = "https://files.pythonhosted.org/packages/b8/b5/9182c9af3836cca61696dabe4fd1304e17bc56cb62f17439e1154f225dd3/psutil-7.2.2-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:917e891983ca3c1887b4ef36447b1e0873e70c933afc831c6b6da078ba474312", size = 184062, upload-time = "2026-01-28T18:15:04.436Z" }, + { url = "https://files.pythonhosted.org/packages/16/ba/0756dca669f5a9300d0cbcbfae9a4c30e446dfc7440ffe43ded5724bfd93/psutil-7.2.2-cp313-cp313t-win_amd64.whl", hash = "sha256:ab486563df44c17f5173621c7b198955bd6b613fb87c71c161f827d3fb149a9b", size = 139893, upload-time = "2026-01-28T18:15:06.378Z" }, + { url = "https://files.pythonhosted.org/packages/1c/61/8fa0e26f33623b49949346de05ec1ddaad02ed8ba64af45f40a147dbfa97/psutil-7.2.2-cp313-cp313t-win_arm64.whl", hash = "sha256:ae0aefdd8796a7737eccea863f80f81e468a1e4cf14d926bd9b6f5f2d5f90ca9", size = 135589, upload-time = "2026-01-28T18:15:08.03Z" }, + { url = "https://files.pythonhosted.org/packages/81/69/ef179ab5ca24f32acc1dac0c247fd6a13b501fd5534dbae0e05a1c48b66d/psutil-7.2.2-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:eed63d3b4d62449571547b60578c5b2c4bcccc5387148db46e0c2313dad0ee00", size = 130664, upload-time = "2026-01-28T18:15:09.469Z" }, + { url = "https://files.pythonhosted.org/packages/7b/64/665248b557a236d3fa9efc378d60d95ef56dd0a490c2cd37dafc7660d4a9/psutil-7.2.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7b6d09433a10592ce39b13d7be5a54fbac1d1228ed29abc880fb23df7cb694c9", size = 131087, upload-time = "2026-01-28T18:15:11.724Z" }, + { url = "https://files.pythonhosted.org/packages/d5/2e/e6782744700d6759ebce3043dcfa661fb61e2fb752b91cdeae9af12c2178/psutil-7.2.2-cp314-cp314t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1fa4ecf83bcdf6e6c8f4449aff98eefb5d0604bf88cb883d7da3d8d2d909546a", size = 182383, upload-time = "2026-01-28T18:15:13.445Z" }, + { url = "https://files.pythonhosted.org/packages/57/49/0a41cefd10cb7505cdc04dab3eacf24c0c2cb158a998b8c7b1d27ee2c1f5/psutil-7.2.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e452c464a02e7dc7822a05d25db4cde564444a67e58539a00f929c51eddda0cf", size = 185210, upload-time = "2026-01-28T18:15:16.002Z" }, + { url = "https://files.pythonhosted.org/packages/dd/2c/ff9bfb544f283ba5f83ba725a3c5fec6d6b10b8f27ac1dc641c473dc390d/psutil-7.2.2-cp314-cp314t-win_amd64.whl", hash = "sha256:c7663d4e37f13e884d13994247449e9f8f574bc4655d509c3b95e9ec9e2b9dc1", size = 141228, upload-time = "2026-01-28T18:15:18.385Z" }, + { url = "https://files.pythonhosted.org/packages/f2/fc/f8d9c31db14fcec13748d373e668bc3bed94d9077dbc17fb0eebc073233c/psutil-7.2.2-cp314-cp314t-win_arm64.whl", hash = "sha256:11fe5a4f613759764e79c65cf11ebdf26e33d6dd34336f8a337aa2996d71c841", size = 136284, upload-time = "2026-01-28T18:15:19.912Z" }, + { url = "https://files.pythonhosted.org/packages/e7/36/5ee6e05c9bd427237b11b3937ad82bb8ad2752d72c6969314590dd0c2f6e/psutil-7.2.2-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:ed0cace939114f62738d808fdcecd4c869222507e266e574799e9c0faa17d486", size = 129090, upload-time = "2026-01-28T18:15:22.168Z" }, + { url = "https://files.pythonhosted.org/packages/80/c4/f5af4c1ca8c1eeb2e92ccca14ce8effdeec651d5ab6053c589b074eda6e1/psutil-7.2.2-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:1a7b04c10f32cc88ab39cbf606e117fd74721c831c98a27dc04578deb0c16979", size = 129859, upload-time = "2026-01-28T18:15:23.795Z" }, + { url = "https://files.pythonhosted.org/packages/b5/70/5d8df3b09e25bce090399cf48e452d25c935ab72dad19406c77f4e828045/psutil-7.2.2-cp36-abi3-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:076a2d2f923fd4821644f5ba89f059523da90dc9014e85f8e45a5774ca5bc6f9", size = 155560, upload-time = "2026-01-28T18:15:25.976Z" }, + { url = "https://files.pythonhosted.org/packages/63/65/37648c0c158dc222aba51c089eb3bdfa238e621674dc42d48706e639204f/psutil-7.2.2-cp36-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b0726cecd84f9474419d67252add4ac0cd9811b04d61123054b9fb6f57df6e9e", size = 156997, upload-time = "2026-01-28T18:15:27.794Z" }, + { url = "https://files.pythonhosted.org/packages/8e/13/125093eadae863ce03c6ffdbae9929430d116a246ef69866dad94da3bfbc/psutil-7.2.2-cp36-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:fd04ef36b4a6d599bbdb225dd1d3f51e00105f6d48a28f006da7f9822f2606d8", size = 148972, upload-time = "2026-01-28T18:15:29.342Z" }, + { url = "https://files.pythonhosted.org/packages/04/78/0acd37ca84ce3ddffaa92ef0f571e073faa6d8ff1f0559ab1272188ea2be/psutil-7.2.2-cp36-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:b58fabe35e80b264a4e3bb23e6b96f9e45a3df7fb7eed419ac0e5947c61e47cc", size = 148266, upload-time = "2026-01-28T18:15:31.597Z" }, + { url = "https://files.pythonhosted.org/packages/b4/90/e2159492b5426be0c1fef7acba807a03511f97c5f86b3caeda6ad92351a7/psutil-7.2.2-cp37-abi3-win_amd64.whl", hash = "sha256:eb7e81434c8d223ec4a219b5fc1c47d0417b12be7ea866e24fb5ad6e84b3d988", size = 137737, upload-time = "2026-01-28T18:15:33.849Z" }, + { url = "https://files.pythonhosted.org/packages/8c/c7/7bb2e321574b10df20cbde462a94e2b71d05f9bbda251ef27d104668306a/psutil-7.2.2-cp37-abi3-win_arm64.whl", hash = "sha256:8c233660f575a5a89e6d4cb65d9f938126312bca76d8fe087b947b3a1aaac9ee", size = 134617, upload-time = "2026-01-28T18:15:36.514Z" }, +] + +[[package]] +name = "ptyprocess" +version = "0.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/20/e5/16ff212c1e452235a90aeb09066144d0c5a6a8c0834397e03f5224495c4e/ptyprocess-0.7.0.tar.gz", hash = "sha256:5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220", size = 70762, upload-time = "2020-12-28T15:15:30.155Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/22/a6/858897256d0deac81a172289110f31629fc4cee19b6f01283303e18c8db3/ptyprocess-0.7.0-py2.py3-none-any.whl", hash = "sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35", size = 13993, upload-time = "2020-12-28T15:15:28.35Z" }, +] + +[[package]] +name = "pure-eval" +version = "0.2.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/cd/05/0a34433a064256a578f1783a10da6df098ceaa4a57bbeaa96a6c0352786b/pure_eval-0.2.3.tar.gz", hash = "sha256:5f4e983f40564c576c7c8635ae88db5956bb2229d7e9237d03b3c0b0190eaf42", size = 19752, upload-time = "2024-07-21T12:58:21.801Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8e/37/efad0257dc6e593a18957422533ff0f87ede7c9c6ea010a2177d738fb82f/pure_eval-0.2.3-py3-none-any.whl", hash = "sha256:1db8e35b67b3d218d818ae653e27f06c3aa420901fa7b081ca98cbedc874e0d0", size = 11842, upload-time = "2024-07-21T12:58:20.04Z" }, +] + +[[package]] +name = "pycparser" +version = "3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1b/7d/92392ff7815c21062bea51aa7b87d45576f649f16458d78b7cf94b9ab2e6/pycparser-3.0.tar.gz", hash = "sha256:600f49d217304a5902ac3c37e1281c9fe94e4d0489de643a9504c5cdfdfc6b29", size = 103492, upload-time = "2026-01-21T14:26:51.89Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0c/c3/44f3fbbfa403ea2a7c779186dc20772604442dde72947e7d01069cbe98e3/pycparser-3.0-py3-none-any.whl", hash = "sha256:b727414169a36b7d524c1c3e31839a521725078d7b2ff038656844266160a992", size = 48172, upload-time = "2026-01-21T14:26:50.693Z" }, +] + [[package]] name = "pydantic" version = "2.12.5" @@ -423,20 +1819,6 @@ dependencies = [ ] sdist = { url = "https://files.pythonhosted.org/packages/71/70/23b021c950c2addd24ec408e9ab05d59b035b39d97cdc1130e1bce647bb6/pydantic_core-2.41.5.tar.gz", hash = "sha256:08daa51ea16ad373ffd5e7606252cc32f07bc72b28284b6bc9c6df804816476e", size = 460952, upload-time = "2025-11-04T13:43:49.098Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/e8/72/74a989dd9f2084b3d9530b0915fdda64ac48831c30dbf7c72a41a5232db8/pydantic_core-2.41.5-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:a3a52f6156e73e7ccb0f8cced536adccb7042be67cb45f9562e12b319c119da6", size = 2105873, upload-time = "2025-11-04T13:39:31.373Z" }, - { url = "https://files.pythonhosted.org/packages/12/44/37e403fd9455708b3b942949e1d7febc02167662bf1a7da5b78ee1ea2842/pydantic_core-2.41.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7f3bf998340c6d4b0c9a2f02d6a400e51f123b59565d74dc60d252ce888c260b", size = 1899826, upload-time = "2025-11-04T13:39:32.897Z" }, - { url = "https://files.pythonhosted.org/packages/33/7f/1d5cab3ccf44c1935a359d51a8a2a9e1a654b744b5e7f80d41b88d501eec/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:378bec5c66998815d224c9ca994f1e14c0c21cb95d2f52b6021cc0b2a58f2a5a", size = 1917869, upload-time = "2025-11-04T13:39:34.469Z" }, - { url = "https://files.pythonhosted.org/packages/6e/6a/30d94a9674a7fe4f4744052ed6c5e083424510be1e93da5bc47569d11810/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e7b576130c69225432866fe2f4a469a85a54ade141d96fd396dffcf607b558f8", size = 2063890, upload-time = "2025-11-04T13:39:36.053Z" }, - { url = "https://files.pythonhosted.org/packages/50/be/76e5d46203fcb2750e542f32e6c371ffa9b8ad17364cf94bb0818dbfb50c/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6cb58b9c66f7e4179a2d5e0f849c48eff5c1fca560994d6eb6543abf955a149e", size = 2229740, upload-time = "2025-11-04T13:39:37.753Z" }, - { url = "https://files.pythonhosted.org/packages/d3/ee/fed784df0144793489f87db310a6bbf8118d7b630ed07aa180d6067e653a/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:88942d3a3dff3afc8288c21e565e476fc278902ae4d6d134f1eeda118cc830b1", size = 2350021, upload-time = "2025-11-04T13:39:40.94Z" }, - { url = "https://files.pythonhosted.org/packages/c8/be/8fed28dd0a180dca19e72c233cbf58efa36df055e5b9d90d64fd1740b828/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f31d95a179f8d64d90f6831d71fa93290893a33148d890ba15de25642c5d075b", size = 2066378, upload-time = "2025-11-04T13:39:42.523Z" }, - { url = "https://files.pythonhosted.org/packages/b0/3b/698cf8ae1d536a010e05121b4958b1257f0b5522085e335360e53a6b1c8b/pydantic_core-2.41.5-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c1df3d34aced70add6f867a8cf413e299177e0c22660cc767218373d0779487b", size = 2175761, upload-time = "2025-11-04T13:39:44.553Z" }, - { url = "https://files.pythonhosted.org/packages/b8/ba/15d537423939553116dea94ce02f9c31be0fa9d0b806d427e0308ec17145/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:4009935984bd36bd2c774e13f9a09563ce8de4abaa7226f5108262fa3e637284", size = 2146303, upload-time = "2025-11-04T13:39:46.238Z" }, - { url = "https://files.pythonhosted.org/packages/58/7f/0de669bf37d206723795f9c90c82966726a2ab06c336deba4735b55af431/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:34a64bc3441dc1213096a20fe27e8e128bd3ff89921706e83c0b1ac971276594", size = 2340355, upload-time = "2025-11-04T13:39:48.002Z" }, - { url = "https://files.pythonhosted.org/packages/e5/de/e7482c435b83d7e3c3ee5ee4451f6e8973cff0eb6007d2872ce6383f6398/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:c9e19dd6e28fdcaa5a1de679aec4141f691023916427ef9bae8584f9c2fb3b0e", size = 2319875, upload-time = "2025-11-04T13:39:49.705Z" }, - { url = "https://files.pythonhosted.org/packages/fe/e6/8c9e81bb6dd7560e33b9053351c29f30c8194b72f2d6932888581f503482/pydantic_core-2.41.5-cp311-cp311-win32.whl", hash = "sha256:2c010c6ded393148374c0f6f0bf89d206bf3217f201faa0635dcd56bd1520f6b", size = 1987549, upload-time = "2025-11-04T13:39:51.842Z" }, - { url = "https://files.pythonhosted.org/packages/11/66/f14d1d978ea94d1bc21fc98fcf570f9542fe55bfcc40269d4e1a21c19bf7/pydantic_core-2.41.5-cp311-cp311-win_amd64.whl", hash = "sha256:76ee27c6e9c7f16f47db7a94157112a2f3a00e958bc626e2f4ee8bec5c328fbe", size = 2011305, upload-time = "2025-11-04T13:39:53.485Z" }, - { url = "https://files.pythonhosted.org/packages/56/d8/0e271434e8efd03186c5386671328154ee349ff0354d83c74f5caaf096ed/pydantic_core-2.41.5-cp311-cp311-win_arm64.whl", hash = "sha256:4bc36bbc0b7584de96561184ad7f012478987882ebf9f9c389b23f432ea3d90f", size = 1972902, upload-time = "2025-11-04T13:39:56.488Z" }, { url = "https://files.pythonhosted.org/packages/5f/5d/5f6c63eebb5afee93bcaae4ce9a898f3373ca23df3ccaef086d0233a35a7/pydantic_core-2.41.5-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:f41a7489d32336dbf2199c8c0a215390a751c5b014c2c1c5366e817202e9cdf7", size = 2110990, upload-time = "2025-11-04T13:39:58.079Z" }, { url = "https://files.pythonhosted.org/packages/aa/32/9c2e8ccb57c01111e0fd091f236c7b371c1bccea0fa85247ac55b1e2b6b6/pydantic_core-2.41.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:070259a8818988b9a84a449a2a7337c7f430a22acc0859c6b110aa7212a6d9c0", size = 1896003, upload-time = "2025-11-04T13:39:59.956Z" }, { url = "https://files.pythonhosted.org/packages/68/b8/a01b53cb0e59139fbc9e4fda3e9724ede8de279097179be4ff31f1abb65a/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e96cea19e34778f8d59fe40775a7a574d95816eb150850a85a7a4c8f4b94ac69", size = 1919200, upload-time = "2025-11-04T13:40:02.241Z" }, @@ -451,22 +1833,52 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/49/3b/774f2b5cd4192d5ab75870ce4381fd89cf218af999515baf07e7206753f0/pydantic_core-2.41.5-cp312-cp312-win32.whl", hash = "sha256:b74557b16e390ec12dca509bce9264c3bbd128f8a2c376eaa68003d7f327276d", size = 1985908, upload-time = "2025-11-04T13:40:19.309Z" }, { url = "https://files.pythonhosted.org/packages/86/45/00173a033c801cacf67c190fef088789394feaf88a98a7035b0e40d53dc9/pydantic_core-2.41.5-cp312-cp312-win_amd64.whl", hash = "sha256:1962293292865bca8e54702b08a4f26da73adc83dd1fcf26fbc875b35d81c815", size = 2020145, upload-time = "2025-11-04T13:40:21.548Z" }, { url = "https://files.pythonhosted.org/packages/f9/22/91fbc821fa6d261b376a3f73809f907cec5ca6025642c463d3488aad22fb/pydantic_core-2.41.5-cp312-cp312-win_arm64.whl", hash = "sha256:1746d4a3d9a794cacae06a5eaaccb4b8643a131d45fbc9af23e353dc0a5ba5c3", size = 1976179, upload-time = "2025-11-04T13:40:23.393Z" }, - { url = "https://files.pythonhosted.org/packages/11/72/90fda5ee3b97e51c494938a4a44c3a35a9c96c19bba12372fb9c634d6f57/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-macosx_10_12_x86_64.whl", hash = "sha256:b96d5f26b05d03cc60f11a7761a5ded1741da411e7fe0909e27a5e6a0cb7b034", size = 2115441, upload-time = "2025-11-04T13:42:39.557Z" }, - { url = "https://files.pythonhosted.org/packages/1f/53/8942f884fa33f50794f119012dc6a1a02ac43a56407adaac20463df8e98f/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-macosx_11_0_arm64.whl", hash = "sha256:634e8609e89ceecea15e2d61bc9ac3718caaaa71963717bf3c8f38bfde64242c", size = 1930291, upload-time = "2025-11-04T13:42:42.169Z" }, - { url = "https://files.pythonhosted.org/packages/79/c8/ecb9ed9cd942bce09fc888ee960b52654fbdbede4ba6c2d6e0d3b1d8b49c/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:93e8740d7503eb008aa2df04d3b9735f845d43ae845e6dcd2be0b55a2da43cd2", size = 1948632, upload-time = "2025-11-04T13:42:44.564Z" }, - { url = "https://files.pythonhosted.org/packages/2e/1b/687711069de7efa6af934e74f601e2a4307365e8fdc404703afc453eab26/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f15489ba13d61f670dcc96772e733aad1a6f9c429cc27574c6cdaed82d0146ad", size = 2138905, upload-time = "2025-11-04T13:42:47.156Z" }, + { url = "https://files.pythonhosted.org/packages/87/06/8806241ff1f70d9939f9af039c6c35f2360cf16e93c2ca76f184e76b1564/pydantic_core-2.41.5-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:941103c9be18ac8daf7b7adca8228f8ed6bb7a1849020f643b3a14d15b1924d9", size = 2120403, upload-time = "2025-11-04T13:40:25.248Z" }, + { url = "https://files.pythonhosted.org/packages/94/02/abfa0e0bda67faa65fef1c84971c7e45928e108fe24333c81f3bfe35d5f5/pydantic_core-2.41.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:112e305c3314f40c93998e567879e887a3160bb8689ef3d2c04b6cc62c33ac34", size = 1896206, upload-time = "2025-11-04T13:40:27.099Z" }, + { url = "https://files.pythonhosted.org/packages/15/df/a4c740c0943e93e6500f9eb23f4ca7ec9bf71b19e608ae5b579678c8d02f/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0cbaad15cb0c90aa221d43c00e77bb33c93e8d36e0bf74760cd00e732d10a6a0", size = 1919307, upload-time = "2025-11-04T13:40:29.806Z" }, + { url = "https://files.pythonhosted.org/packages/9a/e3/6324802931ae1d123528988e0e86587c2072ac2e5394b4bc2bc34b61ff6e/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:03ca43e12fab6023fc79d28ca6b39b05f794ad08ec2feccc59a339b02f2b3d33", size = 2063258, upload-time = "2025-11-04T13:40:33.544Z" }, + { url = "https://files.pythonhosted.org/packages/c9/d4/2230d7151d4957dd79c3044ea26346c148c98fbf0ee6ebd41056f2d62ab5/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dc799088c08fa04e43144b164feb0c13f9a0bc40503f8df3e9fde58a3c0c101e", size = 2214917, upload-time = "2025-11-04T13:40:35.479Z" }, + { url = "https://files.pythonhosted.org/packages/e6/9f/eaac5df17a3672fef0081b6c1bb0b82b33ee89aa5cec0d7b05f52fd4a1fa/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:97aeba56665b4c3235a0e52b2c2f5ae9cd071b8a8310ad27bddb3f7fb30e9aa2", size = 2332186, upload-time = "2025-11-04T13:40:37.436Z" }, + { url = "https://files.pythonhosted.org/packages/cf/4e/35a80cae583a37cf15604b44240e45c05e04e86f9cfd766623149297e971/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:406bf18d345822d6c21366031003612b9c77b3e29ffdb0f612367352aab7d586", size = 2073164, upload-time = "2025-11-04T13:40:40.289Z" }, + { url = "https://files.pythonhosted.org/packages/bf/e3/f6e262673c6140dd3305d144d032f7bd5f7497d3871c1428521f19f9efa2/pydantic_core-2.41.5-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b93590ae81f7010dbe380cdeab6f515902ebcbefe0b9327cc4804d74e93ae69d", size = 2179146, upload-time = "2025-11-04T13:40:42.809Z" }, + { url = "https://files.pythonhosted.org/packages/75/c7/20bd7fc05f0c6ea2056a4565c6f36f8968c0924f19b7d97bbfea55780e73/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:01a3d0ab748ee531f4ea6c3e48ad9dac84ddba4b0d82291f87248f2f9de8d740", size = 2137788, upload-time = "2025-11-04T13:40:44.752Z" }, + { url = "https://files.pythonhosted.org/packages/3a/8d/34318ef985c45196e004bc46c6eab2eda437e744c124ef0dbe1ff2c9d06b/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:6561e94ba9dacc9c61bce40e2d6bdc3bfaa0259d3ff36ace3b1e6901936d2e3e", size = 2340133, upload-time = "2025-11-04T13:40:46.66Z" }, + { url = "https://files.pythonhosted.org/packages/9c/59/013626bf8c78a5a5d9350d12e7697d3d4de951a75565496abd40ccd46bee/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:915c3d10f81bec3a74fbd4faebe8391013ba61e5a1a8d48c4455b923bdda7858", size = 2324852, upload-time = "2025-11-04T13:40:48.575Z" }, + { url = "https://files.pythonhosted.org/packages/1a/d9/c248c103856f807ef70c18a4f986693a46a8ffe1602e5d361485da502d20/pydantic_core-2.41.5-cp313-cp313-win32.whl", hash = "sha256:650ae77860b45cfa6e2cdafc42618ceafab3a2d9a3811fcfbd3bbf8ac3c40d36", size = 1994679, upload-time = "2025-11-04T13:40:50.619Z" }, + { url = "https://files.pythonhosted.org/packages/9e/8b/341991b158ddab181cff136acd2552c9f35bd30380422a639c0671e99a91/pydantic_core-2.41.5-cp313-cp313-win_amd64.whl", hash = "sha256:79ec52ec461e99e13791ec6508c722742ad745571f234ea6255bed38c6480f11", size = 2019766, upload-time = "2025-11-04T13:40:52.631Z" }, + { url = "https://files.pythonhosted.org/packages/73/7d/f2f9db34af103bea3e09735bb40b021788a5e834c81eedb541991badf8f5/pydantic_core-2.41.5-cp313-cp313-win_arm64.whl", hash = "sha256:3f84d5c1b4ab906093bdc1ff10484838aca54ef08de4afa9de0f5f14d69639cd", size = 1981005, upload-time = "2025-11-04T13:40:54.734Z" }, + { url = "https://files.pythonhosted.org/packages/ea/28/46b7c5c9635ae96ea0fbb779e271a38129df2550f763937659ee6c5dbc65/pydantic_core-2.41.5-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:3f37a19d7ebcdd20b96485056ba9e8b304e27d9904d233d7b1015db320e51f0a", size = 2119622, upload-time = "2025-11-04T13:40:56.68Z" }, + { url = "https://files.pythonhosted.org/packages/74/1a/145646e5687e8d9a1e8d09acb278c8535ebe9e972e1f162ed338a622f193/pydantic_core-2.41.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1d1d9764366c73f996edd17abb6d9d7649a7eb690006ab6adbda117717099b14", size = 1891725, upload-time = "2025-11-04T13:40:58.807Z" }, + { url = "https://files.pythonhosted.org/packages/23/04/e89c29e267b8060b40dca97bfc64a19b2a3cf99018167ea1677d96368273/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:25e1c2af0fce638d5f1988b686f3b3ea8cd7de5f244ca147c777769e798a9cd1", size = 1915040, upload-time = "2025-11-04T13:41:00.853Z" }, + { url = "https://files.pythonhosted.org/packages/84/a3/15a82ac7bd97992a82257f777b3583d3e84bdb06ba6858f745daa2ec8a85/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:506d766a8727beef16b7adaeb8ee6217c64fc813646b424d0804d67c16eddb66", size = 2063691, upload-time = "2025-11-04T13:41:03.504Z" }, + { url = "https://files.pythonhosted.org/packages/74/9b/0046701313c6ef08c0c1cf0e028c67c770a4e1275ca73131563c5f2a310a/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4819fa52133c9aa3c387b3328f25c1facc356491e6135b459f1de698ff64d869", size = 2213897, upload-time = "2025-11-04T13:41:05.804Z" }, + { url = "https://files.pythonhosted.org/packages/8a/cd/6bac76ecd1b27e75a95ca3a9a559c643b3afcd2dd62086d4b7a32a18b169/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2b761d210c9ea91feda40d25b4efe82a1707da2ef62901466a42492c028553a2", size = 2333302, upload-time = "2025-11-04T13:41:07.809Z" }, + { url = "https://files.pythonhosted.org/packages/4c/d2/ef2074dc020dd6e109611a8be4449b98cd25e1b9b8a303c2f0fca2f2bcf7/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:22f0fb8c1c583a3b6f24df2470833b40207e907b90c928cc8d3594b76f874375", size = 2064877, upload-time = "2025-11-04T13:41:09.827Z" }, + { url = "https://files.pythonhosted.org/packages/18/66/e9db17a9a763d72f03de903883c057b2592c09509ccfe468187f2a2eef29/pydantic_core-2.41.5-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2782c870e99878c634505236d81e5443092fba820f0373997ff75f90f68cd553", size = 2180680, upload-time = "2025-11-04T13:41:12.379Z" }, + { url = "https://files.pythonhosted.org/packages/d3/9e/3ce66cebb929f3ced22be85d4c2399b8e85b622db77dad36b73c5387f8f8/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:0177272f88ab8312479336e1d777f6b124537d47f2123f89cb37e0accea97f90", size = 2138960, upload-time = "2025-11-04T13:41:14.627Z" }, + { url = "https://files.pythonhosted.org/packages/a6/62/205a998f4327d2079326b01abee48e502ea739d174f0a89295c481a2272e/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:63510af5e38f8955b8ee5687740d6ebf7c2a0886d15a6d65c32814613681bc07", size = 2339102, upload-time = "2025-11-04T13:41:16.868Z" }, + { url = "https://files.pythonhosted.org/packages/3c/0d/f05e79471e889d74d3d88f5bd20d0ed189ad94c2423d81ff8d0000aab4ff/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:e56ba91f47764cc14f1daacd723e3e82d1a89d783f0f5afe9c364b8bb491ccdb", size = 2326039, upload-time = "2025-11-04T13:41:18.934Z" }, + { url = "https://files.pythonhosted.org/packages/ec/e1/e08a6208bb100da7e0c4b288eed624a703f4d129bde2da475721a80cab32/pydantic_core-2.41.5-cp314-cp314-win32.whl", hash = "sha256:aec5cf2fd867b4ff45b9959f8b20ea3993fc93e63c7363fe6851424c8a7e7c23", size = 1995126, upload-time = "2025-11-04T13:41:21.418Z" }, + { url = "https://files.pythonhosted.org/packages/48/5d/56ba7b24e9557f99c9237e29f5c09913c81eeb2f3217e40e922353668092/pydantic_core-2.41.5-cp314-cp314-win_amd64.whl", hash = "sha256:8e7c86f27c585ef37c35e56a96363ab8de4e549a95512445b85c96d3e2f7c1bf", size = 2015489, upload-time = "2025-11-04T13:41:24.076Z" }, + { url = "https://files.pythonhosted.org/packages/4e/bb/f7a190991ec9e3e0ba22e4993d8755bbc4a32925c0b5b42775c03e8148f9/pydantic_core-2.41.5-cp314-cp314-win_arm64.whl", hash = "sha256:e672ba74fbc2dc8eea59fb6d4aed6845e6905fc2a8afe93175d94a83ba2a01a0", size = 1977288, upload-time = "2025-11-04T13:41:26.33Z" }, + { url = "https://files.pythonhosted.org/packages/92/ed/77542d0c51538e32e15afe7899d79efce4b81eee631d99850edc2f5e9349/pydantic_core-2.41.5-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:8566def80554c3faa0e65ac30ab0932b9e3a5cd7f8323764303d468e5c37595a", size = 2120255, upload-time = "2025-11-04T13:41:28.569Z" }, + { url = "https://files.pythonhosted.org/packages/bb/3d/6913dde84d5be21e284439676168b28d8bbba5600d838b9dca99de0fad71/pydantic_core-2.41.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b80aa5095cd3109962a298ce14110ae16b8c1aece8b72f9dafe81cf597ad80b3", size = 1863760, upload-time = "2025-11-04T13:41:31.055Z" }, + { url = "https://files.pythonhosted.org/packages/5a/f0/e5e6b99d4191da102f2b0eb9687aaa7f5bea5d9964071a84effc3e40f997/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3006c3dd9ba34b0c094c544c6006cc79e87d8612999f1a5d43b769b89181f23c", size = 1878092, upload-time = "2025-11-04T13:41:33.21Z" }, + { url = "https://files.pythonhosted.org/packages/71/48/36fb760642d568925953bcc8116455513d6e34c4beaa37544118c36aba6d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:72f6c8b11857a856bcfa48c86f5368439f74453563f951e473514579d44aa612", size = 2053385, upload-time = "2025-11-04T13:41:35.508Z" }, + { url = "https://files.pythonhosted.org/packages/20/25/92dc684dd8eb75a234bc1c764b4210cf2646479d54b47bf46061657292a8/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5cb1b2f9742240e4bb26b652a5aeb840aa4b417c7748b6f8387927bc6e45e40d", size = 2218832, upload-time = "2025-11-04T13:41:37.732Z" }, + { url = "https://files.pythonhosted.org/packages/e2/09/f53e0b05023d3e30357d82eb35835d0f6340ca344720a4599cd663dca599/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bd3d54f38609ff308209bd43acea66061494157703364ae40c951f83ba99a1a9", size = 2327585, upload-time = "2025-11-04T13:41:40Z" }, + { url = "https://files.pythonhosted.org/packages/aa/4e/2ae1aa85d6af35a39b236b1b1641de73f5a6ac4d5a7509f77b814885760c/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2ff4321e56e879ee8d2a879501c8e469414d948f4aba74a2d4593184eb326660", size = 2041078, upload-time = "2025-11-04T13:41:42.323Z" }, + { url = "https://files.pythonhosted.org/packages/cd/13/2e215f17f0ef326fc72afe94776edb77525142c693767fc347ed6288728d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d0d2568a8c11bf8225044aa94409e21da0cb09dcdafe9ecd10250b2baad531a9", size = 2173914, upload-time = "2025-11-04T13:41:45.221Z" }, + { url = "https://files.pythonhosted.org/packages/02/7a/f999a6dcbcd0e5660bc348a3991c8915ce6599f4f2c6ac22f01d7a10816c/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:a39455728aabd58ceabb03c90e12f71fd30fa69615760a075b9fec596456ccc3", size = 2129560, upload-time = "2025-11-04T13:41:47.474Z" }, + { url = "https://files.pythonhosted.org/packages/3a/b1/6c990ac65e3b4c079a4fb9f5b05f5b013afa0f4ed6780a3dd236d2cbdc64/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:239edca560d05757817c13dc17c50766136d21f7cd0fac50295499ae24f90fdf", size = 2329244, upload-time = "2025-11-04T13:41:49.992Z" }, + { url = "https://files.pythonhosted.org/packages/d9/02/3c562f3a51afd4d88fff8dffb1771b30cfdfd79befd9883ee094f5b6c0d8/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:2a5e06546e19f24c6a96a129142a75cee553cc018ffee48a460059b1185f4470", size = 2331955, upload-time = "2025-11-04T13:41:54.079Z" }, + { url = "https://files.pythonhosted.org/packages/5c/96/5fb7d8c3c17bc8c62fdb031c47d77a1af698f1d7a406b0f79aaa1338f9ad/pydantic_core-2.41.5-cp314-cp314t-win32.whl", hash = "sha256:b4ececa40ac28afa90871c2cc2b9ffd2ff0bf749380fbdf57d165fd23da353aa", size = 1988906, upload-time = "2025-11-04T13:41:56.606Z" }, + { url = "https://files.pythonhosted.org/packages/22/ed/182129d83032702912c2e2d8bbe33c036f342cc735737064668585dac28f/pydantic_core-2.41.5-cp314-cp314t-win_amd64.whl", hash = "sha256:80aa89cad80b32a912a65332f64a4450ed00966111b6615ca6816153d3585a8c", size = 1981607, upload-time = "2025-11-04T13:41:58.889Z" }, + { url = "https://files.pythonhosted.org/packages/9f/ed/068e41660b832bb0b1aa5b58011dea2a3fe0ba7861ff38c4d4904c1c1a99/pydantic_core-2.41.5-cp314-cp314t-win_arm64.whl", hash = "sha256:35b44f37a3199f771c3eaa53051bc8a70cd7b54f333531c59e29fd4db5d15008", size = 1974769, upload-time = "2025-11-04T13:42:01.186Z" }, { url = "https://files.pythonhosted.org/packages/09/32/59b0c7e63e277fa7911c2fc70ccfb45ce4b98991e7ef37110663437005af/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:7da7087d756b19037bc2c06edc6c170eeef3c3bafcb8f532ff17d64dc427adfd", size = 2110495, upload-time = "2025-11-04T13:42:49.689Z" }, { url = "https://files.pythonhosted.org/packages/aa/81/05e400037eaf55ad400bcd318c05bb345b57e708887f07ddb2d20e3f0e98/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:aabf5777b5c8ca26f7824cb4a120a740c9588ed58df9b2d196ce92fba42ff8dc", size = 1915388, upload-time = "2025-11-04T13:42:52.215Z" }, { url = "https://files.pythonhosted.org/packages/6e/0d/e3549b2399f71d56476b77dbf3cf8937cec5cd70536bdc0e374a421d0599/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c007fe8a43d43b3969e8469004e9845944f1a80e6acd47c150856bb87f230c56", size = 1942879, upload-time = "2025-11-04T13:42:56.483Z" }, { url = "https://files.pythonhosted.org/packages/f7/07/34573da085946b6a313d7c42f82f16e8920bfd730665de2d11c0c37a74b5/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:76d0819de158cd855d1cbb8fcafdf6f5cf1eb8e470abe056d5d161106e38062b", size = 2139017, upload-time = "2025-11-04T13:42:59.471Z" }, - { url = "https://files.pythonhosted.org/packages/5f/9b/1b3f0e9f9305839d7e84912f9e8bfbd191ed1b1ef48083609f0dabde978c/pydantic_core-2.41.5-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:b2379fa7ed44ddecb5bfe4e48577d752db9fc10be00a6b7446e9663ba143de26", size = 2101980, upload-time = "2025-11-04T13:43:25.97Z" }, - { url = "https://files.pythonhosted.org/packages/a4/ed/d71fefcb4263df0da6a85b5d8a7508360f2f2e9b3bf5814be9c8bccdccc1/pydantic_core-2.41.5-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:266fb4cbf5e3cbd0b53669a6d1b039c45e3ce651fd5442eff4d07c2cc8d66808", size = 1923865, upload-time = "2025-11-04T13:43:28.763Z" }, - { url = "https://files.pythonhosted.org/packages/ce/3a/626b38db460d675f873e4444b4bb030453bbe7b4ba55df821d026a0493c4/pydantic_core-2.41.5-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:58133647260ea01e4d0500089a8c4f07bd7aa6ce109682b1426394988d8aaacc", size = 2134256, upload-time = "2025-11-04T13:43:31.71Z" }, - { url = "https://files.pythonhosted.org/packages/83/d9/8412d7f06f616bbc053d30cb4e5f76786af3221462ad5eee1f202021eb4e/pydantic_core-2.41.5-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:287dad91cfb551c363dc62899a80e9e14da1f0e2b6ebde82c806612ca2a13ef1", size = 2174762, upload-time = "2025-11-04T13:43:34.744Z" }, - { url = "https://files.pythonhosted.org/packages/55/4c/162d906b8e3ba3a99354e20faa1b49a85206c47de97a639510a0e673f5da/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:03b77d184b9eb40240ae9fd676ca364ce1085f203e1b1256f8ab9984dca80a84", size = 2143141, upload-time = "2025-11-04T13:43:37.701Z" }, - { url = "https://files.pythonhosted.org/packages/1f/f2/f11dd73284122713f5f89fc940f370d035fa8e1e078d446b3313955157fe/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:a668ce24de96165bb239160b3d854943128f4334822900534f2fe947930e5770", size = 2330317, upload-time = "2025-11-04T13:43:40.406Z" }, - { url = "https://files.pythonhosted.org/packages/88/9d/b06ca6acfe4abb296110fb1273a4d848a0bfb2ff65f3ee92127b3244e16b/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:f14f8f046c14563f8eb3f45f499cc658ab8d10072961e07225e507adb700e93f", size = 2316992, upload-time = "2025-11-04T13:43:43.602Z" }, - { url = "https://files.pythonhosted.org/packages/36/c7/cfc8e811f061c841d7990b0201912c3556bfeb99cdcb7ed24adc8d6f8704/pydantic_core-2.41.5-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:56121965f7a4dc965bff783d70b907ddf3d57f6eba29b6d2e5dabfaf07799c51", size = 2145302, upload-time = "2025-11-04T13:43:46.64Z" }, ] [[package]] @@ -515,6 +1927,183 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892, upload-time = "2024-03-01T18:36:18.57Z" }, ] +[[package]] +name = "pyyaml" +version = "6.0.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/33/422b98d2195232ca1826284a76852ad5a86fe23e31b009c9886b2d0fb8b2/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", size = 182063, upload-time = "2025-09-25T21:32:11.445Z" }, + { url = "https://files.pythonhosted.org/packages/89/a0/6cf41a19a1f2f3feab0e9c0b74134aa2ce6849093d5517a0c550fe37a648/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0", size = 173973, upload-time = "2025-09-25T21:32:12.492Z" }, + { url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116, upload-time = "2025-09-25T21:32:13.652Z" }, + { url = "https://files.pythonhosted.org/packages/65/30/d7353c338e12baef4ecc1b09e877c1970bd3382789c159b4f89d6a70dc09/pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c", size = 844011, upload-time = "2025-09-25T21:32:15.21Z" }, + { url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", size = 807870, upload-time = "2025-09-25T21:32:16.431Z" }, + { url = "https://files.pythonhosted.org/packages/05/c0/b3be26a015601b822b97d9149ff8cb5ead58c66f981e04fedf4e762f4bd4/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e", size = 761089, upload-time = "2025-09-25T21:32:17.56Z" }, + { url = "https://files.pythonhosted.org/packages/be/8e/98435a21d1d4b46590d5459a22d88128103f8da4c2d4cb8f14f2a96504e1/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", size = 790181, upload-time = "2025-09-25T21:32:18.834Z" }, + { url = "https://files.pythonhosted.org/packages/74/93/7baea19427dcfbe1e5a372d81473250b379f04b1bd3c4c5ff825e2327202/pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5", size = 137658, upload-time = "2025-09-25T21:32:20.209Z" }, + { url = "https://files.pythonhosted.org/packages/86/bf/899e81e4cce32febab4fb42bb97dcdf66bc135272882d1987881a4b519e9/pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b", size = 154003, upload-time = "2025-09-25T21:32:21.167Z" }, + { url = "https://files.pythonhosted.org/packages/1a/08/67bd04656199bbb51dbed1439b7f27601dfb576fb864099c7ef0c3e55531/pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd", size = 140344, upload-time = "2025-09-25T21:32:22.617Z" }, + { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669, upload-time = "2025-09-25T21:32:23.673Z" }, + { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252, upload-time = "2025-09-25T21:32:25.149Z" }, + { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081, upload-time = "2025-09-25T21:32:26.575Z" }, + { url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159, upload-time = "2025-09-25T21:32:27.727Z" }, + { url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626, upload-time = "2025-09-25T21:32:28.878Z" }, + { url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613, upload-time = "2025-09-25T21:32:30.178Z" }, + { url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115, upload-time = "2025-09-25T21:32:31.353Z" }, + { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427, upload-time = "2025-09-25T21:32:32.58Z" }, + { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090, upload-time = "2025-09-25T21:32:33.659Z" }, + { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246, upload-time = "2025-09-25T21:32:34.663Z" }, + { url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814, upload-time = "2025-09-25T21:32:35.712Z" }, + { url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809, upload-time = "2025-09-25T21:32:36.789Z" }, + { url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454, upload-time = "2025-09-25T21:32:37.966Z" }, + { url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355, upload-time = "2025-09-25T21:32:39.178Z" }, + { url = "https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175, upload-time = "2025-09-25T21:32:40.865Z" }, + { url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228, upload-time = "2025-09-25T21:32:42.084Z" }, + { url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194, upload-time = "2025-09-25T21:32:43.362Z" }, + { url = "https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", size = 156429, upload-time = "2025-09-25T21:32:57.844Z" }, + { url = "https://files.pythonhosted.org/packages/f4/f4/a4541072bb9422c8a883ab55255f918fa378ecf083f5b85e87fc2b4eda1b/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", size = 143912, upload-time = "2025-09-25T21:32:59.247Z" }, + { url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108, upload-time = "2025-09-25T21:32:44.377Z" }, + { url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641, upload-time = "2025-09-25T21:32:45.407Z" }, + { url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901, upload-time = "2025-09-25T21:32:48.83Z" }, + { url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132, upload-time = "2025-09-25T21:32:50.149Z" }, + { url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261, upload-time = "2025-09-25T21:32:51.808Z" }, + { url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272, upload-time = "2025-09-25T21:32:52.941Z" }, + { url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923, upload-time = "2025-09-25T21:32:54.537Z" }, + { url = "https://files.pythonhosted.org/packages/f0/7a/1c7270340330e575b92f397352af856a8c06f230aa3e76f86b39d01b416a/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", size = 174062, upload-time = "2025-09-25T21:32:55.767Z" }, + { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" }, +] + +[[package]] +name = "pyzmq" +version = "27.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi", marker = "implementation_name == 'pypy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/04/0b/3c9baedbdf613ecaa7aa07027780b8867f57b6293b6ee50de316c9f3222b/pyzmq-27.1.0.tar.gz", hash = "sha256:ac0765e3d44455adb6ddbf4417dcce460fc40a05978c08efdf2948072f6db540", size = 281750, upload-time = "2025-09-08T23:10:18.157Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/92/e7/038aab64a946d535901103da16b953c8c9cc9c961dadcbf3609ed6428d23/pyzmq-27.1.0-cp312-abi3-macosx_10_15_universal2.whl", hash = "sha256:452631b640340c928fa343801b0d07eb0c3789a5ffa843f6e1a9cee0ba4eb4fc", size = 1306279, upload-time = "2025-09-08T23:08:03.807Z" }, + { url = "https://files.pythonhosted.org/packages/e8/5e/c3c49fdd0f535ef45eefcc16934648e9e59dace4a37ee88fc53f6cd8e641/pyzmq-27.1.0-cp312-abi3-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:1c179799b118e554b66da67d88ed66cd37a169f1f23b5d9f0a231b4e8d44a113", size = 895645, upload-time = "2025-09-08T23:08:05.301Z" }, + { url = "https://files.pythonhosted.org/packages/f8/e5/b0b2504cb4e903a74dcf1ebae157f9e20ebb6ea76095f6cfffea28c42ecd/pyzmq-27.1.0-cp312-abi3-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3837439b7f99e60312f0c926a6ad437b067356dc2bc2ec96eb395fd0fe804233", size = 652574, upload-time = "2025-09-08T23:08:06.828Z" }, + { url = "https://files.pythonhosted.org/packages/f8/9b/c108cdb55560eaf253f0cbdb61b29971e9fb34d9c3499b0e96e4e60ed8a5/pyzmq-27.1.0-cp312-abi3-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:43ad9a73e3da1fab5b0e7e13402f0b2fb934ae1c876c51d0afff0e7c052eca31", size = 840995, upload-time = "2025-09-08T23:08:08.396Z" }, + { url = "https://files.pythonhosted.org/packages/c2/bb/b79798ca177b9eb0825b4c9998c6af8cd2a7f15a6a1a4272c1d1a21d382f/pyzmq-27.1.0-cp312-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:0de3028d69d4cdc475bfe47a6128eb38d8bc0e8f4d69646adfbcd840facbac28", size = 1642070, upload-time = "2025-09-08T23:08:09.989Z" }, + { url = "https://files.pythonhosted.org/packages/9c/80/2df2e7977c4ede24c79ae39dcef3899bfc5f34d1ca7a5b24f182c9b7a9ca/pyzmq-27.1.0-cp312-abi3-musllinux_1_2_i686.whl", hash = "sha256:cf44a7763aea9298c0aa7dbf859f87ed7012de8bda0f3977b6fb1d96745df856", size = 2021121, upload-time = "2025-09-08T23:08:11.907Z" }, + { url = "https://files.pythonhosted.org/packages/46/bd/2d45ad24f5f5ae7e8d01525eb76786fa7557136555cac7d929880519e33a/pyzmq-27.1.0-cp312-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:f30f395a9e6fbca195400ce833c731e7b64c3919aa481af4d88c3759e0cb7496", size = 1878550, upload-time = "2025-09-08T23:08:13.513Z" }, + { url = "https://files.pythonhosted.org/packages/e6/2f/104c0a3c778d7c2ab8190e9db4f62f0b6957b53c9d87db77c284b69f33ea/pyzmq-27.1.0-cp312-abi3-win32.whl", hash = "sha256:250e5436a4ba13885494412b3da5d518cd0d3a278a1ae640e113c073a5f88edd", size = 559184, upload-time = "2025-09-08T23:08:15.163Z" }, + { url = "https://files.pythonhosted.org/packages/fc/7f/a21b20d577e4100c6a41795842028235998a643b1ad406a6d4163ea8f53e/pyzmq-27.1.0-cp312-abi3-win_amd64.whl", hash = "sha256:9ce490cf1d2ca2ad84733aa1d69ce6855372cb5ce9223802450c9b2a7cba0ccf", size = 619480, upload-time = "2025-09-08T23:08:17.192Z" }, + { url = "https://files.pythonhosted.org/packages/78/c2/c012beae5f76b72f007a9e91ee9401cb88c51d0f83c6257a03e785c81cc2/pyzmq-27.1.0-cp312-abi3-win_arm64.whl", hash = "sha256:75a2f36223f0d535a0c919e23615fc85a1e23b71f40c7eb43d7b1dedb4d8f15f", size = 552993, upload-time = "2025-09-08T23:08:18.926Z" }, + { url = "https://files.pythonhosted.org/packages/60/cb/84a13459c51da6cec1b7b1dc1a47e6db6da50b77ad7fd9c145842750a011/pyzmq-27.1.0-cp313-cp313-android_24_arm64_v8a.whl", hash = "sha256:93ad4b0855a664229559e45c8d23797ceac03183c7b6f5b4428152a6b06684a5", size = 1122436, upload-time = "2025-09-08T23:08:20.801Z" }, + { url = "https://files.pythonhosted.org/packages/dc/b6/94414759a69a26c3dd674570a81813c46a078767d931a6c70ad29fc585cb/pyzmq-27.1.0-cp313-cp313-android_24_x86_64.whl", hash = "sha256:fbb4f2400bfda24f12f009cba62ad5734148569ff4949b1b6ec3b519444342e6", size = 1156301, upload-time = "2025-09-08T23:08:22.47Z" }, + { url = "https://files.pythonhosted.org/packages/a5/ad/15906493fd40c316377fd8a8f6b1f93104f97a752667763c9b9c1b71d42d/pyzmq-27.1.0-cp313-cp313t-macosx_10_15_universal2.whl", hash = "sha256:e343d067f7b151cfe4eb3bb796a7752c9d369eed007b91231e817071d2c2fec7", size = 1341197, upload-time = "2025-09-08T23:08:24.286Z" }, + { url = "https://files.pythonhosted.org/packages/14/1d/d343f3ce13db53a54cb8946594e567410b2125394dafcc0268d8dda027e0/pyzmq-27.1.0-cp313-cp313t-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:08363b2011dec81c354d694bdecaef4770e0ae96b9afea70b3f47b973655cc05", size = 897275, upload-time = "2025-09-08T23:08:26.063Z" }, + { url = "https://files.pythonhosted.org/packages/69/2d/d83dd6d7ca929a2fc67d2c3005415cdf322af7751d773524809f9e585129/pyzmq-27.1.0-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d54530c8c8b5b8ddb3318f481297441af102517602b569146185fa10b63f4fa9", size = 660469, upload-time = "2025-09-08T23:08:27.623Z" }, + { url = "https://files.pythonhosted.org/packages/3e/cd/9822a7af117f4bc0f1952dbe9ef8358eb50a24928efd5edf54210b850259/pyzmq-27.1.0-cp313-cp313t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6f3afa12c392f0a44a2414056d730eebc33ec0926aae92b5ad5cf26ebb6cc128", size = 847961, upload-time = "2025-09-08T23:08:29.672Z" }, + { url = "https://files.pythonhosted.org/packages/9a/12/f003e824a19ed73be15542f172fd0ec4ad0b60cf37436652c93b9df7c585/pyzmq-27.1.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:c65047adafe573ff023b3187bb93faa583151627bc9c51fc4fb2c561ed689d39", size = 1650282, upload-time = "2025-09-08T23:08:31.349Z" }, + { url = "https://files.pythonhosted.org/packages/d5/4a/e82d788ed58e9a23995cee70dbc20c9aded3d13a92d30d57ec2291f1e8a3/pyzmq-27.1.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:90e6e9441c946a8b0a667356f7078d96411391a3b8f80980315455574177ec97", size = 2024468, upload-time = "2025-09-08T23:08:33.543Z" }, + { url = "https://files.pythonhosted.org/packages/d9/94/2da0a60841f757481e402b34bf4c8bf57fa54a5466b965de791b1e6f747d/pyzmq-27.1.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:add071b2d25f84e8189aaf0882d39a285b42fa3853016ebab234a5e78c7a43db", size = 1885394, upload-time = "2025-09-08T23:08:35.51Z" }, + { url = "https://files.pythonhosted.org/packages/4f/6f/55c10e2e49ad52d080dc24e37adb215e5b0d64990b57598abc2e3f01725b/pyzmq-27.1.0-cp313-cp313t-win32.whl", hash = "sha256:7ccc0700cfdf7bd487bea8d850ec38f204478681ea02a582a8da8171b7f90a1c", size = 574964, upload-time = "2025-09-08T23:08:37.178Z" }, + { url = "https://files.pythonhosted.org/packages/87/4d/2534970ba63dd7c522d8ca80fb92777f362c0f321900667c615e2067cb29/pyzmq-27.1.0-cp313-cp313t-win_amd64.whl", hash = "sha256:8085a9fba668216b9b4323be338ee5437a235fe275b9d1610e422ccc279733e2", size = 641029, upload-time = "2025-09-08T23:08:40.595Z" }, + { url = "https://files.pythonhosted.org/packages/f6/fa/f8aea7a28b0641f31d40dea42d7ef003fded31e184ef47db696bc74cd610/pyzmq-27.1.0-cp313-cp313t-win_arm64.whl", hash = "sha256:6bb54ca21bcfe361e445256c15eedf083f153811c37be87e0514934d6913061e", size = 561541, upload-time = "2025-09-08T23:08:42.668Z" }, + { url = "https://files.pythonhosted.org/packages/87/45/19efbb3000956e82d0331bafca5d9ac19ea2857722fa2caacefb6042f39d/pyzmq-27.1.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:ce980af330231615756acd5154f29813d553ea555485ae712c491cd483df6b7a", size = 1341197, upload-time = "2025-09-08T23:08:44.973Z" }, + { url = "https://files.pythonhosted.org/packages/48/43/d72ccdbf0d73d1343936296665826350cb1e825f92f2db9db3e61c2162a2/pyzmq-27.1.0-cp314-cp314t-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:1779be8c549e54a1c38f805e56d2a2e5c009d26de10921d7d51cfd1c8d4632ea", size = 897175, upload-time = "2025-09-08T23:08:46.601Z" }, + { url = "https://files.pythonhosted.org/packages/2f/2e/a483f73a10b65a9ef0161e817321d39a770b2acf8bcf3004a28d90d14a94/pyzmq-27.1.0-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7200bb0f03345515df50d99d3db206a0a6bee1955fbb8c453c76f5bf0e08fb96", size = 660427, upload-time = "2025-09-08T23:08:48.187Z" }, + { url = "https://files.pythonhosted.org/packages/f5/d2/5f36552c2d3e5685abe60dfa56f91169f7a2d99bbaf67c5271022ab40863/pyzmq-27.1.0-cp314-cp314t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:01c0e07d558b06a60773744ea6251f769cd79a41a97d11b8bf4ab8f034b0424d", size = 847929, upload-time = "2025-09-08T23:08:49.76Z" }, + { url = "https://files.pythonhosted.org/packages/c4/2a/404b331f2b7bf3198e9945f75c4c521f0c6a3a23b51f7a4a401b94a13833/pyzmq-27.1.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:80d834abee71f65253c91540445d37c4c561e293ba6e741b992f20a105d69146", size = 1650193, upload-time = "2025-09-08T23:08:51.7Z" }, + { url = "https://files.pythonhosted.org/packages/1c/0b/f4107e33f62a5acf60e3ded67ed33d79b4ce18de432625ce2fc5093d6388/pyzmq-27.1.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:544b4e3b7198dde4a62b8ff6685e9802a9a1ebf47e77478a5eb88eca2a82f2fd", size = 2024388, upload-time = "2025-09-08T23:08:53.393Z" }, + { url = "https://files.pythonhosted.org/packages/0d/01/add31fe76512642fd6e40e3a3bd21f4b47e242c8ba33efb6809e37076d9b/pyzmq-27.1.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:cedc4c68178e59a4046f97eca31b148ddcf51e88677de1ef4e78cf06c5376c9a", size = 1885316, upload-time = "2025-09-08T23:08:55.702Z" }, + { url = "https://files.pythonhosted.org/packages/c4/59/a5f38970f9bf07cee96128de79590bb354917914a9be11272cfc7ff26af0/pyzmq-27.1.0-cp314-cp314t-win32.whl", hash = "sha256:1f0b2a577fd770aa6f053211a55d1c47901f4d537389a034c690291485e5fe92", size = 587472, upload-time = "2025-09-08T23:08:58.18Z" }, + { url = "https://files.pythonhosted.org/packages/70/d8/78b1bad170f93fcf5e3536e70e8fadac55030002275c9a29e8f5719185de/pyzmq-27.1.0-cp314-cp314t-win_amd64.whl", hash = "sha256:19c9468ae0437f8074af379e986c5d3d7d7bfe033506af442e8c879732bedbe0", size = 661401, upload-time = "2025-09-08T23:08:59.802Z" }, + { url = "https://files.pythonhosted.org/packages/81/d6/4bfbb40c9a0b42fc53c7cf442f6385db70b40f74a783130c5d0a5aa62228/pyzmq-27.1.0-cp314-cp314t-win_arm64.whl", hash = "sha256:dc5dbf68a7857b59473f7df42650c621d7e8923fb03fa74a526890f4d33cc4d7", size = 575170, upload-time = "2025-09-08T23:09:01.418Z" }, +] + +[[package]] +name = "regex" +version = "2026.2.28" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/8b/71/41455aa99a5a5ac1eaf311f5d8efd9ce6433c03ac1e0962de163350d0d97/regex-2026.2.28.tar.gz", hash = "sha256:a729e47d418ea11d03469f321aaf67cdee8954cde3ff2cf8403ab87951ad10f2", size = 415184, upload-time = "2026-02-28T02:19:42.792Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/07/42/9061b03cf0fc4b5fa2c3984cbbaed54324377e440a5c5a29d29a72518d62/regex-2026.2.28-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:fcf26c3c6d0da98fada8ae4ef0aa1c3405a431c0a77eb17306d38a89b02adcd7", size = 489574, upload-time = "2026-02-28T02:16:50.455Z" }, + { url = "https://files.pythonhosted.org/packages/77/83/0c8a5623a233015595e3da499c5a1c13720ac63c107897a6037bb97af248/regex-2026.2.28-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:02473c954af35dd2defeb07e44182f5705b30ea3f351a7cbffa9177beb14da5d", size = 291426, upload-time = "2026-02-28T02:16:52.52Z" }, + { url = "https://files.pythonhosted.org/packages/9e/06/3ef1ac6910dc3295ebd71b1f9bfa737e82cfead211a18b319d45f85ddd09/regex-2026.2.28-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:9b65d33a17101569f86d9c5966a8b1d7fbf8afdda5a8aa219301b0a80f58cf7d", size = 289200, upload-time = "2026-02-28T02:16:54.08Z" }, + { url = "https://files.pythonhosted.org/packages/dd/c9/8cc8d850b35ab5650ff6756a1cb85286e2000b66c97520b29c1587455344/regex-2026.2.28-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e71dcecaa113eebcc96622c17692672c2d104b1d71ddf7adeda90da7ddeb26fc", size = 796765, upload-time = "2026-02-28T02:16:55.905Z" }, + { url = "https://files.pythonhosted.org/packages/e9/5d/57702597627fc23278ebf36fbb497ac91c0ce7fec89ac6c81e420ca3e38c/regex-2026.2.28-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:481df4623fa4969c8b11f3433ed7d5e3dc9cec0f008356c3212b3933fb77e3d8", size = 863093, upload-time = "2026-02-28T02:16:58.094Z" }, + { url = "https://files.pythonhosted.org/packages/02/6d/f3ecad537ca2811b4d26b54ca848cf70e04fcfc138667c146a9f3157779c/regex-2026.2.28-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:64e7c6ad614573e0640f271e811a408d79a9e1fe62a46adb602f598df42a818d", size = 909455, upload-time = "2026-02-28T02:17:00.918Z" }, + { url = "https://files.pythonhosted.org/packages/9e/40/bb226f203caa22c1043c1ca79b36340156eca0f6a6742b46c3bb222a3a57/regex-2026.2.28-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d6b08a06976ff4fb0d83077022fde3eca06c55432bb997d8c0495b9a4e9872f4", size = 802037, upload-time = "2026-02-28T02:17:02.842Z" }, + { url = "https://files.pythonhosted.org/packages/44/7c/c6d91d8911ac6803b45ca968e8e500c46934e58c0903cbc6d760ee817a0a/regex-2026.2.28-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:864cdd1a2ef5716b0ab468af40139e62ede1b3a53386b375ec0786bb6783fc05", size = 775113, upload-time = "2026-02-28T02:17:04.506Z" }, + { url = "https://files.pythonhosted.org/packages/dc/8d/4a9368d168d47abd4158580b8c848709667b1cd293ff0c0c277279543bd0/regex-2026.2.28-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:511f7419f7afab475fd4d639d4aedfc54205bcb0800066753ef68a59f0f330b5", size = 784194, upload-time = "2026-02-28T02:17:06.888Z" }, + { url = "https://files.pythonhosted.org/packages/cc/bf/2c72ab5d8b7be462cb1651b5cc333da1d0068740342f350fcca3bca31947/regex-2026.2.28-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:b42f7466e32bf15a961cf09f35fa6323cc72e64d3d2c990b10de1274a5da0a59", size = 856846, upload-time = "2026-02-28T02:17:09.11Z" }, + { url = "https://files.pythonhosted.org/packages/7c/f4/6b65c979bb6d09f51bb2d2a7bc85de73c01ec73335d7ddd202dcb8cd1c8f/regex-2026.2.28-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:8710d61737b0c0ce6836b1da7109f20d495e49b3809f30e27e9560be67a257bf", size = 763516, upload-time = "2026-02-28T02:17:11.004Z" }, + { url = "https://files.pythonhosted.org/packages/8e/32/29ea5e27400ee86d2cc2b4e80aa059df04eaf78b4f0c18576ae077aeff68/regex-2026.2.28-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:4390c365fd2d45278f45afd4673cb90f7285f5701607e3ad4274df08e36140ae", size = 849278, upload-time = "2026-02-28T02:17:12.693Z" }, + { url = "https://files.pythonhosted.org/packages/1d/91/3233d03b5f865111cd517e1c95ee8b43e8b428d61fa73764a80c9bb6f537/regex-2026.2.28-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:cb3b1db8ff6c7b8bf838ab05583ea15230cb2f678e569ab0e3a24d1e8320940b", size = 790068, upload-time = "2026-02-28T02:17:14.9Z" }, + { url = "https://files.pythonhosted.org/packages/76/92/abc706c1fb03b4580a09645b206a3fc032f5a9f457bc1a8038ac555658ab/regex-2026.2.28-cp312-cp312-win32.whl", hash = "sha256:f8ed9a5d4612df9d4de15878f0bc6aa7a268afbe5af21a3fdd97fa19516e978c", size = 266416, upload-time = "2026-02-28T02:17:17.15Z" }, + { url = "https://files.pythonhosted.org/packages/fa/06/2a6f7dff190e5fa9df9fb4acf2fdf17a1aa0f7f54596cba8de608db56b3a/regex-2026.2.28-cp312-cp312-win_amd64.whl", hash = "sha256:01d65fd24206c8e1e97e2e31b286c59009636c022eb5d003f52760b0f42155d4", size = 277297, upload-time = "2026-02-28T02:17:18.723Z" }, + { url = "https://files.pythonhosted.org/packages/b7/f0/58a2484851fadf284458fdbd728f580d55c1abac059ae9f048c63b92f427/regex-2026.2.28-cp312-cp312-win_arm64.whl", hash = "sha256:c0b5ccbb8ffb433939d248707d4a8b31993cb76ab1a0187ca886bf50e96df952", size = 270408, upload-time = "2026-02-28T02:17:20.328Z" }, + { url = "https://files.pythonhosted.org/packages/87/f6/dc9ef48c61b79c8201585bf37fa70cd781977da86e466cd94e8e95d2443b/regex-2026.2.28-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:6d63a07e5ec8ce7184452cb00c41c37b49e67dc4f73b2955b5b8e782ea970784", size = 489311, upload-time = "2026-02-28T02:17:22.591Z" }, + { url = "https://files.pythonhosted.org/packages/95/c8/c20390f2232d3f7956f420f4ef1852608ad57aa26c3dd78516cb9f3dc913/regex-2026.2.28-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e59bc8f30414d283ae8ee1617b13d8112e7135cb92830f0ec3688cb29152585a", size = 291285, upload-time = "2026-02-28T02:17:24.355Z" }, + { url = "https://files.pythonhosted.org/packages/d2/a6/ba1068a631ebd71a230e7d8013fcd284b7c89c35f46f34a7da02082141b1/regex-2026.2.28-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:de0cf053139f96219ccfabb4a8dd2d217c8c82cb206c91d9f109f3f552d6b43d", size = 289051, upload-time = "2026-02-28T02:17:26.722Z" }, + { url = "https://files.pythonhosted.org/packages/1d/1b/7cc3b7af4c244c204b7a80924bd3d85aecd9ba5bc82b485c5806ee8cda9e/regex-2026.2.28-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fb4db2f17e6484904f986c5a657cec85574c76b5c5e61c7aae9ffa1bc6224f95", size = 796842, upload-time = "2026-02-28T02:17:29.064Z" }, + { url = "https://files.pythonhosted.org/packages/24/87/26bd03efc60e0d772ac1e7b60a2e6325af98d974e2358f659c507d3c76db/regex-2026.2.28-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:52b017b35ac2214d0db5f4f90e303634dc44e4aba4bd6235a27f97ecbe5b0472", size = 863083, upload-time = "2026-02-28T02:17:31.363Z" }, + { url = "https://files.pythonhosted.org/packages/ae/54/aeaf4afb1aa0a65e40de52a61dc2ac5b00a83c6cb081c8a1d0dda74f3010/regex-2026.2.28-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:69fc560ccbf08a09dc9b52ab69cacfae51e0ed80dc5693078bdc97db2f91ae96", size = 909412, upload-time = "2026-02-28T02:17:33.248Z" }, + { url = "https://files.pythonhosted.org/packages/12/2f/049901def913954e640d199bbc6a7ca2902b6aeda0e5da9d17f114100ec2/regex-2026.2.28-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e61eea47230eba62a31f3e8a0e3164d0f37ef9f40529fb2c79361bc6b53d2a92", size = 802101, upload-time = "2026-02-28T02:17:35.053Z" }, + { url = "https://files.pythonhosted.org/packages/7d/a5/512fb9ff7f5b15ea204bb1967ebb649059446decacccb201381f9fa6aad4/regex-2026.2.28-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:4f5c0b182ad4269e7381b7c27fdb0408399881f7a92a4624fd5487f2971dfc11", size = 775260, upload-time = "2026-02-28T02:17:37.692Z" }, + { url = "https://files.pythonhosted.org/packages/d1/a8/9a92935878aba19bd72706b9db5646a6f993d99b3f6ed42c02ec8beb1d61/regex-2026.2.28-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:96f6269a2882fbb0ee76967116b83679dc628e68eaea44e90884b8d53d833881", size = 784311, upload-time = "2026-02-28T02:17:39.855Z" }, + { url = "https://files.pythonhosted.org/packages/09/d3/fc51a8a738a49a6b6499626580554c9466d3ea561f2b72cfdc72e4149773/regex-2026.2.28-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:b5acd4b6a95f37c3c3828e5d053a7d4edaedb85de551db0153754924cb7c83e3", size = 856876, upload-time = "2026-02-28T02:17:42.317Z" }, + { url = "https://files.pythonhosted.org/packages/08/b7/2e641f3d084b120ca4c52e8c762a78da0b32bf03ef546330db3e2635dc5f/regex-2026.2.28-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:2234059cfe33d9813a3677ef7667999caea9eeaa83fef98eb6ce15c6cf9e0215", size = 763632, upload-time = "2026-02-28T02:17:45.073Z" }, + { url = "https://files.pythonhosted.org/packages/fe/6d/0009021d97e79ee99f3d8641f0a8d001eed23479ade4c3125a5480bf3e2d/regex-2026.2.28-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:c15af43c72a7fb0c97cbc66fa36a43546eddc5c06a662b64a0cbf30d6ac40944", size = 849320, upload-time = "2026-02-28T02:17:47.192Z" }, + { url = "https://files.pythonhosted.org/packages/05/7a/51cfbad5758f8edae430cb21961a9c8d04bce1dae4d2d18d4186eec7cfa1/regex-2026.2.28-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9185cc63359862a6e80fe97f696e04b0ad9a11c4ac0a4a927f979f611bfe3768", size = 790152, upload-time = "2026-02-28T02:17:49.067Z" }, + { url = "https://files.pythonhosted.org/packages/90/3d/a83e2b6b3daa142acb8c41d51de3876186307d5cb7490087031747662500/regex-2026.2.28-cp313-cp313-win32.whl", hash = "sha256:fb66e5245db9652abd7196ace599b04d9c0e4aa7c8f0e2803938377835780081", size = 266398, upload-time = "2026-02-28T02:17:50.744Z" }, + { url = "https://files.pythonhosted.org/packages/85/4f/16e9ebb1fe5425e11b9596c8d57bf8877dcb32391da0bfd33742e3290637/regex-2026.2.28-cp313-cp313-win_amd64.whl", hash = "sha256:71a911098be38c859ceb3f9a9ce43f4ed9f4c6720ad8684a066ea246b76ad9ff", size = 277282, upload-time = "2026-02-28T02:17:53.074Z" }, + { url = "https://files.pythonhosted.org/packages/07/b4/92851335332810c5a89723bf7a7e35c7209f90b7d4160024501717b28cc9/regex-2026.2.28-cp313-cp313-win_arm64.whl", hash = "sha256:39bb5727650b9a0275c6a6690f9bb3fe693a7e6cc5c3155b1240aedf8926423e", size = 270382, upload-time = "2026-02-28T02:17:54.888Z" }, + { url = "https://files.pythonhosted.org/packages/24/07/6c7e4cec1e585959e96cbc24299d97e4437a81173217af54f1804994e911/regex-2026.2.28-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:97054c55db06ab020342cc0d35d6f62a465fa7662871190175f1ad6c655c028f", size = 492541, upload-time = "2026-02-28T02:17:56.813Z" }, + { url = "https://files.pythonhosted.org/packages/7c/13/55eb22ada7f43d4f4bb3815b6132183ebc331c81bd496e2d1f3b8d862e0d/regex-2026.2.28-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0d25a10811de831c2baa6aef3c0be91622f44dd8d31dd12e69f6398efb15e48b", size = 292984, upload-time = "2026-02-28T02:17:58.538Z" }, + { url = "https://files.pythonhosted.org/packages/5b/11/c301f8cb29ce9644a5ef85104c59244e6e7e90994a0f458da4d39baa8e17/regex-2026.2.28-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:d6cfe798d8da41bb1862ed6e0cba14003d387c3c0c4a5d45591076ae9f0ce2f8", size = 291509, upload-time = "2026-02-28T02:18:00.208Z" }, + { url = "https://files.pythonhosted.org/packages/b5/43/aabe384ec1994b91796e903582427bc2ffaed9c4103819ed3c16d8e749f3/regex-2026.2.28-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fd0ce43e71d825b7c0661f9c54d4d74bd97c56c3fd102a8985bcfea48236bacb", size = 809429, upload-time = "2026-02-28T02:18:02.328Z" }, + { url = "https://files.pythonhosted.org/packages/04/b8/8d2d987a816720c4f3109cee7c06a4b24ad0e02d4fc74919ab619e543737/regex-2026.2.28-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:00945d007fd74a9084d2ab79b695b595c6b7ba3698972fadd43e23230c6979c1", size = 869422, upload-time = "2026-02-28T02:18:04.23Z" }, + { url = "https://files.pythonhosted.org/packages/fc/ad/2c004509e763c0c3719f97c03eca26473bffb3868d54c5f280b8cd4f9e3d/regex-2026.2.28-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:bec23c11cbbf09a4df32fe50d57cbdd777bc442269b6e39a1775654f1c95dee2", size = 915175, upload-time = "2026-02-28T02:18:06.791Z" }, + { url = "https://files.pythonhosted.org/packages/55/c2/fd429066da487ef555a9da73bf214894aec77fc8c66a261ee355a69871a8/regex-2026.2.28-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5cdcc17d935c8f9d3f4db5c2ebe2640c332e3822ad5d23c2f8e0228e6947943a", size = 812044, upload-time = "2026-02-28T02:18:08.736Z" }, + { url = "https://files.pythonhosted.org/packages/5b/ca/feedb7055c62a3f7f659971bf45f0e0a87544b6b0cf462884761453f97c5/regex-2026.2.28-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a448af01e3d8031c89c5d902040b124a5e921a25c4e5e07a861ca591ce429341", size = 782056, upload-time = "2026-02-28T02:18:10.777Z" }, + { url = "https://files.pythonhosted.org/packages/95/30/1aa959ed0d25c1dd7dd5047ea8ba482ceaef38ce363c401fd32a6b923e60/regex-2026.2.28-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:10d28e19bd4888e4abf43bd3925f3c134c52fdf7259219003588a42e24c2aa25", size = 798743, upload-time = "2026-02-28T02:18:13.025Z" }, + { url = "https://files.pythonhosted.org/packages/3b/1f/dadb9cf359004784051c897dcf4d5d79895f73a1bbb7b827abaa4814ae80/regex-2026.2.28-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:99985a2c277dcb9ccb63f937451af5d65177af1efdeb8173ac55b61095a0a05c", size = 864633, upload-time = "2026-02-28T02:18:16.84Z" }, + { url = "https://files.pythonhosted.org/packages/a7/f1/b9a25eb24e1cf79890f09e6ec971ee5b511519f1851de3453bc04f6c902b/regex-2026.2.28-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:e1e7b24cb3ae9953a560c563045d1ba56ee4749fbd05cf21ba571069bd7be81b", size = 770862, upload-time = "2026-02-28T02:18:18.892Z" }, + { url = "https://files.pythonhosted.org/packages/02/9a/c5cb10b7aa6f182f9247a30cc9527e326601f46f4df864ac6db588d11fcd/regex-2026.2.28-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:d8511a01d0e4ee1992eb3ba19e09bc1866fe03f05129c3aec3fdc4cbc77aad3f", size = 854788, upload-time = "2026-02-28T02:18:21.475Z" }, + { url = "https://files.pythonhosted.org/packages/0a/50/414ba0731c4bd40b011fa4703b2cc86879ec060c64f2a906e65a56452589/regex-2026.2.28-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:aaffaecffcd2479ce87aa1e74076c221700b7c804e48e98e62500ee748f0f550", size = 800184, upload-time = "2026-02-28T02:18:23.492Z" }, + { url = "https://files.pythonhosted.org/packages/69/50/0c7290987f97e7e6830b0d853f69dc4dc5852c934aae63e7fdcd76b4c383/regex-2026.2.28-cp313-cp313t-win32.whl", hash = "sha256:ef77bdde9c9eba3f7fa5b58084b29bbcc74bcf55fdbeaa67c102a35b5bd7e7cc", size = 269137, upload-time = "2026-02-28T02:18:25.375Z" }, + { url = "https://files.pythonhosted.org/packages/68/80/ef26ff90e74ceb4051ad6efcbbb8a4be965184a57e879ebcbdef327d18fa/regex-2026.2.28-cp313-cp313t-win_amd64.whl", hash = "sha256:98adf340100cbe6fbaf8e6dc75e28f2c191b1be50ffefe292fb0e6f6eefdb0d8", size = 280682, upload-time = "2026-02-28T02:18:27.205Z" }, + { url = "https://files.pythonhosted.org/packages/69/8b/fbad9c52e83ffe8f97e3ed1aa0516e6dff6bb633a41da9e64645bc7efdc5/regex-2026.2.28-cp313-cp313t-win_arm64.whl", hash = "sha256:2fb950ac1d88e6b6a9414381f403797b236f9fa17e1eee07683af72b1634207b", size = 271735, upload-time = "2026-02-28T02:18:29.015Z" }, + { url = "https://files.pythonhosted.org/packages/cf/03/691015f7a7cb1ed6dacb2ea5de5682e4858e05a4c5506b2839cd533bbcd6/regex-2026.2.28-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:78454178c7df31372ea737996fb7f36b3c2c92cccc641d251e072478afb4babc", size = 489497, upload-time = "2026-02-28T02:18:30.889Z" }, + { url = "https://files.pythonhosted.org/packages/c6/ba/8db8fd19afcbfa0e1036eaa70c05f20ca8405817d4ad7a38a6b4c2f031ac/regex-2026.2.28-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:5d10303dd18cedfd4d095543998404df656088240bcfd3cd20a8f95b861f74bd", size = 291295, upload-time = "2026-02-28T02:18:33.426Z" }, + { url = "https://files.pythonhosted.org/packages/5a/79/9aa0caf089e8defef9b857b52fc53801f62ff868e19e5c83d4a96612eba1/regex-2026.2.28-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:19a9c9e0a8f24f39d575a6a854d516b48ffe4cbdcb9de55cb0570a032556ecff", size = 289275, upload-time = "2026-02-28T02:18:35.247Z" }, + { url = "https://files.pythonhosted.org/packages/eb/26/ee53117066a30ef9c883bf1127eece08308ccf8ccd45c45a966e7a665385/regex-2026.2.28-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:09500be324f49b470d907b3ef8af9afe857f5cca486f853853f7945ddbf75911", size = 797176, upload-time = "2026-02-28T02:18:37.15Z" }, + { url = "https://files.pythonhosted.org/packages/05/1b/67fb0495a97259925f343ae78b5d24d4a6624356ae138b57f18bd43006e4/regex-2026.2.28-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:fb1c4ff62277d87a7335f2c1ea4e0387b8f2b3ad88a64efd9943906aafad4f33", size = 863813, upload-time = "2026-02-28T02:18:39.478Z" }, + { url = "https://files.pythonhosted.org/packages/a0/1d/93ac9bbafc53618091c685c7ed40239a90bf9f2a82c983f0baa97cb7ae07/regex-2026.2.28-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b8b3f1be1738feadc69f62daa250c933e85c6f34fa378f54a7ff43807c1b9117", size = 908678, upload-time = "2026-02-28T02:18:41.619Z" }, + { url = "https://files.pythonhosted.org/packages/c7/7a/a8f5e0561702b25239846a16349feece59712ae20598ebb205580332a471/regex-2026.2.28-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:dc8ed8c3f41c27acb83f7b6a9eb727a73fc6663441890c5cb3426a5f6a91ce7d", size = 801528, upload-time = "2026-02-28T02:18:43.624Z" }, + { url = "https://files.pythonhosted.org/packages/96/5d/ed6d4cbde80309854b1b9f42d9062fee38ade15f7eb4909f6ef2440403b5/regex-2026.2.28-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:fa539be029844c0ce1114762d2952ab6cfdd7c7c9bd72e0db26b94c3c36dcc5a", size = 775373, upload-time = "2026-02-28T02:18:46.102Z" }, + { url = "https://files.pythonhosted.org/packages/6a/e9/6e53c34e8068b9deec3e87210086ecb5b9efebdefca6b0d3fa43d66dcecb/regex-2026.2.28-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7900157786428a79615a8264dac1f12c9b02957c473c8110c6b1f972dcecaddf", size = 784859, upload-time = "2026-02-28T02:18:48.269Z" }, + { url = "https://files.pythonhosted.org/packages/48/3c/736e1c7ca7f0dcd2ae33819888fdc69058a349b7e5e84bc3e2f296bbf794/regex-2026.2.28-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:0b1d2b07614d95fa2bf8a63fd1e98bd8fa2b4848dc91b1efbc8ba219fdd73952", size = 857813, upload-time = "2026-02-28T02:18:50.576Z" }, + { url = "https://files.pythonhosted.org/packages/6e/7c/48c4659ad9da61f58e79dbe8c05223e0006696b603c16eb6b5cbfbb52c27/regex-2026.2.28-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:b389c61aa28a79c2e0527ac36da579869c2e235a5b208a12c5b5318cda2501d8", size = 763705, upload-time = "2026-02-28T02:18:52.59Z" }, + { url = "https://files.pythonhosted.org/packages/cf/a1/bc1c261789283128165f71b71b4b221dd1b79c77023752a6074c102f18d8/regex-2026.2.28-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:f467cb602f03fbd1ab1908f68b53c649ce393fde056628dc8c7e634dab6bfc07", size = 848734, upload-time = "2026-02-28T02:18:54.595Z" }, + { url = "https://files.pythonhosted.org/packages/10/d8/979407faf1397036e25a5ae778157366a911c0f382c62501009f4957cf86/regex-2026.2.28-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:e8c8cb2deba42f5ec1ede46374e990f8adc5e6456a57ac1a261b19be6f28e4e6", size = 789871, upload-time = "2026-02-28T02:18:57.34Z" }, + { url = "https://files.pythonhosted.org/packages/03/23/da716821277115fcb1f4e3de1e5dc5023a1e6533598c486abf5448612579/regex-2026.2.28-cp314-cp314-win32.whl", hash = "sha256:9036b400b20e4858d56d117108d7813ed07bb7803e3eed766675862131135ca6", size = 271825, upload-time = "2026-02-28T02:18:59.202Z" }, + { url = "https://files.pythonhosted.org/packages/91/ff/90696f535d978d5f16a52a419be2770a8d8a0e7e0cfecdbfc31313df7fab/regex-2026.2.28-cp314-cp314-win_amd64.whl", hash = "sha256:1d367257cd86c1cbb97ea94e77b373a0bbc2224976e247f173d19e8f18b4afa7", size = 280548, upload-time = "2026-02-28T02:19:01.049Z" }, + { url = "https://files.pythonhosted.org/packages/69/f9/5e1b5652fc0af3fcdf7677e7df3ad2a0d47d669b34ac29a63bb177bb731b/regex-2026.2.28-cp314-cp314-win_arm64.whl", hash = "sha256:5e68192bb3a1d6fb2836da24aa494e413ea65853a21505e142e5b1064a595f3d", size = 273444, upload-time = "2026-02-28T02:19:03.255Z" }, + { url = "https://files.pythonhosted.org/packages/d3/eb/8389f9e940ac89bcf58d185e230a677b4fd07c5f9b917603ad5c0f8fa8fe/regex-2026.2.28-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:a5dac14d0872eeb35260a8e30bac07ddf22adc1e3a0635b52b02e180d17c9c7e", size = 492546, upload-time = "2026-02-28T02:19:05.378Z" }, + { url = "https://files.pythonhosted.org/packages/7b/c7/09441d27ce2a6fa6a61ea3150ea4639c1dcda9b31b2ea07b80d6937b24dd/regex-2026.2.28-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:ec0c608b7a7465ffadb344ed7c987ff2f11ee03f6a130b569aa74d8a70e8333c", size = 292986, upload-time = "2026-02-28T02:19:07.24Z" }, + { url = "https://files.pythonhosted.org/packages/fb/69/4144b60ed7760a6bd235e4087041f487aa4aa62b45618ce018b0c14833ea/regex-2026.2.28-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c7815afb0ca45456613fdaf60ea9c993715511c8d53a83bc468305cbc0ee23c7", size = 291518, upload-time = "2026-02-28T02:19:09.698Z" }, + { url = "https://files.pythonhosted.org/packages/2d/be/77e5426cf5948c82f98c53582009ca9e94938c71f73a8918474f2e2990bb/regex-2026.2.28-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b059e71ec363968671693a78c5053bd9cb2fe410f9b8e4657e88377ebd603a2e", size = 809464, upload-time = "2026-02-28T02:19:12.494Z" }, + { url = "https://files.pythonhosted.org/packages/45/99/2c8c5ac90dc7d05c6e7d8e72c6a3599dc08cd577ac476898e91ca787d7f1/regex-2026.2.28-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b8cf76f1a29f0e99dcfd7aef1551a9827588aae5a737fe31442021165f1920dc", size = 869553, upload-time = "2026-02-28T02:19:15.151Z" }, + { url = "https://files.pythonhosted.org/packages/53/34/daa66a342f0271e7737003abf6c3097aa0498d58c668dbd88362ef94eb5d/regex-2026.2.28-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:180e08a435a0319e6a4821c3468da18dc7001987e1c17ae1335488dfe7518dd8", size = 915289, upload-time = "2026-02-28T02:19:17.331Z" }, + { url = "https://files.pythonhosted.org/packages/c5/c7/e22c2aaf0a12e7e22ab19b004bb78d32ca1ecc7ef245949935463c5567de/regex-2026.2.28-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1e496956106fd59ba6322a8ea17141a27c5040e5ee8f9433ae92d4e5204462a0", size = 812156, upload-time = "2026-02-28T02:19:20.011Z" }, + { url = "https://files.pythonhosted.org/packages/7f/bb/2dc18c1efd9051cf389cd0d7a3a4d90f6804b9fff3a51b5dc3c85b935f71/regex-2026.2.28-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bba2b18d70eeb7b79950f12f633beeecd923f7c9ad6f6bae28e59b4cb3ab046b", size = 782215, upload-time = "2026-02-28T02:19:22.047Z" }, + { url = "https://files.pythonhosted.org/packages/17/1e/9e4ec9b9013931faa32226ec4aa3c71fe664a6d8a2b91ac56442128b332f/regex-2026.2.28-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:6db7bfae0f8a2793ff1f7021468ea55e2699d0790eb58ee6ab36ae43aa00bc5b", size = 798925, upload-time = "2026-02-28T02:19:24.173Z" }, + { url = "https://files.pythonhosted.org/packages/71/57/a505927e449a9ccb41e2cc8d735e2abe3444b0213d1cf9cb364a8c1f2524/regex-2026.2.28-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:d0b02e8b7e5874b48ae0f077ecca61c1a6a9f9895e9c6dfb191b55b242862033", size = 864701, upload-time = "2026-02-28T02:19:26.376Z" }, + { url = "https://files.pythonhosted.org/packages/a6/ad/c62cb60cdd93e13eac5b3d9d6bd5d284225ed0e3329426f94d2552dd7cca/regex-2026.2.28-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:25b6eb660c5cf4b8c3407a1ed462abba26a926cc9965e164268a3267bcc06a43", size = 770899, upload-time = "2026-02-28T02:19:29.38Z" }, + { url = "https://files.pythonhosted.org/packages/3c/5a/874f861f5c3d5ab99633e8030dee1bc113db8e0be299d1f4b07f5b5ec349/regex-2026.2.28-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:5a932ea8ad5d0430351ff9c76c8db34db0d9f53c1d78f06022a21f4e290c5c18", size = 854727, upload-time = "2026-02-28T02:19:31.494Z" }, + { url = "https://files.pythonhosted.org/packages/6b/ca/d2c03b0efde47e13db895b975b2be6a73ed90b8ba963677927283d43bf74/regex-2026.2.28-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:1c2c95e1a2b0f89d01e821ff4de1be4b5d73d1f4b0bf679fa27c1ad8d2327f1a", size = 800366, upload-time = "2026-02-28T02:19:34.248Z" }, + { url = "https://files.pythonhosted.org/packages/14/bd/ee13b20b763b8989f7c75d592bfd5de37dc1181814a2a2747fedcf97e3ba/regex-2026.2.28-cp314-cp314t-win32.whl", hash = "sha256:bbb882061f742eb5d46f2f1bd5304055be0a66b783576de3d7eef1bed4778a6e", size = 274936, upload-time = "2026-02-28T02:19:36.313Z" }, + { url = "https://files.pythonhosted.org/packages/cb/e7/d8020e39414c93af7f0d8688eabcecece44abfd5ce314b21dfda0eebd3d8/regex-2026.2.28-cp314-cp314t-win_amd64.whl", hash = "sha256:6591f281cb44dc13de9585b552cec6fc6cf47fb2fe7a48892295ee9bc4a612f9", size = 284779, upload-time = "2026-02-28T02:19:38.625Z" }, + { url = "https://files.pythonhosted.org/packages/13/c0/ad225f4a405827486f1955283407cf758b6d2fb966712644c5f5aef33d1b/regex-2026.2.28-cp314-cp314t-win_arm64.whl", hash = "sha256:dee50f1be42222f89767b64b283283ef963189da0dda4a515aa54a5563c62dec", size = 275010, upload-time = "2026-02-28T02:19:40.65Z" }, +] + [[package]] name = "requests" version = "2.32.5" @@ -530,6 +2119,41 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/1e/db/4254e3eabe8020b458f1a747140d32277ec7a271daf1d235b70dc0b4e6e3/requests-2.32.5-py3-none-any.whl", hash = "sha256:2462f94637a34fd532264295e186976db0f5d453d1cdd31473c85a6a161affb6", size = 64738, upload-time = "2025-08-18T20:46:00.542Z" }, ] +[[package]] +name = "rich" +version = "14.3.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markdown-it-py" }, + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b3/c6/f3b320c27991c46f43ee9d856302c70dc2d0fb2dba4842ff739d5f46b393/rich-14.3.3.tar.gz", hash = "sha256:b8daa0b9e4eef54dd8cf7c86c03713f53241884e814f4e2f5fb342fe520f639b", size = 230582, upload-time = "2026-02-19T17:23:12.474Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/14/25/b208c5683343959b670dc001595f2f3737e051da617f66c31f7c4fa93abc/rich-14.3.3-py3-none-any.whl", hash = "sha256:793431c1f8619afa7d3b52b2cdec859562b950ea0d4b6b505397612db8d5362d", size = 310458, upload-time = "2026-02-19T17:23:13.732Z" }, +] + +[[package]] +name = "safetensors" +version = "0.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/29/9c/6e74567782559a63bd040a236edca26fd71bc7ba88de2ef35d75df3bca5e/safetensors-0.7.0.tar.gz", hash = "sha256:07663963b67e8bd9f0b8ad15bb9163606cd27cc5a1b96235a50d8369803b96b0", size = 200878, upload-time = "2025-11-19T15:18:43.199Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fa/47/aef6c06649039accf914afef490268e1067ed82be62bcfa5b7e886ad15e8/safetensors-0.7.0-cp38-abi3-macosx_10_12_x86_64.whl", hash = "sha256:c82f4d474cf725255d9e6acf17252991c3c8aac038d6ef363a4bf8be2f6db517", size = 467781, upload-time = "2025-11-19T15:18:35.84Z" }, + { url = "https://files.pythonhosted.org/packages/e8/00/374c0c068e30cd31f1e1b46b4b5738168ec79e7689ca82ee93ddfea05109/safetensors-0.7.0-cp38-abi3-macosx_11_0_arm64.whl", hash = "sha256:94fd4858284736bb67a897a41608b5b0c2496c9bdb3bf2af1fa3409127f20d57", size = 447058, upload-time = "2025-11-19T15:18:34.416Z" }, + { url = "https://files.pythonhosted.org/packages/f1/06/578ffed52c2296f93d7fd2d844cabfa92be51a587c38c8afbb8ae449ca89/safetensors-0.7.0-cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e07d91d0c92a31200f25351f4acb2bc6aff7f48094e13ebb1d0fb995b54b6542", size = 491748, upload-time = "2025-11-19T15:18:09.79Z" }, + { url = "https://files.pythonhosted.org/packages/ae/33/1debbbb70e4791dde185edb9413d1fe01619255abb64b300157d7f15dddd/safetensors-0.7.0-cp38-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:8469155f4cb518bafb4acf4865e8bb9d6804110d2d9bdcaa78564b9fd841e104", size = 503881, upload-time = "2025-11-19T15:18:16.145Z" }, + { url = "https://files.pythonhosted.org/packages/8e/1c/40c2ca924d60792c3be509833df711b553c60effbd91da6f5284a83f7122/safetensors-0.7.0-cp38-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:54bef08bf00a2bff599982f6b08e8770e09cc012d7bba00783fc7ea38f1fb37d", size = 623463, upload-time = "2025-11-19T15:18:21.11Z" }, + { url = "https://files.pythonhosted.org/packages/9b/3a/13784a9364bd43b0d61eef4bea2845039bc2030458b16594a1bd787ae26e/safetensors-0.7.0-cp38-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:42cb091236206bb2016d245c377ed383aa7f78691748f3bb6ee1bfa51ae2ce6a", size = 532855, upload-time = "2025-11-19T15:18:25.719Z" }, + { url = "https://files.pythonhosted.org/packages/a0/60/429e9b1cb3fc651937727befe258ea24122d9663e4d5709a48c9cbfceecb/safetensors-0.7.0-cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dac7252938f0696ddea46f5e855dd3138444e82236e3be475f54929f0c510d48", size = 507152, upload-time = "2025-11-19T15:18:33.023Z" }, + { url = "https://files.pythonhosted.org/packages/3c/a8/4b45e4e059270d17af60359713ffd83f97900d45a6afa73aaa0d737d48b6/safetensors-0.7.0-cp38-abi3-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1d060c70284127fa805085d8f10fbd0962792aed71879d00864acda69dbab981", size = 541856, upload-time = "2025-11-19T15:18:31.075Z" }, + { url = "https://files.pythonhosted.org/packages/06/87/d26d8407c44175d8ae164a95b5a62707fcc445f3c0c56108e37d98070a3d/safetensors-0.7.0-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:cdab83a366799fa730f90a4ebb563e494f28e9e92c4819e556152ad55e43591b", size = 674060, upload-time = "2025-11-19T15:18:37.211Z" }, + { url = "https://files.pythonhosted.org/packages/11/f5/57644a2ff08dc6325816ba7217e5095f17269dada2554b658442c66aed51/safetensors-0.7.0-cp38-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:672132907fcad9f2aedcb705b2d7b3b93354a2aec1b2f706c4db852abe338f85", size = 771715, upload-time = "2025-11-19T15:18:38.689Z" }, + { url = "https://files.pythonhosted.org/packages/86/31/17883e13a814bd278ae6e266b13282a01049b0c81341da7fd0e3e71a80a3/safetensors-0.7.0-cp38-abi3-musllinux_1_2_i686.whl", hash = "sha256:5d72abdb8a4d56d4020713724ba81dac065fedb7f3667151c4a637f1d3fb26c0", size = 714377, upload-time = "2025-11-19T15:18:40.162Z" }, + { url = "https://files.pythonhosted.org/packages/4a/d8/0c8a7dc9b41dcac53c4cbf9df2b9c83e0e0097203de8b37a712b345c0be5/safetensors-0.7.0-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:b0f6d66c1c538d5a94a73aa9ddca8ccc4227e6c9ff555322ea40bdd142391dd4", size = 677368, upload-time = "2025-11-19T15:18:41.627Z" }, + { url = "https://files.pythonhosted.org/packages/05/e5/cb4b713c8a93469e3c5be7c3f8d77d307e65fe89673e731f5c2bfd0a9237/safetensors-0.7.0-cp38-abi3-win32.whl", hash = "sha256:c74af94bf3ac15ac4d0f2a7c7b4663a15f8c2ab15ed0fc7531ca61d0835eccba", size = 326423, upload-time = "2025-11-19T15:18:45.74Z" }, + { url = "https://files.pythonhosted.org/packages/5d/e6/ec8471c8072382cb91233ba7267fd931219753bb43814cbc71757bfd4dab/safetensors-0.7.0-cp38-abi3-win_amd64.whl", hash = "sha256:d1239932053f56f3456f32eb9625590cc7582e905021f94636202a864d470755", size = 341380, upload-time = "2025-11-19T15:18:44.427Z" }, +] + [[package]] name = "scipy" version = "1.17.1" @@ -539,16 +2163,6 @@ dependencies = [ ] sdist = { url = "https://files.pythonhosted.org/packages/7a/97/5a3609c4f8d58b039179648e62dd220f89864f56f7357f5d4f45c29eb2cc/scipy-1.17.1.tar.gz", hash = "sha256:95d8e012d8cb8816c226aef832200b1d45109ed4464303e997c5b13122b297c0", size = 30573822, upload-time = "2026-02-23T00:26:24.851Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/df/75/b4ce781849931fef6fd529afa6b63711d5a733065722d0c3e2724af9e40a/scipy-1.17.1-cp311-cp311-macosx_10_14_x86_64.whl", hash = "sha256:1f95b894f13729334fb990162e911c9e5dc1ab390c58aa6cbecb389c5b5e28ec", size = 31613675, upload-time = "2026-02-23T00:16:00.13Z" }, - { url = "https://files.pythonhosted.org/packages/f7/58/bccc2861b305abdd1b8663d6130c0b3d7cc22e8d86663edbc8401bfd40d4/scipy-1.17.1-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:e18f12c6b0bc5a592ed23d3f7b891f68fd7f8241d69b7883769eb5d5dfb52696", size = 28162057, upload-time = "2026-02-23T00:16:09.456Z" }, - { url = "https://files.pythonhosted.org/packages/6d/ee/18146b7757ed4976276b9c9819108adbc73c5aad636e5353e20746b73069/scipy-1.17.1-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:a3472cfbca0a54177d0faa68f697d8ba4c80bbdc19908c3465556d9f7efce9ee", size = 20334032, upload-time = "2026-02-23T00:16:17.358Z" }, - { url = "https://files.pythonhosted.org/packages/ec/e6/cef1cf3557f0c54954198554a10016b6a03b2ec9e22a4e1df734936bd99c/scipy-1.17.1-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:766e0dc5a616d026a3a1cffa379af959671729083882f50307e18175797b3dfd", size = 22709533, upload-time = "2026-02-23T00:16:25.791Z" }, - { url = "https://files.pythonhosted.org/packages/4d/60/8804678875fc59362b0fb759ab3ecce1f09c10a735680318ac30da8cd76b/scipy-1.17.1-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:744b2bf3640d907b79f3fd7874efe432d1cf171ee721243e350f55234b4cec4c", size = 33062057, upload-time = "2026-02-23T00:16:36.931Z" }, - { url = "https://files.pythonhosted.org/packages/09/7d/af933f0f6e0767995b4e2d705a0665e454d1c19402aa7e895de3951ebb04/scipy-1.17.1-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:43af8d1f3bea642559019edfe64e9b11192a8978efbd1539d7bc2aaa23d92de4", size = 35349300, upload-time = "2026-02-23T00:16:49.108Z" }, - { url = "https://files.pythonhosted.org/packages/b4/3d/7ccbbdcbb54c8fdc20d3b6930137c782a163fa626f0aef920349873421ba/scipy-1.17.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:cd96a1898c0a47be4520327e01f874acfd61fb48a9420f8aa9f6483412ffa444", size = 35127333, upload-time = "2026-02-23T00:17:01.293Z" }, - { url = "https://files.pythonhosted.org/packages/e8/19/f926cb11c42b15ba08e3a71e376d816ac08614f769b4f47e06c3580c836a/scipy-1.17.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:4eb6c25dd62ee8d5edf68a8e1c171dd71c292fdae95d8aeb3dd7d7de4c364082", size = 37741314, upload-time = "2026-02-23T00:17:12.576Z" }, - { url = "https://files.pythonhosted.org/packages/95/da/0d1df507cf574b3f224ccc3d45244c9a1d732c81dcb26b1e8a766ae271a8/scipy-1.17.1-cp311-cp311-win_amd64.whl", hash = "sha256:d30e57c72013c2a4fe441c2fcb8e77b14e152ad48b5464858e07e2ad9fbfceff", size = 36607512, upload-time = "2026-02-23T00:17:23.424Z" }, - { url = "https://files.pythonhosted.org/packages/68/7f/bdd79ceaad24b671543ffe0ef61ed8e659440eb683b66f033454dcee90eb/scipy-1.17.1-cp311-cp311-win_arm64.whl", hash = "sha256:9ecb4efb1cd6e8c4afea0daa91a87fbddbce1b99d2895d151596716c0b2e859d", size = 24599248, upload-time = "2026-02-23T00:17:34.561Z" }, { url = "https://files.pythonhosted.org/packages/35/48/b992b488d6f299dbe3f11a20b24d3dda3d46f1a635ede1c46b5b17a7b163/scipy-1.17.1-cp312-cp312-macosx_10_14_x86_64.whl", hash = "sha256:35c3a56d2ef83efc372eaec584314bd0ef2e2f0d2adb21c55e6ad5b344c0dcb8", size = 31610954, upload-time = "2026-02-23T00:17:49.855Z" }, { url = "https://files.pythonhosted.org/packages/b2/02/cf107b01494c19dc100f1d0b7ac3cc08666e96ba2d64db7626066cee895e/scipy-1.17.1-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:fcb310ddb270a06114bb64bbe53c94926b943f5b7f0842194d585c65eb4edd76", size = 28172662, upload-time = "2026-02-23T00:18:01.64Z" }, { url = "https://files.pythonhosted.org/packages/cf/a9/599c28631bad314d219cf9ffd40e985b24d603fc8a2f4ccc5ae8419a535b/scipy-1.17.1-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:cc90d2e9c7e5c7f1a482c9875007c095c3194b1cfedca3c2f3291cdc2bc7c086", size = 20344366, upload-time = "2026-02-23T00:18:12.015Z" }, @@ -559,6 +2173,64 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/65/94/7698add8f276dbab7a9de9fb6b0e02fc13ee61d51c7c3f85ac28b65e1239/scipy-1.17.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:f590cd684941912d10becc07325a3eeb77886fe981415660d9265c4c418d0bea", size = 37625856, upload-time = "2026-02-23T00:19:00.307Z" }, { url = "https://files.pythonhosted.org/packages/a2/84/dc08d77fbf3d87d3ee27f6a0c6dcce1de5829a64f2eae85a0ecc1f0daa73/scipy-1.17.1-cp312-cp312-win_amd64.whl", hash = "sha256:41b71f4a3a4cab9d366cd9065b288efc4d4f3c0b37a91a8e0947fb5bd7f31d87", size = 36549682, upload-time = "2026-02-23T00:19:07.67Z" }, { url = "https://files.pythonhosted.org/packages/bc/98/fe9ae9ffb3b54b62559f52dedaebe204b408db8109a8c66fdd04869e6424/scipy-1.17.1-cp312-cp312-win_arm64.whl", hash = "sha256:f4115102802df98b2b0db3cce5cb9b92572633a1197c77b7553e5203f284a5b3", size = 24547340, upload-time = "2026-02-23T00:19:12.024Z" }, + { url = "https://files.pythonhosted.org/packages/76/27/07ee1b57b65e92645f219b37148a7e7928b82e2b5dbeccecb4dff7c64f0b/scipy-1.17.1-cp313-cp313-macosx_10_14_x86_64.whl", hash = "sha256:5e3c5c011904115f88a39308379c17f91546f77c1667cea98739fe0fccea804c", size = 31590199, upload-time = "2026-02-23T00:19:17.192Z" }, + { url = "https://files.pythonhosted.org/packages/ec/ae/db19f8ab842e9b724bf5dbb7db29302a91f1e55bc4d04b1025d6d605a2c5/scipy-1.17.1-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:6fac755ca3d2c3edcb22f479fceaa241704111414831ddd3bc6056e18516892f", size = 28154001, upload-time = "2026-02-23T00:19:22.241Z" }, + { url = "https://files.pythonhosted.org/packages/5b/58/3ce96251560107b381cbd6e8413c483bbb1228a6b919fa8652b0d4090e7f/scipy-1.17.1-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:7ff200bf9d24f2e4d5dc6ee8c3ac64d739d3a89e2326ba68aaf6c4a2b838fd7d", size = 20325719, upload-time = "2026-02-23T00:19:26.329Z" }, + { url = "https://files.pythonhosted.org/packages/b2/83/15087d945e0e4d48ce2377498abf5ad171ae013232ae31d06f336e64c999/scipy-1.17.1-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:4b400bdc6f79fa02a4d86640310dde87a21fba0c979efff5248908c6f15fad1b", size = 22683595, upload-time = "2026-02-23T00:19:30.304Z" }, + { url = "https://files.pythonhosted.org/packages/b4/e0/e58fbde4a1a594c8be8114eb4aac1a55bcd6587047efc18a61eb1f5c0d30/scipy-1.17.1-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2b64ca7d4aee0102a97f3ba22124052b4bd2152522355073580bf4845e2550b6", size = 32896429, upload-time = "2026-02-23T00:19:35.536Z" }, + { url = "https://files.pythonhosted.org/packages/f5/5f/f17563f28ff03c7b6799c50d01d5d856a1d55f2676f537ca8d28c7f627cd/scipy-1.17.1-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:581b2264fc0aa555f3f435a5944da7504ea3a065d7029ad60e7c3d1ae09c5464", size = 35203952, upload-time = "2026-02-23T00:19:42.259Z" }, + { url = "https://files.pythonhosted.org/packages/8d/a5/9afd17de24f657fdfe4df9a3f1ea049b39aef7c06000c13db1530d81ccca/scipy-1.17.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:beeda3d4ae615106d7094f7e7cef6218392e4465cc95d25f900bebabfded0950", size = 34979063, upload-time = "2026-02-23T00:19:47.547Z" }, + { url = "https://files.pythonhosted.org/packages/8b/13/88b1d2384b424bf7c924f2038c1c409f8d88bb2a8d49d097861dd64a57b2/scipy-1.17.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6609bc224e9568f65064cfa72edc0f24ee6655b47575954ec6339534b2798369", size = 37598449, upload-time = "2026-02-23T00:19:53.238Z" }, + { url = "https://files.pythonhosted.org/packages/35/e5/d6d0e51fc888f692a35134336866341c08655d92614f492c6860dc45bb2c/scipy-1.17.1-cp313-cp313-win_amd64.whl", hash = "sha256:37425bc9175607b0268f493d79a292c39f9d001a357bebb6b88fdfaff13f6448", size = 36510943, upload-time = "2026-02-23T00:20:50.89Z" }, + { url = "https://files.pythonhosted.org/packages/2a/fd/3be73c564e2a01e690e19cc618811540ba5354c67c8680dce3281123fb79/scipy-1.17.1-cp313-cp313-win_arm64.whl", hash = "sha256:5cf36e801231b6a2059bf354720274b7558746f3b1a4efb43fcf557ccd484a87", size = 24545621, upload-time = "2026-02-23T00:20:55.871Z" }, + { url = "https://files.pythonhosted.org/packages/6f/6b/17787db8b8114933a66f9dcc479a8272e4b4da75fe03b0c282f7b0ade8cd/scipy-1.17.1-cp313-cp313t-macosx_10_14_x86_64.whl", hash = "sha256:d59c30000a16d8edc7e64152e30220bfbd724c9bbb08368c054e24c651314f0a", size = 31936708, upload-time = "2026-02-23T00:19:58.694Z" }, + { url = "https://files.pythonhosted.org/packages/38/2e/524405c2b6392765ab1e2b722a41d5da33dc5c7b7278184a8ad29b6cb206/scipy-1.17.1-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:010f4333c96c9bb1a4516269e33cb5917b08ef2166d5556ca2fd9f082a9e6ea0", size = 28570135, upload-time = "2026-02-23T00:20:03.934Z" }, + { url = "https://files.pythonhosted.org/packages/fd/c3/5bd7199f4ea8556c0c8e39f04ccb014ac37d1468e6cfa6a95c6b3562b76e/scipy-1.17.1-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:2ceb2d3e01c5f1d83c4189737a42d9cb2fc38a6eeed225e7515eef71ad301dce", size = 20741977, upload-time = "2026-02-23T00:20:07.935Z" }, + { url = "https://files.pythonhosted.org/packages/d9/b8/8ccd9b766ad14c78386599708eb745f6b44f08400a5fd0ade7cf89b6fc93/scipy-1.17.1-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:844e165636711ef41f80b4103ed234181646b98a53c8f05da12ca5ca289134f6", size = 23029601, upload-time = "2026-02-23T00:20:12.161Z" }, + { url = "https://files.pythonhosted.org/packages/6d/a0/3cb6f4d2fb3e17428ad2880333cac878909ad1a89f678527b5328b93c1d4/scipy-1.17.1-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:158dd96d2207e21c966063e1635b1063cd7787b627b6f07305315dd73d9c679e", size = 33019667, upload-time = "2026-02-23T00:20:17.208Z" }, + { url = "https://files.pythonhosted.org/packages/f3/c3/2d834a5ac7bf3a0c806ad1508efc02dda3c8c61472a56132d7894c312dea/scipy-1.17.1-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:74cbb80d93260fe2ffa334efa24cb8f2f0f622a9b9febf8b483c0b865bfb3475", size = 35264159, upload-time = "2026-02-23T00:20:23.087Z" }, + { url = "https://files.pythonhosted.org/packages/4d/77/d3ed4becfdbd217c52062fafe35a72388d1bd82c2d0ba5ca19d6fcc93e11/scipy-1.17.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:dbc12c9f3d185f5c737d801da555fb74b3dcfa1a50b66a1a93e09190f41fab50", size = 35102771, upload-time = "2026-02-23T00:20:28.636Z" }, + { url = "https://files.pythonhosted.org/packages/bd/12/d19da97efde68ca1ee5538bb261d5d2c062f0c055575128f11a2730e3ac1/scipy-1.17.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:94055a11dfebe37c656e70317e1996dc197e1a15bbcc351bcdd4610e128fe1ca", size = 37665910, upload-time = "2026-02-23T00:20:34.743Z" }, + { url = "https://files.pythonhosted.org/packages/06/1c/1172a88d507a4baaf72c5a09bb6c018fe2ae0ab622e5830b703a46cc9e44/scipy-1.17.1-cp313-cp313t-win_amd64.whl", hash = "sha256:e30bdeaa5deed6bc27b4cc490823cd0347d7dae09119b8803ae576ea0ce52e4c", size = 36562980, upload-time = "2026-02-23T00:20:40.575Z" }, + { url = "https://files.pythonhosted.org/packages/70/b0/eb757336e5a76dfa7911f63252e3b7d1de00935d7705cf772db5b45ec238/scipy-1.17.1-cp313-cp313t-win_arm64.whl", hash = "sha256:a720477885a9d2411f94a93d16f9d89bad0f28ca23c3f8daa521e2dcc3f44d49", size = 24856543, upload-time = "2026-02-23T00:20:45.313Z" }, + { url = "https://files.pythonhosted.org/packages/cf/83/333afb452af6f0fd70414dc04f898647ee1423979ce02efa75c3b0f2c28e/scipy-1.17.1-cp314-cp314-macosx_10_14_x86_64.whl", hash = "sha256:a48a72c77a310327f6a3a920092fa2b8fd03d7deaa60f093038f22d98e096717", size = 31584510, upload-time = "2026-02-23T00:21:01.015Z" }, + { url = "https://files.pythonhosted.org/packages/ed/a6/d05a85fd51daeb2e4ea71d102f15b34fedca8e931af02594193ae4fd25f7/scipy-1.17.1-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:45abad819184f07240d8a696117a7aacd39787af9e0b719d00285549ed19a1e9", size = 28170131, upload-time = "2026-02-23T00:21:05.888Z" }, + { url = "https://files.pythonhosted.org/packages/db/7b/8624a203326675d7746a254083a187398090a179335b2e4a20e2ddc46e83/scipy-1.17.1-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:3fd1fcdab3ea951b610dc4cef356d416d5802991e7e32b5254828d342f7b7e0b", size = 20342032, upload-time = "2026-02-23T00:21:09.904Z" }, + { url = "https://files.pythonhosted.org/packages/c9/35/2c342897c00775d688d8ff3987aced3426858fd89d5a0e26e020b660b301/scipy-1.17.1-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:7bdf2da170b67fdf10bca777614b1c7d96ae3ca5794fd9587dce41eb2966e866", size = 22678766, upload-time = "2026-02-23T00:21:14.313Z" }, + { url = "https://files.pythonhosted.org/packages/ef/f2/7cdb8eb308a1a6ae1e19f945913c82c23c0c442a462a46480ce487fdc0ac/scipy-1.17.1-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:adb2642e060a6549c343603a3851ba76ef0b74cc8c079a9a58121c7ec9fe2350", size = 32957007, upload-time = "2026-02-23T00:21:19.663Z" }, + { url = "https://files.pythonhosted.org/packages/0b/2e/7eea398450457ecb54e18e9d10110993fa65561c4f3add5e8eccd2b9cd41/scipy-1.17.1-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:eee2cfda04c00a857206a4330f0c5e3e56535494e30ca445eb19ec624ae75118", size = 35221333, upload-time = "2026-02-23T00:21:25.278Z" }, + { url = "https://files.pythonhosted.org/packages/d9/77/5b8509d03b77f093a0d52e606d3c4f79e8b06d1d38c441dacb1e26cacf46/scipy-1.17.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:d2650c1fb97e184d12d8ba010493ee7b322864f7d3d00d3f9bb97d9c21de4068", size = 35042066, upload-time = "2026-02-23T00:21:31.358Z" }, + { url = "https://files.pythonhosted.org/packages/f9/df/18f80fb99df40b4070328d5ae5c596f2f00fffb50167e31439e932f29e7d/scipy-1.17.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:08b900519463543aa604a06bec02461558a6e1cef8fdbb8098f77a48a83c8118", size = 37612763, upload-time = "2026-02-23T00:21:37.247Z" }, + { url = "https://files.pythonhosted.org/packages/4b/39/f0e8ea762a764a9dc52aa7dabcfad51a354819de1f0d4652b6a1122424d6/scipy-1.17.1-cp314-cp314-win_amd64.whl", hash = "sha256:3877ac408e14da24a6196de0ddcace62092bfc12a83823e92e49e40747e52c19", size = 37290984, upload-time = "2026-02-23T00:22:35.023Z" }, + { url = "https://files.pythonhosted.org/packages/7c/56/fe201e3b0f93d1a8bcf75d3379affd228a63d7e2d80ab45467a74b494947/scipy-1.17.1-cp314-cp314-win_arm64.whl", hash = "sha256:f8885db0bc2bffa59d5c1b72fad7a6a92d3e80e7257f967dd81abb553a90d293", size = 25192877, upload-time = "2026-02-23T00:22:39.798Z" }, + { url = "https://files.pythonhosted.org/packages/96/ad/f8c414e121f82e02d76f310f16db9899c4fcde36710329502a6b2a3c0392/scipy-1.17.1-cp314-cp314t-macosx_10_14_x86_64.whl", hash = "sha256:1cc682cea2ae55524432f3cdff9e9a3be743d52a7443d0cba9017c23c87ae2f6", size = 31949750, upload-time = "2026-02-23T00:21:42.289Z" }, + { url = "https://files.pythonhosted.org/packages/7c/b0/c741e8865d61b67c81e255f4f0a832846c064e426636cd7de84e74d209be/scipy-1.17.1-cp314-cp314t-macosx_12_0_arm64.whl", hash = "sha256:2040ad4d1795a0ae89bfc7e8429677f365d45aa9fd5e4587cf1ea737f927b4a1", size = 28585858, upload-time = "2026-02-23T00:21:47.706Z" }, + { url = "https://files.pythonhosted.org/packages/ed/1b/3985219c6177866628fa7c2595bfd23f193ceebbe472c98a08824b9466ff/scipy-1.17.1-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:131f5aaea57602008f9822e2115029b55d4b5f7c070287699fe45c661d051e39", size = 20757723, upload-time = "2026-02-23T00:21:52.039Z" }, + { url = "https://files.pythonhosted.org/packages/c0/19/2a04aa25050d656d6f7b9e7b685cc83d6957fb101665bfd9369ca6534563/scipy-1.17.1-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:9cdc1a2fcfd5c52cfb3045feb399f7b3ce822abdde3a193a6b9a60b3cb5854ca", size = 23043098, upload-time = "2026-02-23T00:21:56.185Z" }, + { url = "https://files.pythonhosted.org/packages/86/f1/3383beb9b5d0dbddd030335bf8a8b32d4317185efe495374f134d8be6cce/scipy-1.17.1-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6e3dcd57ab780c741fde8dc68619de988b966db759a3c3152e8e9142c26295ad", size = 33030397, upload-time = "2026-02-23T00:22:01.404Z" }, + { url = "https://files.pythonhosted.org/packages/41/68/8f21e8a65a5a03f25a79165ec9d2b28c00e66dc80546cf5eb803aeeff35b/scipy-1.17.1-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a9956e4d4f4a301ebf6cde39850333a6b6110799d470dbbb1e25326ac447f52a", size = 35281163, upload-time = "2026-02-23T00:22:07.024Z" }, + { url = "https://files.pythonhosted.org/packages/84/8d/c8a5e19479554007a5632ed7529e665c315ae7492b4f946b0deb39870e39/scipy-1.17.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:a4328d245944d09fd639771de275701ccadf5f781ba0ff092ad141e017eccda4", size = 35116291, upload-time = "2026-02-23T00:22:12.585Z" }, + { url = "https://files.pythonhosted.org/packages/52/52/e57eceff0e342a1f50e274264ed47497b59e6a4e3118808ee58ddda7b74a/scipy-1.17.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:a77cbd07b940d326d39a1d1b37817e2ee4d79cb30e7338f3d0cddffae70fcaa2", size = 37682317, upload-time = "2026-02-23T00:22:18.513Z" }, + { url = "https://files.pythonhosted.org/packages/11/2f/b29eafe4a3fbc3d6de9662b36e028d5f039e72d345e05c250e121a230dd4/scipy-1.17.1-cp314-cp314t-win_amd64.whl", hash = "sha256:eb092099205ef62cd1782b006658db09e2fed75bffcae7cc0d44052d8aa0f484", size = 37345327, upload-time = "2026-02-23T00:22:24.442Z" }, + { url = "https://files.pythonhosted.org/packages/07/39/338d9219c4e87f3e708f18857ecd24d22a0c3094752393319553096b98af/scipy-1.17.1-cp314-cp314t-win_arm64.whl", hash = "sha256:200e1050faffacc162be6a486a984a0497866ec54149a01270adc8a59b7c7d21", size = 25489165, upload-time = "2026-02-23T00:22:29.563Z" }, +] + +[[package]] +name = "setuptools" +version = "81.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0d/1c/73e719955c59b8e424d015ab450f51c0af856ae46ea2da83eba51cc88de1/setuptools-81.0.0.tar.gz", hash = "sha256:487b53915f52501f0a79ccfd0c02c165ffe06631443a886740b91af4b7a5845a", size = 1198299, upload-time = "2026-02-06T21:10:39.601Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e1/e3/c164c88b2e5ce7b24d667b9bd83589cf4f3520d97cad01534cd3c4f55fdb/setuptools-81.0.0-py3-none-any.whl", hash = "sha256:fdd925d5c5d9f62e4b74b30d6dd7828ce236fd6ed998a08d81de62ce5a6310d6", size = 1062021, upload-time = "2026-02-06T21:10:37.175Z" }, +] + +[[package]] +name = "shellingham" +version = "1.5.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/58/15/8b3609fd3830ef7b27b655beb4b4e9c62313a4e8da8c676e142cc210d58e/shellingham-1.5.4.tar.gz", hash = "sha256:8dbca0739d487e5bd35ab3ca4b36e11c4078f3a234bfce294b0a0291363404de", size = 10310, upload-time = "2023-10-24T04:13:40.426Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e0/f9/0595336914c5619e5f28a1fb793285925a8cd4b432c9da0a987836c7f822/shellingham-1.5.4-py2.py3-none-any.whl", hash = "sha256:7ecfff8f2fd72616f7481040475a65b2bf8af90a56c89140852d1120324e8686", size = 9755, upload-time = "2023-10-24T04:13:38.866Z" }, ] [[package]] @@ -570,6 +2242,196 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" }, ] +[[package]] +name = "stack-data" +version = "0.6.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "asttokens" }, + { name = "executing" }, + { name = "pure-eval" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/28/e3/55dcc2cfbc3ca9c29519eb6884dd1415ecb53b0e934862d3559ddcb7e20b/stack_data-0.6.3.tar.gz", hash = "sha256:836a778de4fec4dcd1dcd89ed8abff8a221f58308462e1c4aa2a3cf30148f0b9", size = 44707, upload-time = "2023-09-30T13:58:05.479Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f1/7b/ce1eafaf1a76852e2ec9b22edecf1daa58175c090266e9f6c64afcd81d91/stack_data-0.6.3-py3-none-any.whl", hash = "sha256:d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695", size = 24521, upload-time = "2023-09-30T13:58:03.53Z" }, +] + +[[package]] +name = "sympy" +version = "1.14.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "mpmath" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/83/d3/803453b36afefb7c2bb238361cd4ae6125a569b4db67cd9e79846ba2d68c/sympy-1.14.0.tar.gz", hash = "sha256:d3d3fe8df1e5a0b42f0e7bdf50541697dbe7d23746e894990c030e2b05e72517", size = 7793921, upload-time = "2025-04-27T18:05:01.611Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a2/09/77d55d46fd61b4a135c444fc97158ef34a095e5681d0a6c10b75bf356191/sympy-1.14.0-py3-none-any.whl", hash = "sha256:e091cc3e99d2141a0ba2847328f5479b05d94a6635cb96148ccb3f34671bd8f5", size = 6299353, upload-time = "2025-04-27T18:04:59.103Z" }, +] + +[[package]] +name = "tensorflow" +version = "2.21.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "absl-py" }, + { name = "astunparse" }, + { name = "flatbuffers" }, + { name = "gast" }, + { name = "google-pasta" }, + { name = "grpcio" }, + { name = "h5py" }, + { name = "keras" }, + { name = "libclang" }, + { name = "ml-dtypes" }, + { name = "numpy" }, + { name = "opt-einsum" }, + { name = "packaging" }, + { name = "protobuf" }, + { name = "requests" }, + { name = "setuptools" }, + { name = "six" }, + { name = "termcolor" }, + { name = "typing-extensions" }, + { name = "wrapt" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/39/59/27adba20bbd1088b00fc0e9232aa21493b4800af2299eb6005017a6053f4/tensorflow-2.21.0-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:56ecd7d47429acbe1df2694d50b75bf9fc3995ac92cb367cd9af6c4780ead712", size = 223488205, upload-time = "2026-03-06T17:24:03.48Z" }, + { url = "https://files.pythonhosted.org/packages/20/a5/f139fbbd4e81a2e556170718698acf518a71a84927fa1dc1f5935b6ab3d2/tensorflow-2.21.0-cp312-cp312-manylinux_2_27_aarch64.whl", hash = "sha256:b07d15737406533898e36c7ef7944b1be18e9028dc521b9229952c537bbc5552", size = 281946471, upload-time = "2026-03-06T17:24:11.896Z" }, + { url = "https://files.pythonhosted.org/packages/ce/d7/6e71b4ded8ce99cd21add95611ca14af6e9ad4f2baeabdeb79a4a6b3cb1f/tensorflow-2.21.0-cp312-cp312-manylinux_2_27_x86_64.whl", hash = "sha256:b3b95643c4e70eb925839938fb35cbe142f317ec84af6844ee61513713bb13c0", size = 572611111, upload-time = "2026-03-06T17:24:26.209Z" }, + { url = "https://files.pythonhosted.org/packages/7d/0d/4ee4bc074597b41c9c00dc97b4418ef1eb8736fe9186ffdb3961efdfb730/tensorflow-2.21.0-cp312-cp312-win_amd64.whl", hash = "sha256:27ba0682572b1e50a0db1ee74cfb787eafcfdb1b751bbbf401fed62fe32a92e0", size = 350945509, upload-time = "2026-03-06T17:24:41.65Z" }, + { url = "https://files.pythonhosted.org/packages/40/09/268b45a61be2bce136dabf3a3cd7099c8a984ae398198f71920b4c60c502/tensorflow-2.21.0-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:a145ed46c58192b7c3f9916d070caf4f6afc6dc7e5511f83dd97677f4c4947f4", size = 223766900, upload-time = "2026-03-06T17:24:51.349Z" }, + { url = "https://files.pythonhosted.org/packages/72/72/343b86b4c9bfe28e81f749439f908c1e26aeac73d9f12b8dcdb996eb8ecb/tensorflow-2.21.0-cp313-cp313-manylinux_2_27_aarch64.whl", hash = "sha256:a10abdfb8b1189210c251021a3f153b7ccc52a8e6521351f3dc3331e8ba593e0", size = 282213003, upload-time = "2026-03-06T17:24:59.859Z" }, + { url = "https://files.pythonhosted.org/packages/86/6c/10d075ffc09754c7f10e749ba3c9d46dd809fb007990c7f788128044180c/tensorflow-2.21.0-cp313-cp313-manylinux_2_27_x86_64.whl", hash = "sha256:e9d8da8dcab9650efb45f032ba70af2f016f907e6e0c6bda29dd101bba945406", size = 572881074, upload-time = "2026-03-06T17:25:14.453Z" }, + { url = "https://files.pythonhosted.org/packages/86/91/dedad8403e7b0036d99be4878987693b7b7f62097eb8537fa6ce62ea131c/tensorflow-2.21.0-cp313-cp313-win_amd64.whl", hash = "sha256:76cccbe0a95d9392dee1ae501ae0656b6c73c1cac29a7f8f32d570e0670863f7", size = 351205371, upload-time = "2026-03-06T17:25:33.144Z" }, +] + +[[package]] +name = "termcolor" +version = "3.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/46/79/cf31d7a93a8fdc6aa0fbb665be84426a8c5a557d9240b6239e9e11e35fc5/termcolor-3.3.0.tar.gz", hash = "sha256:348871ca648ec6a9a983a13ab626c0acce02f515b9e1983332b17af7979521c5", size = 14434, upload-time = "2025-12-29T12:55:21.882Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/33/d1/8bb87d21e9aeb323cc03034f5eaf2c8f69841e40e4853c2627edf8111ed3/termcolor-3.3.0-py3-none-any.whl", hash = "sha256:cf642efadaf0a8ebbbf4bc7a31cec2f9b5f21a9f726f4ccbb08192c9c26f43a5", size = 7734, upload-time = "2025-12-29T12:55:20.718Z" }, +] + +[[package]] +name = "tokenizers" +version = "0.22.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "huggingface-hub" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/73/6f/f80cfef4a312e1fb34baf7d85c72d4411afde10978d4657f8cdd811d3ccc/tokenizers-0.22.2.tar.gz", hash = "sha256:473b83b915e547aa366d1eee11806deaf419e17be16310ac0a14077f1e28f917", size = 372115, upload-time = "2026-01-05T10:45:15.988Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/92/97/5dbfabf04c7e348e655e907ed27913e03db0923abb5dfdd120d7b25630e1/tokenizers-0.22.2-cp39-abi3-macosx_10_12_x86_64.whl", hash = "sha256:544dd704ae7238755d790de45ba8da072e9af3eea688f698b137915ae959281c", size = 3100275, upload-time = "2026-01-05T10:41:02.158Z" }, + { url = "https://files.pythonhosted.org/packages/2e/47/174dca0502ef88b28f1c9e06b73ce33500eedfac7a7692108aec220464e7/tokenizers-0.22.2-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:1e418a55456beedca4621dbab65a318981467a2b188e982a23e117f115ce5001", size = 2981472, upload-time = "2026-01-05T10:41:00.276Z" }, + { url = "https://files.pythonhosted.org/packages/d6/84/7990e799f1309a8b87af6b948f31edaa12a3ed22d11b352eaf4f4b2e5753/tokenizers-0.22.2-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2249487018adec45d6e3554c71d46eb39fa8ea67156c640f7513eb26f318cec7", size = 3290736, upload-time = "2026-01-05T10:40:32.165Z" }, + { url = "https://files.pythonhosted.org/packages/78/59/09d0d9ba94dcd5f4f1368d4858d24546b4bdc0231c2354aa31d6199f0399/tokenizers-0.22.2-cp39-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:25b85325d0815e86e0bac263506dd114578953b7b53d7de09a6485e4a160a7dd", size = 3168835, upload-time = "2026-01-05T10:40:38.847Z" }, + { url = "https://files.pythonhosted.org/packages/47/50/b3ebb4243e7160bda8d34b731e54dd8ab8b133e50775872e7a434e524c28/tokenizers-0.22.2-cp39-abi3-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:bfb88f22a209ff7b40a576d5324bf8286b519d7358663db21d6246fb17eea2d5", size = 3521673, upload-time = "2026-01-05T10:40:56.614Z" }, + { url = "https://files.pythonhosted.org/packages/e0/fa/89f4cb9e08df770b57adb96f8cbb7e22695a4cb6c2bd5f0c4f0ebcf33b66/tokenizers-0.22.2-cp39-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1c774b1276f71e1ef716e5486f21e76333464f47bece56bbd554485982a9e03e", size = 3724818, upload-time = "2026-01-05T10:40:44.507Z" }, + { url = "https://files.pythonhosted.org/packages/64/04/ca2363f0bfbe3b3d36e95bf67e56a4c88c8e3362b658e616d1ac185d47f2/tokenizers-0.22.2-cp39-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:df6c4265b289083bf710dff49bc51ef252f9d5be33a45ee2bed151114a56207b", size = 3379195, upload-time = "2026-01-05T10:40:51.139Z" }, + { url = "https://files.pythonhosted.org/packages/2e/76/932be4b50ef6ccedf9d3c6639b056a967a86258c6d9200643f01269211ca/tokenizers-0.22.2-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:369cc9fc8cc10cb24143873a0d95438bb8ee257bb80c71989e3ee290e8d72c67", size = 3274982, upload-time = "2026-01-05T10:40:58.331Z" }, + { url = "https://files.pythonhosted.org/packages/1d/28/5f9f5a4cc211b69e89420980e483831bcc29dade307955cc9dc858a40f01/tokenizers-0.22.2-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:29c30b83d8dcd061078b05ae0cb94d3c710555fbb44861139f9f83dcca3dc3e4", size = 9478245, upload-time = "2026-01-05T10:41:04.053Z" }, + { url = "https://files.pythonhosted.org/packages/6c/fb/66e2da4704d6aadebf8cb39f1d6d1957df667ab24cff2326b77cda0dcb85/tokenizers-0.22.2-cp39-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:37ae80a28c1d3265bb1f22464c856bd23c02a05bb211e56d0c5301a435be6c1a", size = 9560069, upload-time = "2026-01-05T10:45:10.673Z" }, + { url = "https://files.pythonhosted.org/packages/16/04/fed398b05caa87ce9b1a1bb5166645e38196081b225059a6edaff6440fac/tokenizers-0.22.2-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:791135ee325f2336f498590eb2f11dc5c295232f288e75c99a36c5dbce63088a", size = 9899263, upload-time = "2026-01-05T10:45:12.559Z" }, + { url = "https://files.pythonhosted.org/packages/05/a1/d62dfe7376beaaf1394917e0f8e93ee5f67fea8fcf4107501db35996586b/tokenizers-0.22.2-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:38337540fbbddff8e999d59970f3c6f35a82de10053206a7562f1ea02d046fa5", size = 10033429, upload-time = "2026-01-05T10:45:14.333Z" }, + { url = "https://files.pythonhosted.org/packages/fd/18/a545c4ea42af3df6effd7d13d250ba77a0a86fb20393143bbb9a92e434d4/tokenizers-0.22.2-cp39-abi3-win32.whl", hash = "sha256:a6bf3f88c554a2b653af81f3204491c818ae2ac6fbc09e76ef4773351292bc92", size = 2502363, upload-time = "2026-01-05T10:45:20.593Z" }, + { url = "https://files.pythonhosted.org/packages/65/71/0670843133a43d43070abeb1949abfdef12a86d490bea9cd9e18e37c5ff7/tokenizers-0.22.2-cp39-abi3-win_amd64.whl", hash = "sha256:c9ea31edff2968b44a88f97d784c2f16dc0729b8b143ed004699ebca91f05c48", size = 2747786, upload-time = "2026-01-05T10:45:18.411Z" }, + { url = "https://files.pythonhosted.org/packages/72/f4/0de46cfa12cdcbcd464cc59fde36912af405696f687e53a091fb432f694c/tokenizers-0.22.2-cp39-abi3-win_arm64.whl", hash = "sha256:9ce725d22864a1e965217204946f830c37876eee3b2ba6fc6255e8e903d5fcbc", size = 2612133, upload-time = "2026-01-05T10:45:17.232Z" }, +] + +[[package]] +name = "torch" +version = "2.11.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cuda-bindings", marker = "sys_platform == 'linux'" }, + { name = "cuda-toolkit", extra = ["cublas", "cudart", "cufft", "cufile", "cupti", "curand", "cusolver", "cusparse", "nvjitlink", "nvrtc", "nvtx"], marker = "sys_platform == 'linux'" }, + { name = "filelock" }, + { name = "fsspec" }, + { name = "jinja2" }, + { name = "networkx" }, + { name = "nvidia-cudnn-cu13", marker = "sys_platform == 'linux'" }, + { name = "nvidia-cusparselt-cu13", marker = "sys_platform == 'linux'" }, + { name = "nvidia-nccl-cu13", marker = "sys_platform == 'linux'" }, + { name = "nvidia-nvshmem-cu13", marker = "sys_platform == 'linux'" }, + { name = "setuptools" }, + { name = "sympy" }, + { name = "triton", marker = "sys_platform == 'linux'" }, + { name = "typing-extensions" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/6f/8b/69e3008d78e5cee2b30183340cc425081b78afc5eff3d080daab0adda9aa/torch-2.11.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:4b5866312ee6e52ea625cd211dcb97d6a2cdc1131a5f15cc0d87eec948f6dd34", size = 80606338, upload-time = "2026-03-23T18:11:34.781Z" }, + { url = "https://files.pythonhosted.org/packages/13/16/42e5915ebe4868caa6bac83a8ed59db57f12e9a61b7d749d584776ed53d5/torch-2.11.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:f99924682ef0aa6a4ab3b1b76f40dc6e273fca09f367d15a524266db100a723f", size = 419731115, upload-time = "2026-03-23T18:11:06.944Z" }, + { url = "https://files.pythonhosted.org/packages/1a/c9/82638ef24d7877510f83baf821f5619a61b45568ce21c0a87a91576510aa/torch-2.11.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:0f68f4ac6d95d12e896c3b7a912b5871619542ec54d3649cf48cc1edd4dd2756", size = 530712279, upload-time = "2026-03-23T18:10:31.481Z" }, + { url = "https://files.pythonhosted.org/packages/1c/ff/6756f1c7ee302f6d202120e0f4f05b432b839908f9071157302cedfc5232/torch-2.11.0-cp312-cp312-win_amd64.whl", hash = "sha256:fbf39280699d1b869f55eac536deceaa1b60bd6788ba74f399cc67e60a5fab10", size = 114556047, upload-time = "2026-03-23T18:10:55.931Z" }, + { url = "https://files.pythonhosted.org/packages/87/89/5ea6722763acee56b045435fb84258db7375c48165ec8be7880ab2b281c5/torch-2.11.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:1e6debd97ccd3205bbb37eb806a9d8219e1139d15419982c09e23ef7d4369d18", size = 80606801, upload-time = "2026-03-23T18:10:18.649Z" }, + { url = "https://files.pythonhosted.org/packages/32/d1/8ed2173589cbfe744ed54e5a73efc107c0085ba5777ee93a5f4c1ab90553/torch-2.11.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:63a68fa59de8f87acc7e85a5478bb2dddbb3392b7593ec3e78827c793c4b73fd", size = 419732382, upload-time = "2026-03-23T18:08:30.835Z" }, + { url = "https://files.pythonhosted.org/packages/3d/e1/b73f7c575a4b8f87a5928f50a1e35416b5e27295d8be9397d5293e7e8d4c/torch-2.11.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:cc89b9b173d9adfab59fd227f0ab5e5516d9a52b658ae41d64e59d2e55a418db", size = 530711509, upload-time = "2026-03-23T18:08:47.213Z" }, + { url = "https://files.pythonhosted.org/packages/66/82/3e3fcdd388fbe54e29fd3f991f36846ff4ac90b0d0181e9c8f7236565f82/torch-2.11.0-cp313-cp313-win_amd64.whl", hash = "sha256:4dda3b3f52d121063a731ddb835f010dc137b920d7fec2778e52f60d8e4bf0cd", size = 114555842, upload-time = "2026-03-23T18:09:52.111Z" }, + { url = "https://files.pythonhosted.org/packages/db/38/8ac78069621b8c2b4979c2f96dc8409ef5e9c4189f6aac629189a78677ca/torch-2.11.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:8b394322f49af4362d4f80e424bcaca7efcd049619af03a4cf4501520bdf0fb4", size = 80959574, upload-time = "2026-03-23T18:10:14.214Z" }, + { url = "https://files.pythonhosted.org/packages/6d/6c/56bfb37073e7136e6dd86bfc6af7339946dd684e0ecf2155ac0eee687ae1/torch-2.11.0-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:2658f34ce7e2dabf4ec73b45e2ca68aedad7a5be87ea756ad656eaf32bf1e1ea", size = 419732324, upload-time = "2026-03-23T18:09:36.604Z" }, + { url = "https://files.pythonhosted.org/packages/07/f4/1b666b6d61d3394cca306ea543ed03a64aad0a201b6cd159f1d41010aeb1/torch-2.11.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:98bb213c3084cfe176302949bdc360074b18a9da7ab59ef2edc9d9f742504778", size = 530596026, upload-time = "2026-03-23T18:09:20.842Z" }, + { url = "https://files.pythonhosted.org/packages/48/6b/30d1459fa7e4b67e9e3fe1685ca1d8bb4ce7c62ef436c3a615963c6c866c/torch-2.11.0-cp313-cp313t-win_amd64.whl", hash = "sha256:a97b94bbf62992949b4730c6cd2cc9aee7b335921ee8dc207d930f2ed09ae2db", size = 114793702, upload-time = "2026-03-23T18:09:47.304Z" }, + { url = "https://files.pythonhosted.org/packages/26/0d/8603382f61abd0db35841148ddc1ffd607bf3100b11c6e1dab6d2fc44e72/torch-2.11.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:01018087326984a33b64e04c8cb5c2795f9120e0d775ada1f6638840227b04d7", size = 80573442, upload-time = "2026-03-23T18:09:10.117Z" }, + { url = "https://files.pythonhosted.org/packages/c7/86/7cd7c66cb9cec6be330fff36db5bd0eef386d80c031b581ec81be1d4b26c/torch-2.11.0-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:2bb3cc54bd0dea126b0060bb1ec9de0f9c7f7342d93d436646516b0330cd5be7", size = 419749385, upload-time = "2026-03-23T18:07:33.77Z" }, + { url = "https://files.pythonhosted.org/packages/47/e8/b98ca2d39b2e0e4730c0ee52537e488e7008025bc77ca89552ff91021f7c/torch-2.11.0-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:4dc8b3809469b6c30b411bb8c4cad3828efd26236153d9beb6a3ec500f211a60", size = 530716756, upload-time = "2026-03-23T18:07:50.02Z" }, + { url = "https://files.pythonhosted.org/packages/78/88/d4a4cda8362f8a30d1ed428564878c3cafb0d87971fbd3947d4c84552095/torch-2.11.0-cp314-cp314-win_amd64.whl", hash = "sha256:2b4e811728bd0cc58fb2b0948fe939a1ee2bf1422f6025be2fca4c7bd9d79718", size = 114552300, upload-time = "2026-03-23T18:09:05.617Z" }, + { url = "https://files.pythonhosted.org/packages/bf/46/4419098ed6d801750f26567b478fc185c3432e11e2cad712bc6b4c2ab0d0/torch-2.11.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:8245477871c3700d4370352ffec94b103cfcb737229445cf9946cddb7b2ca7cd", size = 80959460, upload-time = "2026-03-23T18:09:00.818Z" }, + { url = "https://files.pythonhosted.org/packages/fd/66/54a56a4a6ceaffb567231994a9745821d3af922a854ed33b0b3a278e0a99/torch-2.11.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:ab9a8482f475f9ba20e12db84b0e55e2f58784bdca43a854a6ccd3fd4b9f75e6", size = 419735835, upload-time = "2026-03-23T18:07:18.974Z" }, + { url = "https://files.pythonhosted.org/packages/b1/e7/0b6665f533aa9e337662dc190425abc0af1fe3234088f4454c52393ded61/torch-2.11.0-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:563ed3d25542d7e7bbc5b235ccfacfeb97fb470c7fee257eae599adb8005c8a2", size = 530613405, upload-time = "2026-03-23T18:08:07.014Z" }, + { url = "https://files.pythonhosted.org/packages/cf/bf/c8d12a2c86dbfd7f40fb2f56fbf5a505ccf2d9ce131eb559dfc7c51e1a04/torch-2.11.0-cp314-cp314t-win_amd64.whl", hash = "sha256:b2a43985ff5ef6ddd923bbcf99943e5f58059805787c5c9a2622bf05ca2965b0", size = 114792991, upload-time = "2026-03-23T18:08:19.216Z" }, +] + +[[package]] +name = "torchvision" +version = "0.26.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, + { name = "pillow" }, + { name = "torch" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/ae/e7/56b47cc3b132aea90ccce22bcb8975dec688b002150012acc842846039d0/torchvision-0.26.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c409e1c3fdebec7a3834465086dbda8bf7680eff79abf7fd2f10c6b59520a7a4", size = 1863502, upload-time = "2026-03-23T18:12:57.326Z" }, + { url = "https://files.pythonhosted.org/packages/f4/ec/5c31c92c08b65662fe9604a4067ae8232582805949f11ddc042cebe818ed/torchvision-0.26.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:406557718e62fdf10f5706e88d8a5ec000f872da913bf629aab9297622585547", size = 7767944, upload-time = "2026-03-23T18:12:42.805Z" }, + { url = "https://files.pythonhosted.org/packages/f5/d8/cb6ccda1a1f35a6597645818641701207b3e8e13553e75fce5d86bac74b2/torchvision-0.26.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:d61a5abb6b42a0c0c311996c2ac4b83a94418a97182c83b055a2a4ae985e05aa", size = 7522205, upload-time = "2026-03-23T18:12:54.654Z" }, + { url = "https://files.pythonhosted.org/packages/1c/a9/c272623a0f735c35f0f6cd6dc74784d4f970e800cf063bb76687895a2ab9/torchvision-0.26.0-cp312-cp312-win_amd64.whl", hash = "sha256:7993c01648e7c61d191b018e84d38fe0825c8fcb2720cd0f37caf7ba14404aa1", size = 4255155, upload-time = "2026-03-23T18:12:32.652Z" }, + { url = "https://files.pythonhosted.org/packages/da/80/0762f77f53605d10c9477be39bb47722cc8e383bbbc2531471ce0e396c07/torchvision-0.26.0-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:5d63dd43162691258b1b3529b9041bac7d54caa37eae0925f997108268cbf7c4", size = 1860809, upload-time = "2026-03-23T18:12:47.629Z" }, + { url = "https://files.pythonhosted.org/packages/e6/81/0b3e58d1478c660a5af4268713486b2df7203f35abd9195fea87348a5178/torchvision-0.26.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:a39c7a26538c41fda453f9a9692b5ff9b35a5437db1d94f3027f6f509c160eac", size = 7727494, upload-time = "2026-03-23T18:12:46.062Z" }, + { url = "https://files.pythonhosted.org/packages/b6/dc/d9ab5d29115aa05e12e30f1397a3eeae1d88a511241dc3bce48dc4342675/torchvision-0.26.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:b7e6213620bbf97742e5f79832f9e9d769e6cf0f744c5b53dad80b76db633691", size = 7521747, upload-time = "2026-03-23T18:12:36.815Z" }, + { url = "https://files.pythonhosted.org/packages/a9/1b/f1bc86a918c5f6feab1eeff11982e2060f4704332e96185463d27855bdf5/torchvision-0.26.0-cp313-cp313-win_amd64.whl", hash = "sha256:4280c35ec8cba1fcc8294fb87e136924708726864c379e4c54494797d86bc474", size = 4319880, upload-time = "2026-03-23T18:12:38.168Z" }, + { url = "https://files.pythonhosted.org/packages/66/28/b4ad0a723ed95b003454caffcc41894b34bd8379df340848cae2c33871de/torchvision-0.26.0-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:358fc4726d0c08615b6d83b3149854f11efb2a564ed1acb6fce882e151412d23", size = 1951973, upload-time = "2026-03-23T18:12:48.781Z" }, + { url = "https://files.pythonhosted.org/packages/71/e2/7a89096e6cf2f3336353b5338ba925e0addf9d8601920340e6bdf47e8eb3/torchvision-0.26.0-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:3daf9cc149cf3cdcbd4df9c59dae69ffca86c6823250442c3bbfd63fc2e26c61", size = 7728679, upload-time = "2026-03-23T18:12:26.196Z" }, + { url = "https://files.pythonhosted.org/packages/69/1d/4e1eebc17d18ce080a11dcf3df3f8f717f0efdfa00983f06e8ba79259f61/torchvision-0.26.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:82c3965eca27e86a316e31e4c3e5a16d353e0bcbe0ef8efa2e66502c54493c4b", size = 7609138, upload-time = "2026-03-23T18:12:35.327Z" }, + { url = "https://files.pythonhosted.org/packages/f3/a4/f1155e943ae5b32400d7000adc81c79bb0392b16ceb33bcf13e02e48cced/torchvision-0.26.0-cp313-cp313t-win_amd64.whl", hash = "sha256:ebc043cc5a4f0bf22e7680806dbba37ffb19e70f6953bbb44ed1a90aeb5c9bea", size = 4248202, upload-time = "2026-03-23T18:12:41.423Z" }, + { url = "https://files.pythonhosted.org/packages/7f/c8/9bffa9c7f7bdf95b2a0a2dc535c290b9f1cc580c3fb3033ab1246ffffdeb/torchvision-0.26.0-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:eb61804eb9dbe88c5a2a6c4da8dec1d80d2d0a6f18c999c524e32266cb1ebcd3", size = 1860813, upload-time = "2026-03-23T18:12:39.636Z" }, + { url = "https://files.pythonhosted.org/packages/7b/ac/48f28ffd227991f2e14f4392dde7e8dc14352bb9428c1ef4a4bbf5f7ed85/torchvision-0.26.0-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:9a904f2131cbfadab4df828088a9f66291ad33f49ff853872aed1f86848ef776", size = 7727777, upload-time = "2026-03-23T18:12:22.549Z" }, + { url = "https://files.pythonhosted.org/packages/a4/21/a2266f7f1b0e58e624ff15fd6f01041f59182c49551ece0db9a183071329/torchvision-0.26.0-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:0f3e572efe62ad645017ea847e0b5e4f2f638d4e39f05bc011d1eb9ac68d4806", size = 7522174, upload-time = "2026-03-23T18:12:29.565Z" }, + { url = "https://files.pythonhosted.org/packages/fc/ba/1666f90bc0bdd77aaa11dcc42bb9f621a9c3668819c32430452e3d404730/torchvision-0.26.0-cp314-cp314-win_amd64.whl", hash = "sha256:114bec0c0e98aa4ba446f63e2fe7a2cbca37b39ac933987ee4804f65de121800", size = 4348469, upload-time = "2026-03-23T18:12:24.44Z" }, + { url = "https://files.pythonhosted.org/packages/45/8f/1f0402ac55c2ae15651ff831957d083fe70b2d12282e72612a30ba601512/torchvision-0.26.0-cp314-cp314t-macosx_12_0_arm64.whl", hash = "sha256:b7d3e295624a28b3b1769228ce1345d94cf4d390dd31136766f76f2d20f718da", size = 1860826, upload-time = "2026-03-23T18:12:34.1Z" }, + { url = "https://files.pythonhosted.org/packages/d2/6a/18a582fe3c5ee26f49b5c9fb21ad8016b4d1c06d10178894a58653946fda/torchvision-0.26.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:7058c5878262937e876f20c25867b33724586aa4499e2853b2d52b99a5e51953", size = 7729089, upload-time = "2026-03-23T18:12:31.394Z" }, + { url = "https://files.pythonhosted.org/packages/c5/9b/f7e119b59499edc00c55c03adc9ec3bd96144d9b81c46852c431f9c64a9a/torchvision-0.26.0-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:8008474855623c6ba52876589dc52df0aa66e518c25eca841445348e5f79844c", size = 7522704, upload-time = "2026-03-23T18:12:20.301Z" }, + { url = "https://files.pythonhosted.org/packages/d0/6a/09f3844c10643f6c0de5d95abc863420cfaf194c88c7dffd0ac523e2015f/torchvision-0.26.0-cp314-cp314t-win_amd64.whl", hash = "sha256:e9d0e022c19a78552fb055d0414d47fecb4a649309b9968573daea160ba6869c", size = 4454275, upload-time = "2026-03-23T18:12:27.487Z" }, +] + +[[package]] +name = "tornado" +version = "6.5.5" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f8/f1/3173dfa4a18db4a9b03e5d55325559dab51ee653763bb8745a75af491286/tornado-6.5.5.tar.gz", hash = "sha256:192b8f3ea91bd7f1f50c06955416ed76c6b72f96779b962f07f911b91e8d30e9", size = 516006, upload-time = "2026-03-10T21:31:02.067Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/59/8c/77f5097695f4dd8255ecbd08b2a1ed8ba8b953d337804dd7080f199e12bf/tornado-6.5.5-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:487dc9cc380e29f58c7ab88f9e27cdeef04b2140862e5076a66fb6bb68bb1bfa", size = 445983, upload-time = "2026-03-10T21:30:44.28Z" }, + { url = "https://files.pythonhosted.org/packages/ab/5e/7625b76cd10f98f1516c36ce0346de62061156352353ef2da44e5c21523c/tornado-6.5.5-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:65a7f1d46d4bb41df1ac99f5fcb685fb25c7e61613742d5108b010975a9a6521", size = 444246, upload-time = "2026-03-10T21:30:46.571Z" }, + { url = "https://files.pythonhosted.org/packages/b2/04/7b5705d5b3c0fab088f434f9c83edac1573830ca49ccf29fb83bf7178eec/tornado-6.5.5-cp39-abi3-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:e74c92e8e65086b338fd56333fb9a68b9f6f2fe7ad532645a290a464bcf46be5", size = 447229, upload-time = "2026-03-10T21:30:48.273Z" }, + { url = "https://files.pythonhosted.org/packages/34/01/74e034a30ef59afb4097ef8659515e96a39d910b712a89af76f5e4e1f93c/tornado-6.5.5-cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:435319e9e340276428bbdb4e7fa732c2d399386d1de5686cb331ec8eee754f07", size = 448192, upload-time = "2026-03-10T21:30:51.22Z" }, + { url = "https://files.pythonhosted.org/packages/be/00/fe9e02c5a96429fce1a1d15a517f5d8444f9c412e0bb9eadfbe3b0fc55bf/tornado-6.5.5-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:3f54aa540bdbfee7b9eb268ead60e7d199de5021facd276819c193c0fb28ea4e", size = 448039, upload-time = "2026-03-10T21:30:53.52Z" }, + { url = "https://files.pythonhosted.org/packages/82/9e/656ee4cec0398b1d18d0f1eb6372c41c6b889722641d84948351ae19556d/tornado-6.5.5-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:36abed1754faeb80fbd6e64db2758091e1320f6bba74a4cf8c09cd18ccce8aca", size = 447445, upload-time = "2026-03-10T21:30:55.541Z" }, + { url = "https://files.pythonhosted.org/packages/5a/76/4921c00511f88af86a33de770d64141170f1cfd9c00311aea689949e274e/tornado-6.5.5-cp39-abi3-win32.whl", hash = "sha256:dd3eafaaeec1c7f2f8fdcd5f964e8907ad788fe8a5a32c4426fbbdda621223b7", size = 448582, upload-time = "2026-03-10T21:30:57.142Z" }, + { url = "https://files.pythonhosted.org/packages/2c/23/f6c6112a04d28eed765e374435fb1a9198f73e1ec4b4024184f21faeb1ad/tornado-6.5.5-cp39-abi3-win_amd64.whl", hash = "sha256:6443a794ba961a9f619b1ae926a2e900ac20c34483eea67be4ed8f1e58d3ef7b", size = 448990, upload-time = "2026-03-10T21:30:58.857Z" }, + { url = "https://files.pythonhosted.org/packages/b7/c8/876602cbc96469911f0939f703453c1157b0c826ecb05bdd32e023397d4e/tornado-6.5.5-cp39-abi3-win_arm64.whl", hash = "sha256:2c9a876e094109333f888539ddb2de4361743e5d21eece20688e3e351e4990a6", size = 448016, upload-time = "2026-03-10T21:31:00.43Z" }, +] + [[package]] name = "tqdm" version = "4.67.3" @@ -582,6 +2444,67 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/16/e1/3079a9ff9b8e11b846c6ac5c8b5bfb7ff225eee721825310c91b3b50304f/tqdm-4.67.3-py3-none-any.whl", hash = "sha256:ee1e4c0e59148062281c49d80b25b67771a127c85fc9676d3be5f243206826bf", size = 78374, upload-time = "2026-02-03T17:35:50.982Z" }, ] +[[package]] +name = "traitlets" +version = "5.14.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/eb/79/72064e6a701c2183016abbbfedaba506d81e30e232a68c9f0d6f6fcd1574/traitlets-5.14.3.tar.gz", hash = "sha256:9ed0579d3502c94b4b3732ac120375cda96f923114522847de4b3bb98b96b6b7", size = 161621, upload-time = "2024-04-19T11:11:49.746Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/00/c0/8f5d070730d7836adc9c9b6408dec68c6ced86b304a9b26a14df072a6e8c/traitlets-5.14.3-py3-none-any.whl", hash = "sha256:b74e89e397b1ed28cc831db7aea759ba6640cb3de13090ca145426688ff1ac4f", size = 85359, upload-time = "2024-04-19T11:11:46.763Z" }, +] + +[[package]] +name = "transformers" +version = "5.3.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "huggingface-hub" }, + { name = "numpy" }, + { name = "packaging" }, + { name = "pyyaml" }, + { name = "regex" }, + { name = "safetensors" }, + { name = "tokenizers" }, + { name = "tqdm" }, + { name = "typer" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/fc/1a/70e830d53ecc96ce69cfa8de38f163712d2b43ac52fbd743f39f56025c31/transformers-5.3.0.tar.gz", hash = "sha256:009555b364029da9e2946d41f1c5de9f15e6b1df46b189b7293f33a161b9c557", size = 8830831, upload-time = "2026-03-04T17:41:46.119Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b8/88/ae8320064e32679a5429a2c9ebbc05c2bf32cefb6e076f9b07f6d685a9b4/transformers-5.3.0-py3-none-any.whl", hash = "sha256:50ac8c89c3c7033444fb3f9f53138096b997ebb70d4b5e50a2e810bf12d3d29a", size = 10661827, upload-time = "2026-03-04T17:41:42.722Z" }, +] + +[[package]] +name = "triton" +version = "3.6.0" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/17/5d/08201db32823bdf77a0e2b9039540080b2e5c23a20706ddba942924ebcd6/triton-3.6.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:374f52c11a711fd062b4bfbb201fd9ac0a5febd28a96fb41b4a0f51dde3157f4", size = 176128243, upload-time = "2026-01-20T16:16:07.857Z" }, + { url = "https://files.pythonhosted.org/packages/ab/a8/cdf8b3e4c98132f965f88c2313a4b493266832ad47fb52f23d14d4f86bb5/triton-3.6.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:74caf5e34b66d9f3a429af689c1c7128daba1d8208df60e81106b115c00d6fca", size = 188266850, upload-time = "2026-01-20T16:00:43.041Z" }, + { url = "https://files.pythonhosted.org/packages/3c/12/34d71b350e89a204c2c7777a9bba0dcf2f19a5bfdd70b57c4dbc5ffd7154/triton-3.6.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:448e02fe6dc898e9e5aa89cf0ee5c371e99df5aa5e8ad976a80b93334f3494fd", size = 176133521, upload-time = "2026-01-20T16:16:13.321Z" }, + { url = "https://files.pythonhosted.org/packages/f9/0b/37d991d8c130ce81a8728ae3c25b6e60935838e9be1b58791f5997b24a54/triton-3.6.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:10c7f76c6e72d2ef08df639e3d0d30729112f47a56b0c81672edc05ee5116ac9", size = 188289450, upload-time = "2026-01-20T16:00:49.136Z" }, + { url = "https://files.pythonhosted.org/packages/ce/4e/41b0c8033b503fd3cfcd12392cdd256945026a91ff02452bef40ec34bee7/triton-3.6.0-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1722e172d34e32abc3eb7711d0025bb69d7959ebea84e3b7f7a341cd7ed694d6", size = 176276087, upload-time = "2026-01-20T16:16:18.989Z" }, + { url = "https://files.pythonhosted.org/packages/35/f8/9c66bfc55361ec6d0e4040a0337fb5924ceb23de4648b8a81ae9d33b2b38/triton-3.6.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d002e07d7180fd65e622134fbd980c9a3d4211fb85224b56a0a0efbd422ab72f", size = 188400296, upload-time = "2026-01-20T16:00:56.042Z" }, + { url = "https://files.pythonhosted.org/packages/49/55/5ecf0dcaa0f2fbbd4420f7ef227ee3cb172e91e5fede9d0ecaddc43363b4/triton-3.6.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ef5523241e7d1abca00f1d240949eebdd7c673b005edbbce0aca95b8191f1d43", size = 176138577, upload-time = "2026-01-20T16:16:25.426Z" }, + { url = "https://files.pythonhosted.org/packages/df/3d/9e7eee57b37c80cec63322c0231bb6da3cfe535a91d7a4d64896fcb89357/triton-3.6.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a17a5d5985f0ac494ed8a8e54568f092f7057ef60e1b0fa09d3fd1512064e803", size = 188273063, upload-time = "2026-01-20T16:01:07.278Z" }, + { url = "https://files.pythonhosted.org/packages/48/db/56ee649cab5eaff4757541325aca81f52d02d4a7cd3506776cad2451e060/triton-3.6.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0b3a97e8ed304dfa9bd23bb41ca04cdf6b2e617d5e782a8653d616037a5d537d", size = 176274804, upload-time = "2026-01-20T16:16:31.528Z" }, + { url = "https://files.pythonhosted.org/packages/f6/56/6113c23ff46c00aae423333eb58b3e60bdfe9179d542781955a5e1514cb3/triton-3.6.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:46bd1c1af4b6704e554cad2eeb3b0a6513a980d470ccfa63189737340c7746a7", size = 188397994, upload-time = "2026-01-20T16:01:14.236Z" }, +] + +[[package]] +name = "typer" +version = "0.24.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "annotated-doc" }, + { name = "click" }, + { name = "rich" }, + { name = "shellingham" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f5/24/cb09efec5cc954f7f9b930bf8279447d24618bb6758d4f6adf2574c41780/typer-0.24.1.tar.gz", hash = "sha256:e39b4732d65fbdcde189ae76cf7cd48aeae72919dea1fdfc16593be016256b45", size = 118613, upload-time = "2026-02-21T16:54:40.609Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4a/91/48db081e7a63bb37284f9fbcefda7c44c277b18b0e13fbc36ea2335b71e6/typer-0.24.1-py3-none-any.whl", hash = "sha256:112c1f0ce578bfb4cab9ffdabc68f031416ebcc216536611ba21f04e9aa84c9e", size = 56085, upload-time = "2026-02-21T16:54:41.616Z" }, +] + [[package]] name = "typing-extensions" version = "4.15.0" @@ -621,6 +2544,91 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/39/08/aaaad47bc4e9dc8c725e68f9d04865dbcb2052843ff09c97b08904852d84/urllib3-2.6.3-py3-none-any.whl", hash = "sha256:bf272323e553dfb2e87d9bfd225ca7b0f467b919d7bbd355436d3fd37cb0acd4", size = 131584, upload-time = "2026-01-07T16:24:42.685Z" }, ] +[[package]] +name = "wcwidth" +version = "0.6.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/35/a2/8e3becb46433538a38726c948d3399905a4c7cabd0df578ede5dc51f0ec2/wcwidth-0.6.0.tar.gz", hash = "sha256:cdc4e4262d6ef9a1a57e018384cbeb1208d8abbc64176027e2c2455c81313159", size = 159684, upload-time = "2026-02-06T19:19:40.919Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/68/5a/199c59e0a824a3db2b89c5d2dade7ab5f9624dbf6448dc291b46d5ec94d3/wcwidth-0.6.0-py3-none-any.whl", hash = "sha256:1a3a1e510b553315f8e146c54764f4fb6264ffad731b3d78088cdb1478ffbdad", size = 94189, upload-time = "2026-02-06T19:19:39.646Z" }, +] + +[[package]] +name = "wheel" +version = "0.46.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "packaging" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/89/24/a2eb353a6edac9a0303977c4cb048134959dd2a51b48a269dfc9dde00c8a/wheel-0.46.3.tar.gz", hash = "sha256:e3e79874b07d776c40bd6033f8ddf76a7dad46a7b8aa1b2787a83083519a1803", size = 60605, upload-time = "2026-01-22T12:39:49.136Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/87/22/b76d483683216dde3d67cba61fb2444be8d5be289bf628c13fc0fd90e5f9/wheel-0.46.3-py3-none-any.whl", hash = "sha256:4b399d56c9d9338230118d705d9737a2a468ccca63d5e813e2a4fc7815d8bc4d", size = 30557, upload-time = "2026-01-22T12:39:48.099Z" }, +] + +[[package]] +name = "wrapt" +version = "2.1.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/2e/64/925f213fdcbb9baeb1530449ac71a4d57fc361c053d06bf78d0c5c7cd80c/wrapt-2.1.2.tar.gz", hash = "sha256:3996a67eecc2c68fd47b4e3c564405a5777367adfd9b8abb58387b63ee83b21e", size = 81678, upload-time = "2026-03-06T02:53:25.134Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4c/b6/1db817582c49c7fcbb7df6809d0f515af29d7c2fbf57eb44c36e98fb1492/wrapt-2.1.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:ff2aad9c4cda28a8f0653fc2d487596458c2a3f475e56ba02909e950a9efa6a9", size = 61255, upload-time = "2026-03-06T02:52:45.663Z" }, + { url = "https://files.pythonhosted.org/packages/a2/16/9b02a6b99c09227c93cd4b73acc3678114154ec38da53043c0ddc1fba0dc/wrapt-2.1.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6433ea84e1cfacf32021d2a4ee909554ade7fd392caa6f7c13f1f4bf7b8e8748", size = 61848, upload-time = "2026-03-06T02:53:48.728Z" }, + { url = "https://files.pythonhosted.org/packages/af/aa/ead46a88f9ec3a432a4832dfedb84092fc35af2d0ba40cd04aea3889f247/wrapt-2.1.2-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:c20b757c268d30d6215916a5fa8461048d023865d888e437fab451139cad6c8e", size = 121433, upload-time = "2026-03-06T02:54:40.328Z" }, + { url = "https://files.pythonhosted.org/packages/3a/9f/742c7c7cdf58b59085a1ee4b6c37b013f66ac33673a7ef4aaed5e992bc33/wrapt-2.1.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:79847b83eb38e70d93dc392c7c5b587efe65b3e7afcc167aa8abd5d60e8761c8", size = 123013, upload-time = "2026-03-06T02:53:26.58Z" }, + { url = "https://files.pythonhosted.org/packages/e8/44/2c3dd45d53236b7ed7c646fcf212251dc19e48e599debd3926b52310fafb/wrapt-2.1.2-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f8fba1bae256186a83d1875b2b1f4e2d1242e8fac0f58ec0d7e41b26967b965c", size = 117326, upload-time = "2026-03-06T02:53:11.547Z" }, + { url = "https://files.pythonhosted.org/packages/74/e2/b17d66abc26bd96f89dec0ecd0ef03da4a1286e6ff793839ec431b9fae57/wrapt-2.1.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e3d3b35eedcf5f7d022291ecd7533321c4775f7b9cd0050a31a68499ba45757c", size = 121444, upload-time = "2026-03-06T02:54:09.5Z" }, + { url = "https://files.pythonhosted.org/packages/3c/62/e2977843fdf9f03daf1586a0ff49060b1b2fc7ff85a7ea82b6217c1ae36e/wrapt-2.1.2-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:6f2c5390460de57fa9582bc8a1b7a6c86e1a41dfad74c5225fc07044c15cc8d1", size = 116237, upload-time = "2026-03-06T02:54:03.884Z" }, + { url = "https://files.pythonhosted.org/packages/88/dd/27fc67914e68d740bce512f11734aec08696e6b17641fef8867c00c949fc/wrapt-2.1.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:7dfa9f2cf65d027b951d05c662cc99ee3bd01f6e4691ed39848a7a5fffc902b2", size = 120563, upload-time = "2026-03-06T02:53:20.412Z" }, + { url = "https://files.pythonhosted.org/packages/ec/9f/b750b3692ed2ef4705cb305bd68858e73010492b80e43d2a4faa5573cbe7/wrapt-2.1.2-cp312-cp312-win32.whl", hash = "sha256:eba8155747eb2cae4a0b913d9ebd12a1db4d860fc4c829d7578c7b989bd3f2f0", size = 58198, upload-time = "2026-03-06T02:53:37.732Z" }, + { url = "https://files.pythonhosted.org/packages/8e/b2/feecfe29f28483d888d76a48f03c4c4d8afea944dbee2b0cd3380f9df032/wrapt-2.1.2-cp312-cp312-win_amd64.whl", hash = "sha256:1c51c738d7d9faa0b3601708e7e2eda9bf779e1b601dce6c77411f2a1b324a63", size = 60441, upload-time = "2026-03-06T02:52:47.138Z" }, + { url = "https://files.pythonhosted.org/packages/44/e1/e328f605d6e208547ea9fd120804fcdec68536ac748987a68c47c606eea8/wrapt-2.1.2-cp312-cp312-win_arm64.whl", hash = "sha256:c8e46ae8e4032792eb2f677dbd0d557170a8e5524d22acc55199f43efedd39bf", size = 58836, upload-time = "2026-03-06T02:53:22.053Z" }, + { url = "https://files.pythonhosted.org/packages/4c/7a/d936840735c828b38d26a854e85d5338894cda544cb7a85a9d5b8b9c4df7/wrapt-2.1.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:787fd6f4d67befa6fe2abdffcbd3de2d82dfc6fb8a6d850407c53332709d030b", size = 61259, upload-time = "2026-03-06T02:53:41.922Z" }, + { url = "https://files.pythonhosted.org/packages/5e/88/9a9b9a90ac8ca11c2fdb6a286cb3a1fc7dd774c00ed70929a6434f6bc634/wrapt-2.1.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:4bdf26e03e6d0da3f0e9422fd36bcebf7bc0eeb55fdf9c727a09abc6b9fe472e", size = 61851, upload-time = "2026-03-06T02:52:48.672Z" }, + { url = "https://files.pythonhosted.org/packages/03/a9/5b7d6a16fd6533fed2756900fc8fc923f678179aea62ada6d65c92718c00/wrapt-2.1.2-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:bbac24d879aa22998e87f6b3f481a5216311e7d53c7db87f189a7a0266dafffb", size = 121446, upload-time = "2026-03-06T02:54:14.013Z" }, + { url = "https://files.pythonhosted.org/packages/45/bb/34c443690c847835cfe9f892be78c533d4f32366ad2888972c094a897e39/wrapt-2.1.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:16997dfb9d67addc2e3f41b62a104341e80cac52f91110dece393923c0ebd5ca", size = 123056, upload-time = "2026-03-06T02:54:10.829Z" }, + { url = "https://files.pythonhosted.org/packages/93/b9/ff205f391cb708f67f41ea148545f2b53ff543a7ac293b30d178af4d2271/wrapt-2.1.2-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:162e4e2ba7542da9027821cb6e7c5e068d64f9a10b5f15512ea28e954893a267", size = 117359, upload-time = "2026-03-06T02:53:03.623Z" }, + { url = "https://files.pythonhosted.org/packages/1f/3d/1ea04d7747825119c3c9a5e0874a40b33594ada92e5649347c457d982805/wrapt-2.1.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f29c827a8d9936ac320746747a016c4bc66ef639f5cd0d32df24f5eacbf9c69f", size = 121479, upload-time = "2026-03-06T02:53:45.844Z" }, + { url = "https://files.pythonhosted.org/packages/78/cc/ee3a011920c7a023b25e8df26f306b2484a531ab84ca5c96260a73de76c0/wrapt-2.1.2-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:a9dd9813825f7ecb018c17fd147a01845eb330254dff86d3b5816f20f4d6aaf8", size = 116271, upload-time = "2026-03-06T02:54:46.356Z" }, + { url = "https://files.pythonhosted.org/packages/98/fd/e5ff7ded41b76d802cf1191288473e850d24ba2e39a6ec540f21ae3b57cb/wrapt-2.1.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6f8dbdd3719e534860d6a78526aafc220e0241f981367018c2875178cf83a413", size = 120573, upload-time = "2026-03-06T02:52:50.163Z" }, + { url = "https://files.pythonhosted.org/packages/47/c5/242cae3b5b080cd09bacef0591691ba1879739050cc7c801ff35c8886b66/wrapt-2.1.2-cp313-cp313-win32.whl", hash = "sha256:5c35b5d82b16a3bc6e0a04349b606a0582bc29f573786aebe98e0c159bc48db6", size = 58205, upload-time = "2026-03-06T02:53:47.494Z" }, + { url = "https://files.pythonhosted.org/packages/12/69/c358c61e7a50f290958809b3c61ebe8b3838ea3e070d7aac9814f95a0528/wrapt-2.1.2-cp313-cp313-win_amd64.whl", hash = "sha256:f8bc1c264d8d1cf5b3560a87bbdd31131573eb25f9f9447bb6252b8d4c44a3a1", size = 60452, upload-time = "2026-03-06T02:53:30.038Z" }, + { url = "https://files.pythonhosted.org/packages/8e/66/c8a6fcfe321295fd8c0ab1bd685b5a01462a9b3aa2f597254462fc2bc975/wrapt-2.1.2-cp313-cp313-win_arm64.whl", hash = "sha256:3beb22f674550d5634642c645aba4c72a2c66fb185ae1aebe1e955fae5a13baf", size = 58842, upload-time = "2026-03-06T02:52:52.114Z" }, + { url = "https://files.pythonhosted.org/packages/da/55/9c7052c349106e0b3f17ae8db4b23a691a963c334de7f9dbd60f8f74a831/wrapt-2.1.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0fc04bc8664a8bc4c8e00b37b5355cffca2535209fba1abb09ae2b7c76ddf82b", size = 63075, upload-time = "2026-03-06T02:53:19.108Z" }, + { url = "https://files.pythonhosted.org/packages/09/a8/ce7b4006f7218248dd71b7b2b732d0710845a0e49213b18faef64811ffef/wrapt-2.1.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:a9b9d50c9af998875a1482a038eb05755dfd6fe303a313f6a940bb53a83c3f18", size = 63719, upload-time = "2026-03-06T02:54:33.452Z" }, + { url = "https://files.pythonhosted.org/packages/e4/e5/2ca472e80b9e2b7a17f106bb8f9df1db11e62101652ce210f66935c6af67/wrapt-2.1.2-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:2d3ff4f0024dd224290c0eabf0240f1bfc1f26363431505fb1b0283d3b08f11d", size = 152643, upload-time = "2026-03-06T02:52:42.721Z" }, + { url = "https://files.pythonhosted.org/packages/36/42/30f0f2cefca9d9cbf6835f544d825064570203c3e70aa873d8ae12e23791/wrapt-2.1.2-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3278c471f4468ad544a691b31bb856374fbdefb7fee1a152153e64019379f015", size = 158805, upload-time = "2026-03-06T02:54:25.441Z" }, + { url = "https://files.pythonhosted.org/packages/bb/67/d08672f801f604889dcf58f1a0b424fe3808860ede9e03affc1876b295af/wrapt-2.1.2-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a8914c754d3134a3032601c6984db1c576e6abaf3fc68094bb8ab1379d75ff92", size = 145990, upload-time = "2026-03-06T02:53:57.456Z" }, + { url = "https://files.pythonhosted.org/packages/68/a7/fd371b02e73babec1de6ade596e8cd9691051058cfdadbfd62a5898f3295/wrapt-2.1.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:ff95d4264e55839be37bafe1536db2ab2de19da6b65f9244f01f332b5286cfbf", size = 155670, upload-time = "2026-03-06T02:54:55.309Z" }, + { url = "https://files.pythonhosted.org/packages/86/2d/9fe0095dfdb621009f40117dcebf41d7396c2c22dca6eac779f4c007b86c/wrapt-2.1.2-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:76405518ca4e1b76fbb1b9f686cff93aebae03920cc55ceeec48ff9f719c5f67", size = 144357, upload-time = "2026-03-06T02:54:24.092Z" }, + { url = "https://files.pythonhosted.org/packages/0e/b6/ec7b4a254abbe4cde9fa15c5d2cca4518f6b07d0f1b77d4ee9655e30280e/wrapt-2.1.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:c0be8b5a74c5824e9359b53e7e58bef71a729bacc82e16587db1c4ebc91f7c5a", size = 150269, upload-time = "2026-03-06T02:53:31.268Z" }, + { url = "https://files.pythonhosted.org/packages/6e/6b/2fabe8ebf148f4ee3c782aae86a795cc68ffe7d432ef550f234025ce0cfa/wrapt-2.1.2-cp313-cp313t-win32.whl", hash = "sha256:f01277d9a5fc1862f26f7626da9cf443bebc0abd2f303f41c5e995b15887dabd", size = 59894, upload-time = "2026-03-06T02:54:15.391Z" }, + { url = "https://files.pythonhosted.org/packages/ca/fb/9ba66fc2dedc936de5f8073c0217b5d4484e966d87723415cc8262c5d9c2/wrapt-2.1.2-cp313-cp313t-win_amd64.whl", hash = "sha256:84ce8f1c2104d2f6daa912b1b5b039f331febfeee74f8042ad4e04992bd95c8f", size = 63197, upload-time = "2026-03-06T02:54:41.943Z" }, + { url = "https://files.pythonhosted.org/packages/c0/1c/012d7423c95d0e337117723eb8ecf73c622ce15a97847e84cf3f8f26cd7e/wrapt-2.1.2-cp313-cp313t-win_arm64.whl", hash = "sha256:a93cd767e37faeddbe07d8fc4212d5cba660af59bdb0f6372c93faaa13e6e679", size = 60363, upload-time = "2026-03-06T02:54:48.093Z" }, + { url = "https://files.pythonhosted.org/packages/39/25/e7ea0b417db02bb796182a5316398a75792cd9a22528783d868755e1f669/wrapt-2.1.2-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:1370e516598854e5b4366e09ce81e08bfe94d42b0fd569b88ec46cc56d9164a9", size = 61418, upload-time = "2026-03-06T02:53:55.706Z" }, + { url = "https://files.pythonhosted.org/packages/ec/0f/fa539e2f6a770249907757eaeb9a5ff4deb41c026f8466c1c6d799088a9b/wrapt-2.1.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:6de1a3851c27e0bd6a04ca993ea6f80fc53e6c742ee1601f486c08e9f9b900a9", size = 61914, upload-time = "2026-03-06T02:52:53.37Z" }, + { url = "https://files.pythonhosted.org/packages/53/37/02af1867f5b1441aaeda9c82deed061b7cd1372572ddcd717f6df90b5e93/wrapt-2.1.2-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:de9f1a2bbc5ac7f6012ec24525bdd444765a2ff64b5985ac6e0692144838542e", size = 120417, upload-time = "2026-03-06T02:54:30.74Z" }, + { url = "https://files.pythonhosted.org/packages/c3/b7/0138a6238c8ba7476c77cf786a807f871672b37f37a422970342308276e7/wrapt-2.1.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:970d57ed83fa040d8b20c52fe74a6ae7e3775ae8cff5efd6a81e06b19078484c", size = 122797, upload-time = "2026-03-06T02:54:51.539Z" }, + { url = "https://files.pythonhosted.org/packages/e1/ad/819ae558036d6a15b7ed290d5b14e209ca795dd4da9c58e50c067d5927b0/wrapt-2.1.2-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3969c56e4563c375861c8df14fa55146e81ac11c8db49ea6fb7f2ba58bc1ff9a", size = 117350, upload-time = "2026-03-06T02:54:37.651Z" }, + { url = "https://files.pythonhosted.org/packages/8b/2d/afc18dc57a4600a6e594f77a9ae09db54f55ba455440a54886694a84c71b/wrapt-2.1.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:57d7c0c980abdc5f1d98b11a2aa3bb159790add80258c717fa49a99921456d90", size = 121223, upload-time = "2026-03-06T02:54:35.221Z" }, + { url = "https://files.pythonhosted.org/packages/b9/5b/5ec189b22205697bc56eb3b62aed87a1e0423e9c8285d0781c7a83170d15/wrapt-2.1.2-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:776867878e83130c7a04237010463372e877c1c994d449ca6aaafeab6aab2586", size = 116287, upload-time = "2026-03-06T02:54:19.654Z" }, + { url = "https://files.pythonhosted.org/packages/f7/2d/f84939a7c9b5e6cdd8a8d0f6a26cabf36a0f7e468b967720e8b0cd2bdf69/wrapt-2.1.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:fab036efe5464ec3291411fabb80a7a39e2dd80bae9bcbeeca5087fdfa891e19", size = 119593, upload-time = "2026-03-06T02:54:16.697Z" }, + { url = "https://files.pythonhosted.org/packages/0b/fe/ccd22a1263159c4ac811ab9374c061bcb4a702773f6e06e38de5f81a1bdc/wrapt-2.1.2-cp314-cp314-win32.whl", hash = "sha256:e6ed62c82ddf58d001096ae84ce7f833db97ae2263bff31c9b336ba8cfe3f508", size = 58631, upload-time = "2026-03-06T02:53:06.498Z" }, + { url = "https://files.pythonhosted.org/packages/65/0a/6bd83be7bff2e7efaac7b4ac9748da9d75a34634bbbbc8ad077d527146df/wrapt-2.1.2-cp314-cp314-win_amd64.whl", hash = "sha256:467e7c76315390331c67073073d00662015bb730c566820c9ca9b54e4d67fd04", size = 60875, upload-time = "2026-03-06T02:53:50.252Z" }, + { url = "https://files.pythonhosted.org/packages/6c/c0/0b3056397fe02ff80e5a5d72d627c11eb885d1ca78e71b1a5c1e8c7d45de/wrapt-2.1.2-cp314-cp314-win_arm64.whl", hash = "sha256:da1f00a557c66225d53b095a97eace0fc5349e3bfda28fa34ffae238978ee575", size = 59164, upload-time = "2026-03-06T02:53:59.128Z" }, + { url = "https://files.pythonhosted.org/packages/71/ed/5d89c798741993b2371396eb9d4634f009ff1ad8a6c78d366fe2883ea7a6/wrapt-2.1.2-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:62503ffbc2d3a69891cf29beeaccdb4d5e0a126e2b6a851688d4777e01428dbb", size = 63163, upload-time = "2026-03-06T02:52:54.873Z" }, + { url = "https://files.pythonhosted.org/packages/c6/8c/05d277d182bf36b0a13d6bd393ed1dec3468a25b59d01fba2dd70fe4d6ae/wrapt-2.1.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c7e6cd120ef837d5b6f860a6ea3745f8763805c418bb2f12eeb1fa6e25f22d22", size = 63723, upload-time = "2026-03-06T02:52:56.374Z" }, + { url = "https://files.pythonhosted.org/packages/f4/27/6c51ec1eff4413c57e72d6106bb8dec6f0c7cdba6503d78f0fa98767bcc9/wrapt-2.1.2-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:3769a77df8e756d65fbc050333f423c01ae012b4f6731aaf70cf2bef61b34596", size = 152652, upload-time = "2026-03-06T02:53:23.79Z" }, + { url = "https://files.pythonhosted.org/packages/db/4c/d7dd662d6963fc7335bfe29d512b02b71cdfa23eeca7ab3ac74a67505deb/wrapt-2.1.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a76d61a2e851996150ba0f80582dd92a870643fa481f3b3846f229de88caf044", size = 158807, upload-time = "2026-03-06T02:53:35.742Z" }, + { url = "https://files.pythonhosted.org/packages/b4/4d/1e5eea1a78d539d346765727422976676615814029522c76b87a95f6bcdd/wrapt-2.1.2-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:6f97edc9842cf215312b75fe737ee7c8adda75a89979f8e11558dfff6343cc4b", size = 146061, upload-time = "2026-03-06T02:52:57.574Z" }, + { url = "https://files.pythonhosted.org/packages/89/bc/62cabea7695cd12a288023251eeefdcb8465056ddaab6227cb78a2de005b/wrapt-2.1.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:4006c351de6d5007aa33a551f600404ba44228a89e833d2fadc5caa5de8edfbf", size = 155667, upload-time = "2026-03-06T02:53:39.422Z" }, + { url = "https://files.pythonhosted.org/packages/e9/99/6f2888cd68588f24df3a76572c69c2de28287acb9e1972bf0c83ce97dbc1/wrapt-2.1.2-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:a9372fc3639a878c8e7d87e1556fa209091b0a66e912c611e3f833e2c4202be2", size = 144392, upload-time = "2026-03-06T02:54:22.41Z" }, + { url = "https://files.pythonhosted.org/packages/40/51/1dfc783a6c57971614c48e361a82ca3b6da9055879952587bc99fe1a7171/wrapt-2.1.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:3144b027ff30cbd2fca07c0a87e67011adb717eb5f5bd8496325c17e454257a3", size = 150296, upload-time = "2026-03-06T02:54:07.848Z" }, + { url = "https://files.pythonhosted.org/packages/6c/38/cbb8b933a0201076c1f64fc42883b0023002bdc14a4964219154e6ff3350/wrapt-2.1.2-cp314-cp314t-win32.whl", hash = "sha256:3b8d15e52e195813efe5db8cec156eebe339aaf84222f4f4f051a6c01f237ed7", size = 60539, upload-time = "2026-03-06T02:54:00.594Z" }, + { url = "https://files.pythonhosted.org/packages/82/dd/e5176e4b241c9f528402cebb238a36785a628179d7d8b71091154b3e4c9e/wrapt-2.1.2-cp314-cp314t-win_amd64.whl", hash = "sha256:08ffa54146a7559f5b8df4b289b46d963a8e74ed16ba3687f99896101a3990c5", size = 63969, upload-time = "2026-03-06T02:54:39Z" }, + { url = "https://files.pythonhosted.org/packages/5c/99/79f17046cf67e4a95b9987ea129632ba8bcec0bc81f3fb3d19bdb0bd60cd/wrapt-2.1.2-cp314-cp314t-win_arm64.whl", hash = "sha256:72aaa9d0d8e4ed0e2e98019cea47a21f823c9dd4b43c7b77bba6679ffcca6a00", size = 60554, upload-time = "2026-03-06T02:53:14.132Z" }, + { url = "https://files.pythonhosted.org/packages/1a/c7/8528ac2dfa2c1e6708f647df7ae144ead13f0a31146f43c7264b4942bf12/wrapt-2.1.2-py3-none-any.whl", hash = "sha256:b8fd6fa2b2c4e7621808f8c62e8317f4aae56e59721ad933bac5239d913cf0e8", size = 43993, upload-time = "2026-03-06T02:53:12.905Z" }, +] + [[package]] name = "xarray" version = "2026.2.0"