commit dbbddf79bbfe3ca4124cbd3bd81985861b7ef713 Author: dpachner02 Date: Thu Nov 13 14:54:37 2025 +0100 initial commit diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..505a3b1 --- /dev/null +++ b/.gitignore @@ -0,0 +1,10 @@ +# Python-generated files +__pycache__/ +*.py[oc] +build/ +dist/ +wheels/ +*.egg-info + +# Virtual environments +.venv diff --git a/.python-version b/.python-version new file mode 100644 index 0000000..e4fba21 --- /dev/null +++ b/.python-version @@ -0,0 +1 @@ +3.12 diff --git a/0_ExplorativeDatenanaylse_Einführung_fertig_2120830.ipynb b/0_ExplorativeDatenanaylse_Einführung_fertig_2120830.ipynb new file mode 100644 index 0000000..d84c9ee --- /dev/null +++ b/0_ExplorativeDatenanaylse_Einführung_fertig_2120830.ipynb @@ -0,0 +1,954 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "7d1106cf", + "metadata": {}, + "source": [ + "# Vorbereitung auf die DAT - Labore\n", + "\n", + "### Vorwissen:\n", + "Ich erwarte ein gewisses Vorwissen in Statistik (z.B. Basics aus MA3). Dies können Sie sich zum Beispiel aneignen durch:\n", + "- Kopp-Schneider, Werft \"Grundlagen der Statistik\" in Medizinische Physik: https://link.springer.com/book/10.1007%2F978-3-662-54801-1\n", + "(pdf des Kapitels auch auf moodle)\n", + "\n", + "### Literatur für die ersten Labore: \n", + "- Bruce et al. Praktische Statistik für Data Scientists, Kapitel 1 bis 3\n", + "- Sauer, Moderne Datenanalyse mit R:\n", + " - Wir machen ein Teil der Analyse aus Kapitel 10 mit Python\n", + " - später Kapitel 17 (und Teile aus 15-16)\n", + "- Python-Dokumentationen, z.B. VanderPlas: Data Science mit Python\n", + "\n", + "### Sie werden hier:\n", + "- Erste Schritte in python gehen $\\rightarrow$ Test Ihrer Python-Umgebung, evtl. Aneignen oder Auffrischen grundlegender Python Kenntnisse zum Daten laden und visualisieren\n", + "- Hinweise erhalten, auf welcher Theorie die ersten Labore aufbauen $\\rightarrow$ Möglichkeit zur Vorbereitung und/oder zur Auffrischung von Vorwissen\n", + "\n", + "### Lernziele:\n", + "- Sie können den NYCFlights Datensatz laden und den gekürzten Datensatz in einem DataFrame darstellen. Sie wissen zudem wie eine Tabelle mit Daten für eine Datenanalyse aussehen sollte. \n", + "- Sie können Daten mit seaborn als Balkendiagramm, Boxplot, Violinplot und kategorialen Barplot darstellen.\n", + "- Sie können deskriptive Statistiken berechnen und bewerten.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "3548bf3f", + "metadata": { + "ExecuteTime": { + "end_time": "2024-09-27T07:14:18.427404Z", + "start_time": "2024-09-27T07:14:18.416601Z" + } + }, + "outputs": [], + "source": [ + "# Import nötiger Module\n", + "\n", + "# Daten einlesen und Daten verarbeiten\n", + "import pandas as pd\n", + "\n", + "# Plotten\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns # zum (einfacheren) Erstellen guter statistischer Plots\n", + "\n", + "sns.set_theme() # alle Plots (auch von matplotlib) im seaborn-Style\n", + "\n", + "# Numerische und statistisches Werkzeug\n", + "import numpy as np\n", + "from scipy import stats" + ] + }, + { + "cell_type": "markdown", + "id": "81da0a5a", + "metadata": {}, + "source": [ + "## 1. Vorbereitung der Daten: NYCFlights Datensatz\n", + "Ein in vielen Data Science Lehrbüchern und Anleitungen verwendeter Datensatz sind Flugdaten von New York City aus dem Jahr 2013. Diesen Datensatz werden wir in mehreren Laboren verwenden, um uns verschiedene Aspekte von Datenanalysen anzuschauen. \n", + "\n", + "Wir nutzen in den ersten Laboren eine gekürzte Version des Datensatzes, da wir alle Beobachtungen mit fehlenden Werten erst einmal löschen. Andere Varianten mit fehlenden Werten umzugehen (Feature Engineering) schauen wir uns später an.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "e429ce79-f282-4000-b6d7-a72449e88f51", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: nycflights13 in ./lib/python3.12/site-packages (0.0.3)\n", + "Requirement already satisfied: pandas>=0.24.0 in ./lib/python3.12/site-packages (from nycflights13) (2.3.2)\n", + "Requirement already satisfied: numpy>=1.26.0 in ./lib/python3.12/site-packages (from pandas>=0.24.0->nycflights13) (2.3.3)\n", + "Requirement already satisfied: python-dateutil>=2.8.2 in ./lib/python3.12/site-packages (from pandas>=0.24.0->nycflights13) (2.9.0.post0)\n", + "Requirement already satisfied: pytz>=2020.1 in ./lib/python3.12/site-packages (from pandas>=0.24.0->nycflights13) (2025.2)\n", + "Requirement already satisfied: tzdata>=2022.7 in ./lib/python3.12/site-packages (from pandas>=0.24.0->nycflights13) (2025.2)\n", + "Requirement already satisfied: six>=1.5 in ./lib/python3.12/site-packages (from python-dateutil>=2.8.2->pandas>=0.24.0->nycflights13) (1.17.0)\n", + "Note: you may need to restart the kernel to use updated packages.\n" + ] + } + ], + "source": [ + "pip install nycflights13" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "7536dd73", + "metadata": { + "ExecuteTime": { + "end_time": "2024-09-27T07:14:20.002045Z", + "start_time": "2024-09-27T07:14:18.512263Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
yearmonthdaydep_timesched_dep_timedep_delayarr_timesched_arr_timearr_delaycarrierflighttailnumorigindestair_timedistancehourminutetime_hour
0201311517.05152.0830.081911.0UA1545N14228EWRIAH227.014005152013-01-01T10:00:00Z
1201311533.05294.0850.083020.0UA1714N24211LGAIAH227.014165292013-01-01T10:00:00Z
2201311542.05402.0923.085033.0AA1141N619AAJFKMIA160.010895402013-01-01T10:00:00Z
3201311544.0545-1.01004.01022-18.0B6725N804JBJFKBQN183.015765452013-01-01T10:00:00Z
4201311554.0600-6.0812.0837-25.0DL461N668DNLGAATL116.0762602013-01-01T11:00:00Z
\n", + "
" + ], + "text/plain": [ + " year month day dep_time sched_dep_time dep_delay arr_time \\\n", + "0 2013 1 1 517.0 515 2.0 830.0 \n", + "1 2013 1 1 533.0 529 4.0 850.0 \n", + "2 2013 1 1 542.0 540 2.0 923.0 \n", + "3 2013 1 1 544.0 545 -1.0 1004.0 \n", + "4 2013 1 1 554.0 600 -6.0 812.0 \n", + "\n", + " sched_arr_time arr_delay carrier flight tailnum origin dest air_time \\\n", + "0 819 11.0 UA 1545 N14228 EWR IAH 227.0 \n", + "1 830 20.0 UA 1714 N24211 LGA IAH 227.0 \n", + "2 850 33.0 AA 1141 N619AA JFK MIA 160.0 \n", + "3 1022 -18.0 B6 725 N804JB JFK BQN 183.0 \n", + "4 837 -25.0 DL 461 N668DN LGA ATL 116.0 \n", + "\n", + " distance hour minute time_hour \n", + "0 1400 5 15 2013-01-01T10:00:00Z \n", + "1 1416 5 29 2013-01-01T10:00:00Z \n", + "2 1089 5 40 2013-01-01T10:00:00Z \n", + "3 1576 5 45 2013-01-01T10:00:00Z \n", + "4 762 6 0 2013-01-01T11:00:00Z " + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"\"\"\n", + "Laden des Datensatzes. Er liegt als DataFrame vor: https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.html\n", + "DataFrames ermöglichen das (schnelle) Arbeiten auch mit größeren Datensätzen.\n", + "\n", + "Doku des R-Packages: https://nycflights13.tidyverse.org/reference/flights.html\n", + "\n", + "Zu diesem Datensatz gibt es dann noch weitere Infodatensätze, z.B. zu den Flughäfen: https://nycflights13.tidyverse.org/reference/airports.html\n", + ">>> from nycflights13 import airports\n", + "\n", + "\"\"\"\n", + "from nycflights13 import flights\n", + "\n", + "# Vorschau von 5 Zeilen der Daten in einem DataFrame:\n", + "flights.head(5)" + ] + }, + { + "cell_type": "markdown", + "id": "d72baf05", + "metadata": {}, + "source": [ + "### Aussehen einer Datentabelle\n", + "Sie sehen nun eine Tabelle mit Daten. So sollte zunächst bei jeder Datenanalyse der vorbereitete Datensatz aussehen.\n", + "Es gelten folgende Konventionen:\n", + "- jede Zeile enthält eine Beobachtung (engl. observation), hier einen Flug\n", + "- jede Spalte enthält eine Variable (engl. variable, feature...). Diese können kategorial aber auch kontinuierlich sein. Ordnen Sie zu und wenn unbekannt, recherchieren Sie mögliche Datentypen! \n", + "- Bei jeder Datenanalyse sollten Sie ein sog. \"Code Book\" führen, in dem auch festgehalten ist, was die verschiedenen Variablen bedeuten. Infos zu den vorliegenden Daten (was bedeutet dep_time, welche Einheit...) finden Sie in der oben verlinkten Doku zum korrespondierenden R-Paket\n", + "\n", + "### Kürzen des Datensatzes\n", + "Da der Datensatz viele fehlende Werte enthält und wir uns zunächst auf die Visualisierung und deskriptive Statistik konzentrieren wollen, löschen wir zunächst alle Zeilen mit fehlenden Werten und verwenden einen gekürzten Datensatz.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "0e26db8b", + "metadata": { + "ExecuteTime": { + "end_time": "2024-09-27T07:14:20.804624Z", + "start_time": "2024-09-27T07:14:20.226757Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "year 0\n", + "month 0\n", + "day 0\n", + "dep_time 8255\n", + "sched_dep_time 0\n", + "dep_delay 8255\n", + "arr_time 8713\n", + "sched_arr_time 0\n", + "arr_delay 9430\n", + "carrier 0\n", + "flight 0\n", + "tailnum 2512\n", + "origin 0\n", + "dest 0\n", + "air_time 9430\n", + "distance 0\n", + "hour 0\n", + "minute 0\n", + "time_hour 0\n", + "dtype: int64\n" + ] + } + ], + "source": [ + "# Herausfinden welche Spalte wie viele fehlende Werte, die als nans (not a number) kodiert sind, enthält:\n", + "print(flights.isna().sum())" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "79e435de", + "metadata": { + "ExecuteTime": { + "end_time": "2024-09-27T07:14:22.090779Z", + "start_time": "2024-09-27T07:14:21.298237Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Anzahl gelöschter Zeilen: 9430 von 336776 (2.8%)\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
yearmonthdaydep_timesched_dep_timedep_delayarr_timesched_arr_timearr_delaycarrierflighttailnumorigindestair_timedistancehourminutetime_hour
0201311517.05152.0830.081911.0UA1545N14228EWRIAH227.014005152013-01-01T10:00:00Z
1201311533.05294.0850.083020.0UA1714N24211LGAIAH227.014165292013-01-01T10:00:00Z
2201311542.05402.0923.085033.0AA1141N619AAJFKMIA160.010895402013-01-01T10:00:00Z
3201311544.0545-1.01004.01022-18.0B6725N804JBJFKBQN183.015765452013-01-01T10:00:00Z
4201311554.0600-6.0812.0837-25.0DL461N668DNLGAATL116.0762602013-01-01T11:00:00Z
\n", + "
" + ], + "text/plain": [ + " year month day dep_time sched_dep_time dep_delay arr_time \\\n", + "0 2013 1 1 517.0 515 2.0 830.0 \n", + "1 2013 1 1 533.0 529 4.0 850.0 \n", + "2 2013 1 1 542.0 540 2.0 923.0 \n", + "3 2013 1 1 544.0 545 -1.0 1004.0 \n", + "4 2013 1 1 554.0 600 -6.0 812.0 \n", + "\n", + " sched_arr_time arr_delay carrier flight tailnum origin dest air_time \\\n", + "0 819 11.0 UA 1545 N14228 EWR IAH 227.0 \n", + "1 830 20.0 UA 1714 N24211 LGA IAH 227.0 \n", + "2 850 33.0 AA 1141 N619AA JFK MIA 160.0 \n", + "3 1022 -18.0 B6 725 N804JB JFK BQN 183.0 \n", + "4 837 -25.0 DL 461 N668DN LGA ATL 116.0 \n", + "\n", + " distance hour minute time_hour \n", + "0 1400 5 15 2013-01-01T10:00:00Z \n", + "1 1416 5 29 2013-01-01T10:00:00Z \n", + "2 1089 5 40 2013-01-01T10:00:00Z \n", + "3 1576 5 45 2013-01-01T10:00:00Z \n", + "4 762 6 0 2013-01-01T11:00:00Z " + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Mit fehlenden Werten beschäftigen wir uns später. Hier nutzen wie zunächst den gekürzten Datensatz und werfen alle Zeilen mit fehlenden Werten raus.\n", + "\n", + "fls = flights.dropna() # fls = flights ohne NaNs, das ist unser Datensatz für die ersten Gehversuche mit Visualisierungen, Gruppierungen und deskriptiven Statistiken\n", + "\n", + "# Wie viele Zeilen wurden gelöscht?\n", + "number_deleted = len(flights) - len(fls)\n", + "number_deleted_percent = np.round(number_deleted / len(flights) * 100, 2)\n", + "print(f\"Anzahl gelöschter Zeilen: {number_deleted} von {len(flights)} ({number_deleted_percent}%)\")\n", + "fls.head()" + ] + }, + { + "cell_type": "markdown", + "id": "6418c67c", + "metadata": {}, + "source": [ + "## 2. Erste Python Schritte zur Datenvisualisierung\n", + "\n", + "Wir starten DAT mit der explorativen Datenanalyse, d.h. es geht darum einen Überblick über den vorliegenden Datensatz zu bekommen. Das geht besonders gut durch Visualisierungen. Daher hier zunächst der Test, ob bei Ihnen alle nötigen Pakete installiert sind und funktionieren. Zudem können Sie starten sich in die Syntax einzuarbeiten.\n", + "\n", + "Einige werden `matplotlib` kennen. Für statistische Datenvisualisierungen ist das Paket `seaborn` sehr nützlich. Es basiert auf `matplotlib`. Es vereinfacht sehr viele Vorgänge und liefert überaus nützliche und hochwertige Graphen: \n", + "https://seaborn.pydata.org/index.html\n", + "\n", + "Ändern von Darstellung und Beschriftung etc. basiert auf matplotlib. Die Dokumentation finden Sie unter: https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.html\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "c6af1355", + "metadata": {}, + "source": [ + "### Visualisierung kategorieller Daten\n", + "\n", + "Wir nutzen hierfür `seaborn`, da dort Graphentypen vorliegen, die die Kategorisierung vornehmen. Alternativ geht das auch, wenn man die Werte mit `pandas` kategorisiert und dann nur mit `matplotlib` darstellt. Die Visualisierung und damit das Gewinnen eines Überblicks über den vorliegenden Datensatz ist immer der erste Schritt einer Datenanalyse, die sog. explorative Datenanalyse. Hier geht es nicht darum, Schlüsse zu ziehen oder Vorhersagen zu treffen, sondern die vorliegenden Daten verstehen zu lernen.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "d170440d", + "metadata": { + "ExecuteTime": { + "end_time": "2024-09-27T07:14:23.837640Z", + "start_time": "2024-09-27T07:14:22.203336Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Visualisierung von kategorialen Features mit seaborn:\n", + "# seaborn hat eine Funktion, die die Anzahl der Werte zählt und als Balkendiagramm darstellt. Hier ein Graph, der die Anzahl der Flüge zählt, die von den verschiedenen Abflughäfen starten:\n", + "sns.countplot(data=fls, x='origin')\n", + "plt.show() # zeigt die Grafik an, ohne die Objektinformationen auszugeben" + ] + }, + { + "cell_type": "markdown", + "id": "b391bc98d6e683fd", + "metadata": {}, + "source": [ + "Um mehrere Graphen nebeneinander/untereinander darzustellen eignen sich subplots. Hier ein Beispiel mit 3 Graphen nebeneinander. Die Position ergibt sich dann aus `ax=axs[0]` etc. \n", + "\n", + "#### Aufgabe: \n", + "- Wählen Sie zwei weitere Kategorien aus der Tabelle aus und fügen Sie einen Graphen mit anderer Kategorisierung zu `axs[1]` und `axs[2]` hinzu\n", + "- Erstellen Sie passende Titel für die Graphen\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "a0f2e100", + "metadata": { + "ExecuteTime": { + "end_time": "2024-09-27T07:14:26.286294Z", + "start_time": "2024-09-27T07:14:24.209824Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#3 Balkendiagramme zu Abflughafen, 'Ihre Auswahl' und 'Ihre Auswahl':\n", + "\n", + "fig, axs = plt.subplots(1, 3, figsize=(15, 5))\n", + "sns.countplot(data=fls, x='origin', ax=axs[0]).set_title(\"Abfuhr\")\n", + "sns.countplot(data=fls, x='dest', ax=axs[1]).set_title(\"Ankunft\")\n", + "sns.countplot(data=fls, x='carrier', ax=axs[2]).set_title(\"Lufthansa\")\n", + "#TODO: Graphen für axs[1] und axs[2] hinzufügen\n", + "#TODO: Titel für die Graphen hinzufügen\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "4656d434", + "metadata": {}, + "source": [ + "### Zusammenfassung kontinuierlicher Variablen\n", + "\n", + "Die Flugverspätung `arr_delay` ist eine kontinuierliche Variable, d.h. es gibt eine große Anzahl (prinzipiell unendlich viele) unterschiedliche Werte.\n", + "Die Darstellung erfolgt dann in einem Histogramm, die Werte werden in Klassen (engl. bins) zusammengefasst." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "489fadc9", + "metadata": { + "ExecuteTime": { + "end_time": "2024-09-27T07:14:27.401876Z", + "start_time": "2024-09-27T07:14:26.408359Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.histplot(data=fls, x='arr_delay', bins=100)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "1da45283", + "metadata": {}, + "source": [ + "Hier schauen wir zunächst auf zusammenfassende Statistiken wie Mittelwert, Standardabweichung, Median, Quantile etc. Wenn Ihnen diese Begriffe nicht bekannt sind, lesen Sie bitte in einem Statistikbuch nach. Verständnis und Interpretation üben wir in der nächsten Vorlesung.\n", + "\n", + "Verschiedene Module bieten Zusammenfassungen von Statistikdaten.\n", + "Hier finden Sie einige Dokumentationen: \n", + "https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.describe.html\n", + "https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.describe.html\n", + "https://www.statsmodels.org/stable/generated/statsmodels.stats.descriptivestats.describe.html#statsmodels.stats.descriptivestats.describe\n", + "\n", + "\n", + "#### Wichtiger Hinweis zur Berechnung von Varianzen und Standardabweichungen\n", + "Verschiedene Bibliotheken verwenden verschiedene Vorfaktoren für die Berechnung von Streuparametern. Traditionell wird in der deskriptiven Statistik der Vorfaktor $\\frac{1}{n}$ verwendet. Damit sind die Metriken aber nicht erwartungstreu. Daher sollte, wie in der schließenden Statistik üblich, der Vorfaktor $\\frac{1}{n-1}$ verwendet werden. Gekennzeichnet wird das über den Parameter ddof (delta degrees of freedom): ddof=0 für $\\frac{1}{n}$ und ddof=1 für $\\frac{1}{n-1}$. \n", + "\n", + "Pandas: ddof=1\n", + "scipy: ddof=0\n", + "numpy: ddof=0\n" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "46a03abc", + "metadata": { + "ExecuteTime": { + "end_time": "2024-09-27T07:14:27.608456Z", + "start_time": "2024-09-27T07:14:27.583742Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "count 327346.000000\n", + "mean 6.895377\n", + "std 44.633292\n", + "min -86.000000\n", + "25% -17.000000\n", + "50% -5.000000\n", + "75% 14.000000\n", + "max 1272.000000\n", + "Name: arr_delay, dtype: float64\n" + ] + } + ], + "source": [ + "#Calculate descriptive statistics using pandas for fls[\"arr_delay\"]. As fls is a pandas dataFrame this is a pandas method.\n", + "print(fls[\"arr_delay\"].describe())" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "04e7441a", + "metadata": { + "ExecuteTime": { + "end_time": "2024-09-27T07:14:27.760088Z", + "start_time": "2024-09-27T07:14:27.711610Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "DescribeResult(nobs=np.int64(327346), minmax=(np.float64(-86.0), np.float64(1272.0)), mean=np.float64(6.89537675731489), variance=np.float64(1992.1307271019398), skewness=np.float64(3.7168004488352424), kurtosis=np.float64(29.232579155522807))" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Calculate descriptive statistics using scipy for fls[\"arr_delay\"]. Be aware to correct for ddof=1!\n", + "stats.describe(fls[\"arr_delay\"], ddof=1)" + ] + }, + { + "cell_type": "markdown", + "id": "cb5308ef", + "metadata": {}, + "source": [ + "### Visualisierung zusammengefasster kontinuierlicher Daten nach Kategorie\n", + "\n", + "Es gibt verschiedene Möglichkeiten Zusammenfassungen von kontinuierlichen Daten nach Kategorien darzustellen. Hier drei schöne Beispiel aus seaborn im Vergleich:\n", + "- Boxplot: grafische Übersicht der wichtigsten Quantile. Praktischerweise dann auch für verschiedene Kategorien einer Variable getrennt möglich\n", + "- Violinplot: kombiniert Dichteschätzer und Boxlot (Box nimmt Form der geschätzten Dichtefunktion an)\n", + "- Kategoriale Barplots verschiedener Metriken (Mittelwert, Median, etc.)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "6d5810fb", + "metadata": { + "ExecuteTime": { + "end_time": "2024-09-27T07:14:42.376578Z", + "start_time": "2024-09-27T07:14:27.799428Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(1, 3, figsize=(16, 5))\n", + "\n", + "sns.boxplot(x=\"origin\", y=\"arr_delay\", data=fls, ax=axs[0])\n", + "sns.violinplot(x=\"origin\", y=\"arr_delay\", data=fls, ax=axs[1])\n", + "sns.barplot(data=fls, x=\"origin\", y=\"arr_delay\", estimator=\"median\", ax=axs[2])\n", + "\n", + "axs[0].set_ylabel('Arrival Delay in Minutes')\n", + "axs[1].set_ylabel('Arrival Delay in Minutes')\n", + "axs[2].set_ylabel('Median Arrival Delay in Minutes')\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "4b8cd2caf98fe15a", + "metadata": {}, + "source": [ + "##### Überlegen Sie:\n", + "- Was zeigen die verschiedenen Graphen? $\\rightarrow$ Lesen Sie ggf. nach, wie die verschiedenen Graphen definiert sind\n", + "- Welche Vor- und Nachteile haben die verschiedenen Graphen? \n", + "\n", + "\n", + "### Lageparameter im Vergleich\n", + "Im Balkendiagramm können verschiedene statistische Größen gezeigt werden. Unten zwei Graphen, die die Lageparameter Mittelwert und Median nebeneinander stellen. \n", + " \n", + "##### Überlegen Sie:\n", + "- Welche Unterschiede sehen Sie? \n", + "- Woran könnte das liegen?\n" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "5f3475ea", + "metadata": { + "ExecuteTime": { + "end_time": "2024-09-27T07:14:53.917392Z", + "start_time": "2024-09-27T07:14:42.415234Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(1, 2, figsize=(15, 5), sharey=True)\n", + "sns.barplot(data=fls, x=\"origin\", y=\"arr_delay\", ax=axs[0]) # Mittelwert, Fehlerbalken werden defaultmäßig angezeigt \n", + "sns.barplot(data=fls, x=\"origin\", y=\"arr_delay\", estimator='median', ax=axs[1]) # Median\n", + "\n", + "axs[0].set_title('Mean Arrival Delay in Minutes')\n", + "axs[1].set_title('Median Arrival Delay in Minutes')\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "57782e6a47eb2008", + "metadata": {}, + "source": [ + "## 3. Weitere Untersuchung des Datensatzes\n", + "\n", + "Nutzen Sie die Ihnen bekannten Mehoden, um den Datensatz weiter zu untersuchen." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "651c0e725e27db74", + "metadata": { + "ExecuteTime": { + "end_time": "2024-09-27T07:14:53.957094Z", + "start_time": "2024-09-27T07:14:53.949728Z" + } + }, + "outputs": [], + "source": [ + "# TODO: Weitere Daten visualisieren und Statistiken berechnen" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/1_ExplorativeDatenanaylse.ipynb b/1_ExplorativeDatenanaylse.ipynb new file mode 100644 index 0000000..62560c8 --- /dev/null +++ b/1_ExplorativeDatenanaylse.ipynb @@ -0,0 +1,480 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "7d1106cf", + "metadata": {}, + "source": [ + "# Explorative Datenanalyse des NYCFlights Datensatzes\n", + "\n", + "### Vorwissen:\n", + "Mit einem gewissen Vorwissen in Statistik (Basics aus MA3) haben Sie mehr von der Veranstaltung. Die wichtigsten Grundlagen finden Sie zum Beispiel in:\n", + "- Kopp-Schneider, Werft “Grundlagen der Statistik” in Medizinische Physik: https://link.springer.com/book/10.1007%2F978-3-662-54801-1\n", + "\n", + "### Literatur zum Nachschlagen während des Labors (Links auf moodle): \n", + "- Bruce et al. Praktische Statistik für Data Scientists, Kapitel 1 bis Seite 31\n", + "- Sauer, Moderne Datenanalyse mit R: Wir machen eine ähnliche Analyse mit Python wie in Kapitel 10 (ohne 10.2.3) mit R beschrieben\n", + "- Python-Dokumentationen, z.B. VanderPlas: Data Science mit Python\n", + "\n", + "### Sie werden hier:\n", + "- Datensatz einlesen/laden\n", + "- Daten als Tabelle anschauen: typische Datenstruktur für Data Science: pandas DataFrame\n", + "- Unterschiedliche Skalentypen der Daten erkennen\n", + "- Kategoriale Daten visualisieren (Welche Datentypen sind kategorial?)\n", + "- Metrische (kontinuierlich oder diskret mit vielen Werten) Daten visualisieren und nach Kategorien sortiert visualisieren\n", + "- Zusammenhänge zwischen metrischen Daten visualisieren und interpretieren\n", + "- den NYCFlights Datensatz erkunden\n", + "\n", + "### Lernziele:\n", + "- Sie haben eine erste Idee wie eine explorative Datenanalyse funktioniert und sich schon einmal in einen Datensatz vertieft.\n", + "- Sie erkennen unterschiedliche Datentypen und können Daten unterschiedlicher Datentypen geeignet visualisieren.\n", + "- Sie können Visualisierungen nach verschiedenen Kategorien in Python nutzen und wissen, wann welche Visualisierung sinnvoll ist.\n", + "\n", + "### Output:\n", + "- 1 Graph Ihrer Wahl (jede/r wird vermutlich etwas anderes finden, was sie/er interessant findet. Zu Beginn der nächsten Vorlesung werden wir alle Graphen anschauen und so unser Wissen über den Datensatz erweitern). Bitte bis nächsten Dienstag auf moodle hochladen. Bitte stellen Sie die Daten so dar, dass sie auf einer Folie erkennbar sind (Größe der Achsenbeschriftung, etc.)." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "3548bf3f", + "metadata": {}, + "outputs": [], + "source": [ + "#Nötige Module importieren\n", + "\n", + "#Daten einlesen und Daten verarbeiten\n", + "import pandas as pd\n", + "\n", + "#Plotten\n", + "import matplotlib.pyplot as plt\n", + "\n", + "#zum (einfacheren) Erstellen guter statistischer Plots:\n", + "import seaborn as sns\n", + "\n", + "sns.set_theme() # alle Plots (auch von matplotlib) im seaborn-Style\n", + "\n", + "# Numerische und statistisches Werkzeug\n", + "import numpy as np\n", + "from scipy import stats" + ] + }, + { + "cell_type": "markdown", + "id": "6418c67c", + "metadata": {}, + "source": [ + "## Anleitung\n", + "\n", + "Im Folgenden sollen Sie versuchen mit Hilfe von Visualisierungen einen (ersten) Überblick über den NYCFlights Datensatz zu bekommen. Für einfache und gute statistische Datenvisualisierungen eignet sich das Paket `seaborn`. Es basiert auf `matplotlib`. Es vereinfacht sehr viele Vorgänge und liefert überaus nützliche und hochwertige Graphen: \n", + "https://seaborn.pydata.org/index.html\n", + "\n", + "Ändern von Darstellung und Beschriftung etc. basiert auf matplotlib. Die Dokumentation finden Sie unter: https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.html\n", + "\n", + "In der letzten Anleitung gab es hierzu schon die ersten Graphen. Nun wollen wir uns etwas genauer mit dem Datensatz beschäftigen. Wir fokussieren uns in diesem Labor darauf, Daten abhängig von verschiedenen Kategorien zu visualisieren. Verteilungen von kontinuierlichen Daten betrachten wir in späteren Laboren." + ] + }, + { + "cell_type": "markdown", + "id": "81da0a5a", + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "source": [ + "### 1. Analyse der Datentypen und Erstellung eines Codebooks\n", + "Wir nutzen den NYC Flights Datensatz gekürzt um die fehlenden Werte (siehe 0_ExplorativeDatenanalyse_Einführung). Bevor wir mit Visualisierungen starten, müssen wir die Art der Variablen kennen. Schauen Sie sich die Datentabelle an und notieren Sie kurz für jede Variable:\n", + "\n", + "- Bedeutung (können Sie mit dem Namen etwas anfangen? Schauen Sie ggf. in die Dokumentation!)\n", + "- Datentyp und Skalenniveau\n", + "- Möglicher Wertebereich, Einheit etc. \n", + "- evtl. weitere Anmerkungen (z.B. Anzahl fehlender Werte)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "7536dd73", + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/david/DATENV/lib/python3.12/site-packages/nycflights13/__init__.py:2: UserWarning: pkg_resources is deprecated as an API. See https://setuptools.pypa.io/en/latest/pkg_resources.html. The pkg_resources package is slated for removal as early as 2025-11-30. Refrain from using this package or pin to Setuptools<81.\n", + " from pkg_resources import resource_filename as _rf\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
yearmonthdaydep_timesched_dep_timedep_delayarr_timesched_arr_timearr_delaycarrierflighttailnumorigindestair_timedistancehourminutetime_hour
0201311517.05152.0830.081911.0UA1545N14228EWRIAH227.014005152013-01-01T10:00:00Z
1201311533.05294.0850.083020.0UA1714N24211LGAIAH227.014165292013-01-01T10:00:00Z
2201311542.05402.0923.085033.0AA1141N619AAJFKMIA160.010895402013-01-01T10:00:00Z
3201311544.0545-1.01004.01022-18.0B6725N804JBJFKBQN183.015765452013-01-01T10:00:00Z
4201311554.0600-6.0812.0837-25.0DL461N668DNLGAATL116.0762602013-01-01T11:00:00Z
\n", + "
" + ], + "text/plain": [ + " year month day dep_time sched_dep_time dep_delay arr_time \\\n", + "0 2013 1 1 517.0 515 2.0 830.0 \n", + "1 2013 1 1 533.0 529 4.0 850.0 \n", + "2 2013 1 1 542.0 540 2.0 923.0 \n", + "3 2013 1 1 544.0 545 -1.0 1004.0 \n", + "4 2013 1 1 554.0 600 -6.0 812.0 \n", + "\n", + " sched_arr_time arr_delay carrier flight tailnum origin dest air_time \\\n", + "0 819 11.0 UA 1545 N14228 EWR IAH 227.0 \n", + "1 830 20.0 UA 1714 N24211 LGA IAH 227.0 \n", + "2 850 33.0 AA 1141 N619AA JFK MIA 160.0 \n", + "3 1022 -18.0 B6 725 N804JB JFK BQN 183.0 \n", + "4 837 -25.0 DL 461 N668DN LGA ATL 116.0 \n", + "\n", + " distance hour minute time_hour \n", + "0 1400 5 15 2013-01-01T10:00:00Z \n", + "1 1416 5 29 2013-01-01T10:00:00Z \n", + "2 1089 5 40 2013-01-01T10:00:00Z \n", + "3 1576 5 45 2013-01-01T10:00:00Z \n", + "4 762 6 0 2013-01-01T11:00:00Z " + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from nycflights13 import flights\n", + "fls = flights.dropna()\n", + "fls.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "3d4b4541a7bd605b", + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "ename": "SyntaxError", + "evalue": "unterminated string literal (detected at line 5) (3173771718.py, line 5)", + "output_type": "error", + "traceback": [ + " \u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[3]\u001b[39m\u001b[32m, line 5\u001b[39m\n\u001b[31m \u001b[39m\u001b[31mdep_time = \"Abflugszeit, \"integer -> intervallskaliert\", \"Bereich +unendlich\", \"\"\u001b[39m\n ^\n\u001b[31mSyntaxError\u001b[39m\u001b[31m:\u001b[39m unterminated string literal (detected at line 5)\n" + ] + } + ], + "source": [ + "#TODO: Erstellen eines einfachen, kurzen CodeBooks\n", + "year = \"Jahr des Ereignis\", \"integer -> intervallskaliert\", \"Bereich unendlich\", \"\"\n", + "month = \"Monat des Ereignis\", \"integer -> intervallskaliert\", \"Bereich 1-12\", \"\"\n", + "day = \"Tag des Ereignis\", \"integer -> intervallskaliert\", \"Bereich 1-31\", \"\"\n", + "dep_time = \"Abflugszeit, \"integer -> intervallskaliert\", \"Bereich +unendlich\", \"\"\n", + "sched_dep_time = \"Abflugszeit geplant , \"integer -> intervallskaliert\", \"Bereich +unendlich\", \"\"\n", + "dep_delay = \"Abflugszeit verspätung\", \"integer -> intervallskaliert\", \"Bereich unendlich\", \"\"\n", + "arr_time = \"Ankunftszeit\" \"integer -> intervallskaliert\", \"Bereich +unendlich\", \"\"\n", + "sched_arr_time = \"Ankunftszeit geplant\", \"integer -> intervallskaliert\", \"Bereich +unendlich\", \"\"\n", + "arr_delay = \"Ankunftszeit verspätung\", \"integer -> intervallskaliert\", \"Bereich unendlich\", \"\"\n", + "carrier = \"Airline\", \"string -> nominalskaliert\", \"Bereich nicht definiert\", \"\"\n", + "flight = \"Flugnummer\" \"int -> ordinalskaliert\", \"Bereich +unendlich\", \"\"\n", + "tailnum = \"Flugzeugregistrierungsnummer\", \"string -> nominalskaliert\", \"Bereich nicht definiert\", \"\"\n", + "origin = \" Start / Abflugort\", \"string -> nominalskaliert\", \"Bereich nicht definiert\", \"\"\n", + "dest = \"Ziel / Ankunftsort\", \"string -> nominalskaliert\", \"Bereich nicht definiert\", \"\"\n", + "air_time = \"Flugzeit\", \"integer -> intervallskaliert\", \"Bereich +unendlich\", \"\"\n", + "distance = \"Distanz\", \"integer -> intervallskaliert\", \"Bereich +unendlich\", \"\"\n", + "hour = \"Volle Stunden\", \"integer -> intervallskaliert\", \"Bereich +unendlich\", \"\"\n", + "minute = \"Volle Minuten\", \"integer -> intervallskaliert\", \"Bereich 0-59\", \"\"\n", + "time_hour = \"Aktuelle Uhrzeit\", \" string -> intervallskaliert\", \"Bereich nicht definiert\", \"\"\n" + ] + }, + { + "cell_type": "markdown", + "id": "30614e80a808033e", + "metadata": {}, + "source": [ + "### 2. Analyse der Kategorien\n", + "\n", + "Sie haben nun geschaut welche Variablen kategorisch vorliegen. Finden Sie heraus, wie viele verschiedene Kategorien es jeweils gibt. Starten Sie auch hier mit Visualisierungen durch geeignete Balkendiagramme (sns.countplots). Für Details können Sie dann immer noch rechnen. Einen ersten Plot sollten Sie schon mit der letzten Anleitung erstellt haben. Schauen Sie sich jetzt alle Kategorien an. Evtl. stellen Sie dabei fest, dass eine der Kategorien, die Sie als kategorial einsortiert hatten, eigentlich nicht kategorial ist, sondern z.B. numerisch vorliegt, aber nur wenige verschiedene Werte annehmen kann.\n", + "\n", + "Um auf ein Element einer Variable zuzugreifen: `'variablenname'[[index]]` (index beginnt bei 0) (z.B. `fls.year[[0]]`)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "3e441694ef7d1e26", + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#TODO: Analyse der Kategorien\n", + "cols = fls.shape[1]\n", + "dNames = list(fls)\n", + "fig, axs = plt.subplots(1, 3, figsize=(60, 20))\n", + "sns.countplot(data=fls, x=\"carrier\", ax=axs[0]).set_title(\"carrier\")\n", + "sns.countplot(data=fls, x=\"dest\", ax=axs[1]).set_title(\"dest\")\n", + "sns.countplot(data=fls, x=\"origin\", ax=axs[2]).set_title(\"origin\")\n", + "\n", + "plt.show()\n", + "#sns.countplot(data=fls, x='origin', ax=axs[0]).set_title(\"Abfuhr\")\n", + "\n", + "#plt.show() # zeigt die Grafik an, ohne die Objektinformationen auszugeben" + ] + }, + { + "cell_type": "markdown", + "id": "c4a08071adcea7c4", + "metadata": {}, + "source": [ + "### 3. Einfluss der kategorialen Variablen auf die kontinuierlichen Variablen\n", + "\n", + "Sie haben nun einen Überblick über die kategorialen Variablen. Nun wollen wir explorieren, welche Kategorien Einfluss auf welche kontinuierlichen Variablen haben. Dazu nutzt man am besten Visualisierungen. Sie können mit den vorgeschlagenen Möglichkeiten aus der letzten Anleitung starten und auch andere testen:\n", + "\n", + "- Boxplot: grafische Übersicht der wichtigsten Quantile. Praktischerweise dann auch für verschiedene Kategorien einer Variable getrennt möglich\n", + "- Violinplot: kombiniert Dichteschätzer und Boxlot (Box nimmt Form der geschätzten Dichtefunktion an)\n", + "- Kategoriale Barplots verschiedener Metriken (Mittelwert, Median, etc.)\n", + "- diese und weitere Möglichkeiten z.B. auf: https://seaborn.pydata.org/tutorial/categorical.html\n", + "\n", + "Nehmen Sie sich genug Zeit den Datensatz zu erkunden und erstellen Sie dann einen Graph zu einem Aspekt, den Sie interessant finden.\n", + "Sie dürfen natürlich auch Zusammenhänge zwischen kontinuierlichen Variablen untersuchen. Die Visualisierung in Streudiagrammen ist Ihnen aber vermutlich deutlich bekannter als der Einsatz kategorialer Variablen in Visualisierungen, achten Sie daher darauf, dass in Ihrem Graphen auch kategoriale Variablen vorkommen." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "2d87d3b5fc03b219", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# TODO: Exploration des Datensatzes durch Visualisierungen.\n", + "fig, axs = plt.subplots(1, 4, figsize=(20, 8))\n", + "\n", + "\n", + "sns.barplot(data=fls, y=\"carrier\",x= \"dep_delay\",hue=\"origin\",mulitple ax=axs[0], errorbar=None)\n", + "sns.barplot(data=fls, hue=\"carrier\",x= \"arr_delay\", ax=axs[1], errorbar=None)\n", + "sns.boxplot(data=fls, x=\"origin\", y=\"distance\", ax=axs[2])\n", + "\n", + "\n", + "sns.histplot(data=fls, x= \"origin\", y=\"carrier\", cbar=True, ax=axs[3])\n", + "\n", + "\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3f4df820-b04c-47a0-aa60-a3ad5bbcf681", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/2_Stichprobenverteilungen.ipynb b/2_Stichprobenverteilungen.ipynb new file mode 100644 index 0000000..2f7de00 --- /dev/null +++ b/2_Stichprobenverteilungen.ipynb @@ -0,0 +1,444 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "7d1106cf", + "metadata": {}, + "source": [ + "# Labor zu Stichprobenverteilungen und Standardfehlern\n", + "## \n", + "#### Literatur: \n", + "- Bruce et al. Praktische Statistik für Data Scientists, Kapitel 1 bis Seite 27, Kapitel 2 bis Standardfehler\n", + "- Sauer Moderne Datenanalyse mit R, Kapitel 17.1. 17.2\n", + "- Python-Dokumentationen\n", + "\n", + "#### Sie werden hier:\n", + "- kontinuierliche Daten visualisieren und zusammenfassen\n", + "- erkunden, was bei wiederholter Messung passiert: Stichprobenverteilung und Standardfehler\n", + "\n", + "#### Lernziele:\n", + "- kontinuierliche Daten in Histogrammen visualisieren und diese interpretieren können\n", + "- Unterschied zwischen Verteilung der Messwerte und der Verteilung eines gesuchten Parameters (Stichprobenverteilung) verstehen\n", + "- Stichprobenverteilung und Standardfehler kennen und interpretieren können\n", + "- ein anschauliches Verständnis des zentralen Grenzwertsatzes haben\n", + "\n", + "#### Output (Abfrage über moodle):\n", + "- Formulieren Sie eine Erkenntnis, die Sie bei der Bearbeitung des Labors gewonnen haben.\n", + "- Formulieren Sie eine Frage, die bei Ihnen offen geblieben ist.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d4735007", + "metadata": {}, + "outputs": [ + { + "ename": "ModuleNotFoundError", + "evalue": "No module named 'statsmodels'", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mModuleNotFoundError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[1]\u001b[39m\u001b[32m, line 15\u001b[39m\n\u001b[32m 13\u001b[39m \u001b[38;5;28;01mimport\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mnumpy\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mas\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mnp\u001b[39;00m\n\u001b[32m 14\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mscipy\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m stats\n\u001b[32m---> \u001b[39m\u001b[32m15\u001b[39m \u001b[38;5;28;01mimport\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mstatsmodels\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mapi\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mas\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01msm\u001b[39;00m\n", + "\u001b[31mModuleNotFoundError\u001b[39m: No module named 'statsmodels'" + ] + } + ], + "source": [ + "# Nötige Module importieren\n", + "\n", + "# Plotten\n", + "import matplotlib.pyplot as plt\n", + "import seaborn\n", + "\n", + "# Zum (einfacheren) Erstellen guter statistischer Plots:\n", + "import seaborn as sns\n", + "\n", + "seaborn.set_theme() # alle Plots (auch von matplotlib) im seaborn-Style\n", + "\n", + "# Numerische und statistisches Operationen\n", + "import numpy as np\n", + "from scipy import stats\n", + "import statsmodels.api as sm" + ] + }, + { + "cell_type": "markdown", + "id": "81da0a5a", + "metadata": {}, + "source": [ + "## 1. Kontinuierliche Daten in Histogrammen darstellen: Verteilung der Messwerte\n", + "\n", + "Wir nutzen wieder den NYC Flights Datensatz (ohne nans) und schauen uns die Verspätungen bei Ankunft `arr_delay` genauer an.\n", + "\n", + "Kontinuierliche Daten visualisiert man mit \"statistischen\" Plots: Histogramm, (empirische) Verteilungsfunktion, etc. Auch ein Boxplot zeigt immerhin 5 Quantile und damit nicht nur Lage und Streuung, sondern auch etwas von der \"Form\" der Verteilung der Daten.\n", + "\n", + "Beim Histogramm ist wichtig:\n", + "- Daten werden in Klassen (Bins) zusammengefasst ⇒ geeignete Anzahl Klassen wählen\n", + "- Histogramm ist eine flächentreue Darstellung ⇒ geeignete Normierung wählen (y-Achse)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "332a70c3", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/david/DATENV/lib/python3.12/site-packages/nycflights13/__init__.py:2: UserWarning: pkg_resources is deprecated as an API. See https://setuptools.pypa.io/en/latest/pkg_resources.html. The pkg_resources package is slated for removal as early as 2025-11-30. Refrain from using this package or pin to Setuptools<81.\n", + " from pkg_resources import resource_filename as _rf\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from nycflights13 import flights\n", + "\n", + "fls = flights.dropna()\n", + "\n", + "sns.histplot(fls.arr_delay);" + ] + }, + { + "cell_type": "markdown", + "id": "dccca170", + "metadata": {}, + "source": [ + "#### a) Klassen beim Histogramm\n", + "\n", + "Testen Sie verschiedene Anzahl Klassen. Typische Faustregeln:\n", + "- $2 \\sqrt{n}$\n", + "- $< \\sqrt{n}$ für große Stichproben\n", + "- $10\\log_{10} n$\n", + "\n", + "Bitte beachten: wichtiger ist der optische Eindruck!" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "d15c811e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "anzahl = len(fls.arr_delay)\n", + "\n", + "fig, axs = plt.subplots(1, 3, figsize=(15, 5))\n", + "\n", + "n_bins1 = int(np.round(2 * np.sqrt(anzahl), 0)) # np.round(zahl, 0) rundet auf 0 Nachkommastellen, da #Bins ganzzahlig sein muss\n", + "n_bins2 = int(np.round(np.sqrt(anzahl), 0))\n", + "n_bins3 = int(np.round(10*np.log10(anzahl), 0))\n", + "\n", + "\n", + "sns.histplot(fls.arr_delay, bins=n_bins1, ax=axs[0])\n", + "sns.histplot(fls.arr_delay, bins=n_bins2, ax=axs[1])\n", + "sns.histplot(fls.arr_delay, bins=n_bins3, ax=axs[2])\n", + "#plt.xlabel('Arrival delay / min') #Um automatisch eine korrekte Beschriftung incl. Einheit zu erhalten, könnte man auch die Variable entsprechend benennen. Das ist Geschmackssache.\n", + "#plt.ylabel('Number of flights') #Vorsicht bei der Beschriftung der Achsen. Je nach Normierung der y-Achse muss eine manuelle Beschriftung angepasst werden!\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "5d015c91", + "metadata": {}, + "source": [ + "Was passiert beim Ändern der Klassenanzahl mit der y-Achse?\n", + "\n", + "#### b) Normierung beim Histogramm\n", + "\n", + "In matplotlib lässt sich die Normierung auf `density=True` und `density=False` stellen. Welchen Einfluss hat das?\n", + "In seaborn sind über `stat = ...` die üblichen weiteren Möglichkeiten gegeben:\n", + "https://seaborn.pydata.org/generated/seaborn.histplot.html:\n", + "\n", + "```\n", + " Aggregate statistic to compute in each bin.\n", + " \n", + " count: show the number of observations in each bin\n", + " \n", + " frequency: show the number of observations divided by the bin width\n", + " \n", + " probability or proportion: normalize such that bar heights sum to 1\n", + " \n", + " percent: normalize such that bar heights sum to 100\n", + " \n", + " density: normalize such that the total area of the histogram equals 1\n", + "```\n", + "Schauen Sie sich die verschiedenen Varianten an und überlegen Sie, was sie bedeuten. Häufig wird ohne genaueres Hinschauen \"count\" verwendet. Dann ist aber die Fläche nicht auf 1 normiert und der Vergleich mit der Dichtefunktion funktioniert nicht richtig. Daher: Wenn das Histogramm mit einer Dichtefunktion verglichen wird, sollte `stat=density` verwendet werden!\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "a20d379d7fce80e6", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(1, 2, figsize=(12, 4))\n", + "\n", + "x = np.linspace(-100, 200, 1000)\n", + "\n", + "sns.histplot(data=fls, x='arr_delay', kde=True, stat='count', ax=axs[0])\n", + "sns.histplot(data=fls, x='arr_delay', kde=True, stat='density', ax=axs[1])\n", + "axs[1].plot(x, stats.norm.pdf(x, loc=fls.arr_delay.mean(), scale=fls.arr_delay.std()),\n", + " color='red') # Normalverteilung mit Mittelwert und Standardabweichung der Stichprobe, Dichte ist normiert auf 1\n", + "\n", + "axs[0].set_xlim(-100, 200)\n", + "axs[1].set_xlim(-100, 200)\n", + "axs[0].set_title('Histogram (count)')\n", + "axs[1].set_title('Histogram with PDF')\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "032695f4", + "metadata": {}, + "source": [ + "## 2. Stichprobenverteilung: Verteilung der Parameter\n", + "\n", + "Bisher haben wir uns angeschaut, wie die Variable `arr_delay` verteilt ist. Normalerweise haben wir aber nicht alle Daten (die sog. Grundgesamtheit oder Population) vorliegen, sondern nur eine Stichprobe. Trotzdem wollen wir eine Aussage über alle Daten treffen, d.h. wir würden gerne anhand unserer Stichprobe einschätzen wie die Grundgesamtheit aussieht. Diesem Vorgehen nähern wir uns hier von Simulationsseite. Wir stellen uns vor, die Grundgesamtheit sind alle NYC Flüge aus 2013 aber wir hätten nur eine Stichprobe. Was könnten wir dann über die Flüge sagen?\n", + "\n", + "#### a) Stichprobenverteilung des Mittelwerts\n", + "Zunächst versuchen wir aus einer Stichprobe des Datensatzes eine Aussage über die mittlere Verspätung im Jahr 2013 zu treffen. Dazu werden wir\n", + "- eine Stichprobe ziehen und den Mittelwert berechnen.\n", + "- nochmal eine Stichprobe ziehen $\\rightarrow$ Was ist anders?\n", + "- ganz häufig Stichproben ziehen und eine Stichprobenverteilung für den Mittelwert erstellen\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "affa40e4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "sample1 with mean 24.4: [-1.0, 11.0, -30.0, 73.0, 69.0]\n", + "sample2 with mean 32.0: [-8.0, -22.0, 143.0, 47.0, 0.0]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Wir ziehen zweimal eine Stichprobe, berechnen ihren Mittelwert und visualisieren die Stichprobe\n", + "sample1 = fls.sample(5).arr_delay\n", + "sample2 = fls.sample(5).arr_delay\n", + "\n", + "print(f\"sample1 with mean {sample1.mean()}: {sample1.tolist()}\")\n", + "print(f\"sample2 with mean {sample2.mean()}: {sample2.tolist()}\")\n", + "\n", + "fig, axs = plt.subplots(1, 2, sharex=True, sharey=True)\n", + "sns.histplot(sample1, ax=axs[0])\n", + "sns.histplot(sample2, ax=axs[1])\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "1feb7f85", + "metadata": {}, + "outputs": [], + "source": [ + "# Wir wiederholen das nun für verschiedene Stichprobengrößen je 1000x\n", + "n_replics = 1000\n", + "sample_sizes = [5, 30, 100]\n", + "np.random.seed(123)\n", + "\n", + "means_by_sample_size = []\n", + "\n", + "\"\"\"\n", + "Ich verwende hier list comprehensions, sie sind kompakter und schneller als Schleifen. Sie können stattdessen auch eine Schleife verwenden.\n", + "https://www.w3schools.com/python/python_lists_comprehension.asp\n", + "\n", + "Beispiel:\n", + ">>> numbers = [1, 2, 3, 4]\n", + ">>> squares = [n**2 for n in numbers]\n", + ">>> print(squares)\n", + "[1, 4, 9, 16]\n", + "\n", + "Für jedes n aus sample_sizes tue 1000x:\n", + " - ziehe n Stichproben und berechne den Mittelwert\n", + " - speichere die Mittelwerte in einer Liste\n", + " \n", + "Als Resultat erhalten wir eine Liste, die 3 Listen (für die 3 Stichprobengrößen) mit jeweils 1000 Mittelwerten enthält.\n", + "\"\"\"\n", + "for sample_size in sample_sizes:\n", + " means_by_sample_size.append([flights.sample(sample_size).arr_delay.mean() for _ in range(n_replics)])\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "77874aae", + "metadata": {}, + "outputs": [], + "source": [ + "fig, axs = plt.subplots(1, 3, figsize=(16, 5), sharex=True, sharey=True)\n", + "\n", + "fig.suptitle(\"Stichprobenverteilung des Mittelwerts\")\n", + "\n", + "for i, means in enumerate(means_by_sample_size):\n", + " sns.histplot(means, bins=64, kde=True, stat=\"density\", ax=axs[i])\n", + " axs[i].set_xlabel(r'$\\bar{x}$')\n", + " axs[i].set_title(f\"N={sample_sizes[i]}\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "487f6a11", + "metadata": {}, + "source": [ + "Diese Verteilungen des errechneten Parameters nennt man Stichprobenverteilung. In diesem Fall haben wir Stichprobenverteilungen für den Mittelwert erstellt.\n", + "\n", + "Was fällt Ihnen beim Vergleich der sog. Stichprobenverteilungen auf?\n", + "\n", + "Stellen Sie sich folgende Fragen:\n", + "- wie relevant ist die Streuung in der Stichprobe für die Stichprobenverteilung?\n", + "- wie relevant ist die Stichprobengröße für die Stichprobenverteilung?\n", + "- wie relevant ist die Verteilung der Daten für die Stichprobenverteilung? (das schauen wir uns unten genauer an)\n", + "- was ist der Unterschied zwischen der Verteilung der Daten und der Stichprobenverteilung?\n", + "- gibt es für Sie eine Erkenntnis für die Praxis, z.B. bei der Analyse von Messdaten? \n", + " (Beispiel: Sie messen in einem Labor elektrische Kennzahlen und interessieren sich für den Mittelwert. Was geben Sie als Messergebnis an?) (Wir haben früher immer Mittelwert und Standardabweichung angegeben. Ist das sinnvoll? Überlegen Sie bessere Alternativen!)\n", + "\n", + "\n", + "#### b) Berechnung des Standardfehlers\n", + "Der Standardfehler (standard error (of the mean)) ist eine wichtige Kenngröße der Stichprobenverteilung und spielt eine zentrale Rolle bei Schätzungen. Lesen Sie im Buch nach welche Definitionen/Interpretationen es gibt.\n", + "\n", + "Berechnen Sie den Standardfehler als Streuung (Standardabweichung) der Stichprobenverteilung. Wie verändert sich der Standardfehler mit der Stichprobengröße? Vergleichen Sie den Wert mit der theoretischen Formel für den Standardfehler des Mittelwerts." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "91d64eb0e3b775a9", + "metadata": {}, + "outputs": [], + "source": [ + "#TODO: Berechnung des Standardfehlers für die unterschiedlichen Stichprobengrößen aus der Stichprobenverteilung und aus theoretischer Formel" + ] + }, + { + "cell_type": "markdown", + "id": "a3e48c793591a5cc", + "metadata": {}, + "source": [ + "#### c) Stichprobenverteilung für weitere statistische Größen\n", + "\n", + "Wie sehen Stichprobenverteilungen für andere statistische Größen aus? \n", + "1. Wiederholen Sie die Analyse von oben für Median und Standardabweichung. Was fällt Ihnen auf?\n", + "2. Untersuchen Sie den Einfluss der Verteilung der Daten auf die Stichprobenverteilung. Dazu können Sie sich Daten aus anderen Verteilungen generieren (z.B. exponentialverteilt, gleichverteilt etc.) und dann die Stichprobenverteilungen anschauen. Alternativ können Sie folgende Visualisierung nutzen: https://onlinestatbook.com/stat_sim/sampling_dist/index.html\n", + "3. Sehen Sie einen Zusammenhang zum zentralen Grenzwertsatz?\n", + "\n", + "Hier gibt es viele Erkenntnisse zu gewinnen, spielen Sie mit den Parametern und lassen Sie sich überraschen!\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "56e5975f6fdafbd4", + "metadata": {}, + "outputs": [], + "source": [ + "# TODO: Stichprobenverteilung für Median und Standardabweichung\n", + "# TODO: Einfluss der Verteilung der Daten auf die Stichprobenverteilung untersuchen" + ] + }, + { + "cell_type": "markdown", + "id": "2e1a9e01754ace26", + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "source": [ + "## 3. Output \n", + "Als Output aus diesem Labor sammeln Sie Ihre Erkenntnisse und offenen Fragen. Tragen Sie Ihre wichtigste Erkenntnis und Ihre \"größte\" Frage bis Dienstagabend auf moodle ein. Diese Antworten nutze ich zur Vorbereitung der nächsten Vorlesung." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "392f73677803f15d", + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/README.md b/README.md new file mode 100644 index 0000000..e69de29 diff --git a/Untitled.ipynb b/Untitled.ipynb new file mode 100644 index 0000000..b5c7b76 --- /dev/null +++ b/Untitled.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "1b48a7b8-fc42-4c7b-8507-b0c7b6ed169b", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/main.py b/main.py new file mode 100644 index 0000000..d1fa9ca --- /dev/null +++ b/main.py @@ -0,0 +1,6 @@ +def main(): + print("Hello from dat!") + + +if __name__ == "__main__": + main() diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..632a67b --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,15 @@ +[project] +name = "dat" +version = "0.1.0" +description = "Add your description here" +readme = "README.md" +requires-python = ">=3.12" +dependencies = [ + "pandas>=2.3.3", + "seaborn>=0.13.2", +] + +[dependency-groups] +dev = [ + "ipykernel>=7.0.1", +] diff --git a/uv.lock b/uv.lock new file mode 100644 index 0000000..280e8f5 --- /dev/null +++ b/uv.lock @@ -0,0 +1,957 @@ +version = 1 +revision = 3 +requires-python = ">=3.12" + +[[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.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/4a/e7/82da0a03e7ba5141f05cce0d302e6eed121ae055e0456ca228bf693984bc/asttokens-3.0.0.tar.gz", hash = "sha256:0dcd8baa8d62b0c1d118b399b2ddba3c4aff271d0d7a9e0d4c1681c79035bbc7", size = 61978, upload-time = "2024-11-30T04:30:14.439Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/25/8a/c46dcc25341b5bce5472c718902eb3d38600a903b14fa6aeecef3f21a46f/asttokens-3.0.0-py3-none-any.whl", hash = "sha256:e3078351a059199dd5138cb1c706e6430c05eff2ff136af5eb4790f9d28932e2", size = 26918, upload-time = "2024-11-30T04:30:10.946Z" }, +] + +[[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 = "colorama" +version = "0.4.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" } +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" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, +] +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/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" }, + { url = "https://files.pythonhosted.org/packages/63/12/897aeebfb475b7748ea67b61e045accdfcf0d971f8a588b67108ed7f5512/contourpy-1.3.3-cp312-cp312-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b2e8faa0ed68cb29af51edd8e24798bb661eac3bd9f65420c1887b6ca89987c8", size = 379536, upload-time = "2025-07-26T12:01:25.91Z" }, + { url = "https://files.pythonhosted.org/packages/43/8a/a8c584b82deb248930ce069e71576fc09bd7174bbd35183b7943fb1064fd/contourpy-1.3.3-cp312-cp312-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:626d60935cf668e70a5ce6ff184fd713e9683fb458898e4249b63be9e28286ea", size = 384397, upload-time = "2025-07-26T12:01:27.152Z" }, + { url = "https://files.pythonhosted.org/packages/cc/8f/ec6289987824b29529d0dfda0d74a07cec60e54b9c92f3c9da4c0ac732de/contourpy-1.3.3-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4d00e655fcef08aba35ec9610536bfe90267d7ab5ba944f7032549c55a146da1", size = 362601, upload-time = "2025-07-26T12:01:28.808Z" }, + { url = "https://files.pythonhosted.org/packages/05/0a/a3fe3be3ee2dceb3e615ebb4df97ae6f3828aa915d3e10549ce016302bd1/contourpy-1.3.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:451e71b5a7d597379ef572de31eeb909a87246974d960049a9848c3bc6c41bf7", size = 1331288, upload-time = "2025-07-26T12:01:31.198Z" }, + { url = "https://files.pythonhosted.org/packages/33/1d/acad9bd4e97f13f3e2b18a3977fe1b4a37ecf3d38d815333980c6c72e963/contourpy-1.3.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:459c1f020cd59fcfe6650180678a9993932d80d44ccde1fa1868977438f0b411", size = 1403386, upload-time = "2025-07-26T12:01:33.947Z" }, + { 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/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 = "cycler" +version = "0.12.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a9/95/a3dbbb5028f35eafb79008e7522a75244477d2838f38cbb722248dabc2a8/cycler-0.12.1.tar.gz", hash = "sha256:88bb128f02ba341da8ef447245a9e138fae777f6a23943da4540077d3601eb1c", size = 7615, upload-time = "2023-10-07T05:32:18.335Z" } +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 = "dat" +version = "0.1.0" +source = { virtual = "." } +dependencies = [ + { name = "pandas" }, + { name = "seaborn" }, +] + +[package.dev-dependencies] +dev = [ + { name = "ipykernel" }, +] + +[package.metadata] +requires-dist = [ + { name = "pandas", specifier = ">=2.3.3" }, + { name = "seaborn", specifier = ">=0.13.2" }, +] + +[package.metadata.requires-dev] +dev = [{ name = "ipykernel", specifier = ">=7.0.1" }] + +[[package]] +name = "debugpy" +version = "1.8.17" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/15/ad/71e708ff4ca377c4230530d6a7aa7992592648c122a2cd2b321cf8b35a76/debugpy-1.8.17.tar.gz", hash = "sha256:fd723b47a8c08892b1a16b2c6239a8b96637c62a59b94bb5dab4bac592a58a8e", size = 1644129, upload-time = "2025-09-17T16:33:20.633Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/08/2b/9d8e65beb2751876c82e1aceb32f328c43ec872711fa80257c7674f45650/debugpy-1.8.17-cp312-cp312-macosx_15_0_universal2.whl", hash = "sha256:f14467edef672195c6f6b8e27ce5005313cb5d03c9239059bc7182b60c176e2d", size = 2549522, upload-time = "2025-09-17T16:33:38.466Z" }, + { url = "https://files.pythonhosted.org/packages/b4/78/eb0d77f02971c05fca0eb7465b18058ba84bd957062f5eec82f941ac792a/debugpy-1.8.17-cp312-cp312-manylinux_2_34_x86_64.whl", hash = "sha256:24693179ef9dfa20dca8605905a42b392be56d410c333af82f1c5dff807a64cc", size = 4309417, upload-time = "2025-09-17T16:33:41.299Z" }, + { url = "https://files.pythonhosted.org/packages/37/42/c40f1d8cc1fed1e75ea54298a382395b8b937d923fcf41ab0797a554f555/debugpy-1.8.17-cp312-cp312-win32.whl", hash = "sha256:6a4e9dacf2cbb60d2514ff7b04b4534b0139facbf2abdffe0639ddb6088e59cf", size = 5277130, upload-time = "2025-09-17T16:33:43.554Z" }, + { url = "https://files.pythonhosted.org/packages/72/22/84263b205baad32b81b36eac076de0cdbe09fe2d0637f5b32243dc7c925b/debugpy-1.8.17-cp312-cp312-win_amd64.whl", hash = "sha256:e8f8f61c518952fb15f74a302e068b48d9c4691768ade433e4adeea961993464", size = 5319053, upload-time = "2025-09-17T16:33:53.033Z" }, + { url = "https://files.pythonhosted.org/packages/50/76/597e5cb97d026274ba297af8d89138dfd9e695767ba0e0895edb20963f40/debugpy-1.8.17-cp313-cp313-macosx_15_0_universal2.whl", hash = "sha256:857c1dd5d70042502aef1c6d1c2801211f3ea7e56f75e9c335f434afb403e464", size = 2538386, upload-time = "2025-09-17T16:33:54.594Z" }, + { url = "https://files.pythonhosted.org/packages/5f/60/ce5c34fcdfec493701f9d1532dba95b21b2f6394147234dce21160bd923f/debugpy-1.8.17-cp313-cp313-manylinux_2_34_x86_64.whl", hash = "sha256:3bea3b0b12f3946e098cce9b43c3c46e317b567f79570c3f43f0b96d00788088", size = 4292100, upload-time = "2025-09-17T16:33:56.353Z" }, + { url = "https://files.pythonhosted.org/packages/e8/95/7873cf2146577ef71d2a20bf553f12df865922a6f87b9e8ee1df04f01785/debugpy-1.8.17-cp313-cp313-win32.whl", hash = "sha256:e34ee844c2f17b18556b5bbe59e1e2ff4e86a00282d2a46edab73fd7f18f4a83", size = 5277002, upload-time = "2025-09-17T16:33:58.231Z" }, + { url = "https://files.pythonhosted.org/packages/46/11/18c79a1cee5ff539a94ec4aa290c1c069a5580fd5cfd2fb2e282f8e905da/debugpy-1.8.17-cp313-cp313-win_amd64.whl", hash = "sha256:6c5cd6f009ad4fca8e33e5238210dc1e5f42db07d4b6ab21ac7ffa904a196420", size = 5319047, upload-time = "2025-09-17T16:34:00.586Z" }, + { url = "https://files.pythonhosted.org/packages/de/45/115d55b2a9da6de812696064ceb505c31e952c5d89c4ed1d9bb983deec34/debugpy-1.8.17-cp314-cp314-macosx_15_0_universal2.whl", hash = "sha256:045290c010bcd2d82bc97aa2daf6837443cd52f6328592698809b4549babcee1", size = 2536899, upload-time = "2025-09-17T16:34:02.657Z" }, + { url = "https://files.pythonhosted.org/packages/5a/73/2aa00c7f1f06e997ef57dc9b23d61a92120bec1437a012afb6d176585197/debugpy-1.8.17-cp314-cp314-manylinux_2_34_x86_64.whl", hash = "sha256:b69b6bd9dba6a03632534cdf67c760625760a215ae289f7489a452af1031fe1f", size = 4268254, upload-time = "2025-09-17T16:34:04.486Z" }, + { url = "https://files.pythonhosted.org/packages/86/b5/ed3e65c63c68a6634e3ba04bd10255c8e46ec16ebed7d1c79e4816d8a760/debugpy-1.8.17-cp314-cp314-win32.whl", hash = "sha256:5c59b74aa5630f3a5194467100c3b3d1c77898f9ab27e3f7dc5d40fc2f122670", size = 5277203, upload-time = "2025-09-17T16:34:06.65Z" }, + { url = "https://files.pythonhosted.org/packages/b0/26/394276b71c7538445f29e792f589ab7379ae70fd26ff5577dfde71158e96/debugpy-1.8.17-cp314-cp314-win_amd64.whl", hash = "sha256:893cba7bb0f55161de4365584b025f7064e1f88913551bcd23be3260b231429c", size = 5318493, upload-time = "2025-09-17T16:34:08.483Z" }, + { url = "https://files.pythonhosted.org/packages/b0/d0/89247ec250369fc76db477720a26b2fce7ba079ff1380e4ab4529d2fe233/debugpy-1.8.17-py2.py3-none-any.whl", hash = "sha256:60c7dca6571efe660ccb7a9508d73ca14b8796c4ed484c2002abba714226cfef", size = 5283210, upload-time = "2025-09-17T16:34:25.835Z" }, +] + +[[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 = "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 = "fonttools" +version = "4.60.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/4b/42/97a13e47a1e51a5a7142475bbcf5107fe3a68fc34aef331c897d5fb98ad0/fonttools-4.60.1.tar.gz", hash = "sha256:ef00af0439ebfee806b25f24c8f92109157ff3fac5731dc7867957812e87b8d9", size = 3559823, upload-time = "2025-09-29T21:13:27.129Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e3/f7/a10b101b7a6f8836a5adb47f2791f2075d044a6ca123f35985c42edc82d8/fonttools-4.60.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:7b0c6d57ab00dae9529f3faf187f2254ea0aa1e04215cf2f1a8ec277c96661bc", size = 2832953, upload-time = "2025-09-29T21:11:39.616Z" }, + { url = "https://files.pythonhosted.org/packages/ed/fe/7bd094b59c926acf2304d2151354ddbeb74b94812f3dc943c231db09cb41/fonttools-4.60.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:839565cbf14645952d933853e8ade66a463684ed6ed6c9345d0faf1f0e868877", size = 2352706, upload-time = "2025-09-29T21:11:41.826Z" }, + { url = "https://files.pythonhosted.org/packages/c0/ca/4bb48a26ed95a1e7eba175535fe5805887682140ee0a0d10a88e1de84208/fonttools-4.60.1-cp312-cp312-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:8177ec9676ea6e1793c8a084a90b65a9f778771998eb919d05db6d4b1c0b114c", size = 4923716, upload-time = "2025-09-29T21:11:43.893Z" }, + { url = "https://files.pythonhosted.org/packages/b8/9f/2cb82999f686c1d1ddf06f6ae1a9117a880adbec113611cc9d22b2fdd465/fonttools-4.60.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:996a4d1834524adbb423385d5a629b868ef9d774670856c63c9a0408a3063401", size = 4968175, upload-time = "2025-09-29T21:11:46.439Z" }, + { url = "https://files.pythonhosted.org/packages/18/79/be569699e37d166b78e6218f2cde8c550204f2505038cdd83b42edc469b9/fonttools-4.60.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a46b2f450bc79e06ef3b6394f0c68660529ed51692606ad7f953fc2e448bc903", size = 4911031, upload-time = "2025-09-29T21:11:48.977Z" }, + { url = "https://files.pythonhosted.org/packages/cc/9f/89411cc116effaec5260ad519162f64f9c150e5522a27cbb05eb62d0c05b/fonttools-4.60.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:6ec722ee589e89a89f5b7574f5c45604030aa6ae24cb2c751e2707193b466fed", size = 5062966, upload-time = "2025-09-29T21:11:54.344Z" }, + { url = "https://files.pythonhosted.org/packages/62/a1/f888221934b5731d46cb9991c7a71f30cb1f97c0ef5fcf37f8da8fce6c8e/fonttools-4.60.1-cp312-cp312-win32.whl", hash = "sha256:b2cf105cee600d2de04ca3cfa1f74f1127f8455b71dbad02b9da6ec266e116d6", size = 2218750, upload-time = "2025-09-29T21:11:56.601Z" }, + { url = "https://files.pythonhosted.org/packages/88/8f/a55b5550cd33cd1028601df41acd057d4be20efa5c958f417b0c0613924d/fonttools-4.60.1-cp312-cp312-win_amd64.whl", hash = "sha256:992775c9fbe2cf794786fa0ffca7f09f564ba3499b8fe9f2f80bd7197db60383", size = 2267026, upload-time = "2025-09-29T21:11:58.852Z" }, + { url = "https://files.pythonhosted.org/packages/7c/5b/cdd2c612277b7ac7ec8c0c9bc41812c43dc7b2d5f2b0897e15fdf5a1f915/fonttools-4.60.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:6f68576bb4bbf6060c7ab047b1574a1ebe5c50a17de62830079967b211059ebb", size = 2825777, upload-time = "2025-09-29T21:12:01.22Z" }, + { url = "https://files.pythonhosted.org/packages/d6/8a/de9cc0540f542963ba5e8f3a1f6ad48fa211badc3177783b9d5cadf79b5d/fonttools-4.60.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:eedacb5c5d22b7097482fa834bda0dafa3d914a4e829ec83cdea2a01f8c813c4", size = 2348080, upload-time = "2025-09-29T21:12:03.785Z" }, + { url = "https://files.pythonhosted.org/packages/2d/8b/371ab3cec97ee3fe1126b3406b7abd60c8fec8975fd79a3c75cdea0c3d83/fonttools-4.60.1-cp313-cp313-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b33a7884fabd72bdf5f910d0cf46be50dce86a0362a65cfc746a4168c67eb96c", size = 4903082, upload-time = "2025-09-29T21:12:06.382Z" }, + { url = "https://files.pythonhosted.org/packages/04/05/06b1455e4bc653fcb2117ac3ef5fa3a8a14919b93c60742d04440605d058/fonttools-4.60.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2409d5fb7b55fd70f715e6d34e7a6e4f7511b8ad29a49d6df225ee76da76dd77", size = 4960125, upload-time = "2025-09-29T21:12:09.314Z" }, + { url = "https://files.pythonhosted.org/packages/8e/37/f3b840fcb2666f6cb97038793606bdd83488dca2d0b0fc542ccc20afa668/fonttools-4.60.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:c8651e0d4b3bdeda6602b85fdc2abbefc1b41e573ecb37b6779c4ca50753a199", size = 4901454, upload-time = "2025-09-29T21:12:11.931Z" }, + { url = "https://files.pythonhosted.org/packages/fd/9e/eb76f77e82f8d4a46420aadff12cec6237751b0fb9ef1de373186dcffb5f/fonttools-4.60.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:145daa14bf24824b677b9357c5e44fd8895c2a8f53596e1b9ea3496081dc692c", size = 5044495, upload-time = "2025-09-29T21:12:15.241Z" }, + { url = "https://files.pythonhosted.org/packages/f8/b3/cede8f8235d42ff7ae891bae8d619d02c8ac9fd0cfc450c5927a6200c70d/fonttools-4.60.1-cp313-cp313-win32.whl", hash = "sha256:2299df884c11162617a66b7c316957d74a18e3758c0274762d2cc87df7bc0272", size = 2217028, upload-time = "2025-09-29T21:12:17.96Z" }, + { url = "https://files.pythonhosted.org/packages/75/4d/b022c1577807ce8b31ffe055306ec13a866f2337ecee96e75b24b9b753ea/fonttools-4.60.1-cp313-cp313-win_amd64.whl", hash = "sha256:a3db56f153bd4c5c2b619ab02c5db5192e222150ce5a1bc10f16164714bc39ac", size = 2266200, upload-time = "2025-09-29T21:12:20.14Z" }, + { url = "https://files.pythonhosted.org/packages/9a/83/752ca11c1aa9a899b793a130f2e466b79ea0cf7279c8d79c178fc954a07b/fonttools-4.60.1-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:a884aef09d45ba1206712c7dbda5829562d3fea7726935d3289d343232ecb0d3", size = 2822830, upload-time = "2025-09-29T21:12:24.406Z" }, + { url = "https://files.pythonhosted.org/packages/57/17/bbeab391100331950a96ce55cfbbff27d781c1b85ebafb4167eae50d9fe3/fonttools-4.60.1-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8a44788d9d91df72d1a5eac49b31aeb887a5f4aab761b4cffc4196c74907ea85", size = 2345524, upload-time = "2025-09-29T21:12:26.819Z" }, + { url = "https://files.pythonhosted.org/packages/3d/2e/d4831caa96d85a84dd0da1d9f90d81cec081f551e0ea216df684092c6c97/fonttools-4.60.1-cp314-cp314-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:e852d9dda9f93ad3651ae1e3bb770eac544ec93c3807888798eccddf84596537", size = 4843490, upload-time = "2025-09-29T21:12:29.123Z" }, + { url = "https://files.pythonhosted.org/packages/49/13/5e2ea7c7a101b6fc3941be65307ef8df92cbbfa6ec4804032baf1893b434/fonttools-4.60.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:154cb6ee417e417bf5f7c42fe25858c9140c26f647c7347c06f0cc2d47eff003", size = 4944184, upload-time = "2025-09-29T21:12:31.414Z" }, + { url = "https://files.pythonhosted.org/packages/0c/2b/cf9603551c525b73fc47c52ee0b82a891579a93d9651ed694e4e2cd08bb8/fonttools-4.60.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:5664fd1a9ea7f244487ac8f10340c4e37664675e8667d6fee420766e0fb3cf08", size = 4890218, upload-time = "2025-09-29T21:12:33.936Z" }, + { url = "https://files.pythonhosted.org/packages/fd/2f/933d2352422e25f2376aae74f79eaa882a50fb3bfef3c0d4f50501267101/fonttools-4.60.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:583b7f8e3c49486e4d489ad1deacfb8d5be54a8ef34d6df824f6a171f8511d99", size = 4999324, upload-time = "2025-09-29T21:12:36.637Z" }, + { url = "https://files.pythonhosted.org/packages/38/99/234594c0391221f66216bc2c886923513b3399a148defaccf81dc3be6560/fonttools-4.60.1-cp314-cp314-win32.whl", hash = "sha256:66929e2ea2810c6533a5184f938502cfdaea4bc3efb7130d8cc02e1c1b4108d6", size = 2220861, upload-time = "2025-09-29T21:12:39.108Z" }, + { url = "https://files.pythonhosted.org/packages/3e/1d/edb5b23726dde50fc4068e1493e4fc7658eeefcaf75d4c5ffce067d07ae5/fonttools-4.60.1-cp314-cp314-win_amd64.whl", hash = "sha256:f3d5be054c461d6a2268831f04091dc82753176f6ea06dc6047a5e168265a987", size = 2270934, upload-time = "2025-09-29T21:12:41.339Z" }, + { url = "https://files.pythonhosted.org/packages/fb/da/1392aaa2170adc7071fe7f9cfd181a5684a7afcde605aebddf1fb4d76df5/fonttools-4.60.1-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:b6379e7546ba4ae4b18f8ae2b9bc5960936007a1c0e30b342f662577e8bc3299", size = 2894340, upload-time = "2025-09-29T21:12:43.774Z" }, + { url = "https://files.pythonhosted.org/packages/bf/a7/3b9f16e010d536ce567058b931a20b590d8f3177b2eda09edd92e392375d/fonttools-4.60.1-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:9d0ced62b59e0430b3690dbc5373df1c2aa7585e9a8ce38eff87f0fd993c5b01", size = 2375073, upload-time = "2025-09-29T21:12:46.437Z" }, + { url = "https://files.pythonhosted.org/packages/9b/b5/e9bcf51980f98e59bb5bb7c382a63c6f6cac0eec5f67de6d8f2322382065/fonttools-4.60.1-cp314-cp314t-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:875cb7764708b3132637f6c5fb385b16eeba0f7ac9fa45a69d35e09b47045801", size = 4849758, upload-time = "2025-09-29T21:12:48.694Z" }, + { url = "https://files.pythonhosted.org/packages/e3/dc/1d2cf7d1cba82264b2f8385db3f5960e3d8ce756b4dc65b700d2c496f7e9/fonttools-4.60.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a184b2ea57b13680ab6d5fbde99ccef152c95c06746cb7718c583abd8f945ccc", size = 5085598, upload-time = "2025-09-29T21:12:51.081Z" }, + { url = "https://files.pythonhosted.org/packages/5d/4d/279e28ba87fb20e0c69baf72b60bbf1c4d873af1476806a7b5f2b7fac1ff/fonttools-4.60.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:026290e4ec76583881763fac284aca67365e0be9f13a7fb137257096114cb3bc", size = 4957603, upload-time = "2025-09-29T21:12:53.423Z" }, + { url = "https://files.pythonhosted.org/packages/78/d4/ff19976305e0c05aa3340c805475abb00224c954d3c65e82c0a69633d55d/fonttools-4.60.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:f0e8817c7d1a0c2eedebf57ef9a9896f3ea23324769a9a2061a80fe8852705ed", size = 4974184, upload-time = "2025-09-29T21:12:55.962Z" }, + { url = "https://files.pythonhosted.org/packages/63/22/8553ff6166f5cd21cfaa115aaacaa0dc73b91c079a8cfd54a482cbc0f4f5/fonttools-4.60.1-cp314-cp314t-win32.whl", hash = "sha256:1410155d0e764a4615774e5c2c6fc516259fe3eca5882f034eb9bfdbee056259", size = 2282241, upload-time = "2025-09-29T21:12:58.179Z" }, + { url = "https://files.pythonhosted.org/packages/8a/cb/fa7b4d148e11d5a72761a22e595344133e83a9507a4c231df972e657579b/fonttools-4.60.1-cp314-cp314t-win_amd64.whl", hash = "sha256:022beaea4b73a70295b688f817ddc24ed3e3418b5036ffcd5658141184ef0d0c", size = 2345760, upload-time = "2025-09-29T21:13:00.375Z" }, + { url = "https://files.pythonhosted.org/packages/c7/93/0dd45cd283c32dea1545151d8c3637b4b8c53cdb3a625aeb2885b184d74d/fonttools-4.60.1-py3-none-any.whl", hash = "sha256:906306ac7afe2156fcf0042173d6ebbb05416af70f6b370967b47f8f00103bbb", size = 1143175, upload-time = "2025-09-29T21:13:24.134Z" }, +] + +[[package]] +name = "ipykernel" +version = "7.0.1" +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/a8/4c/9f0024c8457286c6bfd5405a15d650ec5ea36f420ef9bbc58b301f66cfc5/ipykernel-7.0.1.tar.gz", hash = "sha256:2d3fd7cdef22071c2abbad78f142b743228c5d59cd470d034871ae0ac359533c", size = 171460, upload-time = "2025-10-14T16:17:07.325Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b8/f7/761037905ffdec673533bfa43af8d4c31c859c778dfc3bbb71899875ec18/ipykernel-7.0.1-py3-none-any.whl", hash = "sha256:87182a8305e28954b6721087dec45b171712610111d494c17bb607befa1c4000", size = 118157, upload-time = "2025-10-14T16:17:05.606Z" }, +] + +[[package]] +name = "ipython" +version = "9.6.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/2a/34/29b18c62e39ee2f7a6a3bba7efd952729d8aadd45ca17efc34453b717665/ipython-9.6.0.tar.gz", hash = "sha256:5603d6d5d356378be5043e69441a072b50a5b33b4503428c77b04cb8ce7bc731", size = 4396932, upload-time = "2025-09-29T10:55:53.948Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/48/c5/d5e07995077e48220269c28a221e168c91123ad5ceee44d548f54a057fc0/ipython-9.6.0-py3-none-any.whl", hash = "sha256:5f77efafc886d2f023442479b8149e7d86547ad0a979e9da9f045d252f648196", size = 616170, upload-time = "2025-09-29T10:55:47.676Z" }, +] + +[[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 = "jupyter-client" +version = "8.6.3" +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/71/22/bf9f12fdaeae18019a468b68952a60fe6dbab5d67cd2a103cac7659b41ca/jupyter_client-8.6.3.tar.gz", hash = "sha256:35b3a0947c4a6e9d589eb97d7d4cd5e90f910ee73101611f01283732bd6d9419", size = 342019, upload-time = "2024-09-17T10:44:17.613Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/11/85/b0394e0b6fcccd2c1eeefc230978a6f8cb0c5df1e4cd3e7625735a0d7d1e/jupyter_client-8.6.3-py3-none-any.whl", hash = "sha256:e8a19cc986cc45905ac3362915f410f3af85424b4c0905e94fa5f2cb08e8f23f", size = 106105, upload-time = "2024-09-17T10:44:15.218Z" }, +] + +[[package]] +name = "jupyter-core" +version = "5.9.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "platformdirs" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6f/0c/7b01e93e054555cbadf614f2ff10ea77aecbc8867831914d8a2c5868481a/jupyter_core-5.9.0.tar.gz", hash = "sha256:5f8fba10cfc946fe1b4037e986458fc89430397207b21d741dc399d3d42951d4", size = 89804, upload-time = "2025-10-16T12:12:23.851Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/96/f2/5efda2a70d98288f4d94baba8489cd782d53772233c77351864bc754a146/jupyter_core-5.9.0-py3-none-any.whl", hash = "sha256:bf13431d292ce34a25568586729a3b9deb07d112289b77350dc4c2340c2f34c1", size = 29024, upload-time = "2025-10-16T12:12:22.19Z" }, +] + +[[package]] +name = "kiwisolver" +version = "1.4.9" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/5c/3c/85844f1b0feb11ee581ac23fe5fce65cd049a200c1446708cc1b7f922875/kiwisolver-1.4.9.tar.gz", hash = "sha256:c3b22c26c6fd6811b0ae8363b95ca8ce4ea3c202d3d0975b2914310ceb1bcc4d", size = 97564, upload-time = "2025-08-10T21:27:49.279Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/86/c9/13573a747838aeb1c76e3267620daa054f4152444d1f3d1a2324b78255b5/kiwisolver-1.4.9-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:ac5a486ac389dddcc5bef4f365b6ae3ffff2c433324fb38dd35e3fab7c957999", size = 123686, upload-time = "2025-08-10T21:26:10.034Z" }, + { url = "https://files.pythonhosted.org/packages/51/ea/2ecf727927f103ffd1739271ca19c424d0e65ea473fbaeea1c014aea93f6/kiwisolver-1.4.9-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:f2ba92255faa7309d06fe44c3a4a97efe1c8d640c2a79a5ef728b685762a6fd2", size = 66460, upload-time = "2025-08-10T21:26:11.083Z" }, + { url = "https://files.pythonhosted.org/packages/5b/5a/51f5464373ce2aeb5194508298a508b6f21d3867f499556263c64c621914/kiwisolver-1.4.9-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:4a2899935e724dd1074cb568ce7ac0dce28b2cd6ab539c8e001a8578eb106d14", size = 64952, upload-time = "2025-08-10T21:26:12.058Z" }, + { url = "https://files.pythonhosted.org/packages/70/90/6d240beb0f24b74371762873e9b7f499f1e02166a2d9c5801f4dbf8fa12e/kiwisolver-1.4.9-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f6008a4919fdbc0b0097089f67a1eb55d950ed7e90ce2cc3e640abadd2757a04", size = 1474756, upload-time = "2025-08-10T21:26:13.096Z" }, + { url = "https://files.pythonhosted.org/packages/12/42/f36816eaf465220f683fb711efdd1bbf7a7005a2473d0e4ed421389bd26c/kiwisolver-1.4.9-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:67bb8b474b4181770f926f7b7d2f8c0248cbcb78b660fdd41a47054b28d2a752", size = 1276404, upload-time = "2025-08-10T21:26:14.457Z" }, + { url = "https://files.pythonhosted.org/packages/2e/64/bc2de94800adc830c476dce44e9b40fd0809cddeef1fde9fcf0f73da301f/kiwisolver-1.4.9-cp312-cp312-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2327a4a30d3ee07d2fbe2e7933e8a37c591663b96ce42a00bc67461a87d7df77", size = 1294410, upload-time = "2025-08-10T21:26:15.73Z" }, + { url = "https://files.pythonhosted.org/packages/5f/42/2dc82330a70aa8e55b6d395b11018045e58d0bb00834502bf11509f79091/kiwisolver-1.4.9-cp312-cp312-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:7a08b491ec91b1d5053ac177afe5290adacf1f0f6307d771ccac5de30592d198", size = 1343631, upload-time = "2025-08-10T21:26:17.045Z" }, + { url = "https://files.pythonhosted.org/packages/22/fd/f4c67a6ed1aab149ec5a8a401c323cee7a1cbe364381bb6c9c0d564e0e20/kiwisolver-1.4.9-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:d8fc5c867c22b828001b6a38d2eaeb88160bf5783c6cb4a5e440efc981ce286d", size = 2224963, upload-time = "2025-08-10T21:26:18.737Z" }, + { url = "https://files.pythonhosted.org/packages/45/aa/76720bd4cb3713314677d9ec94dcc21ced3f1baf4830adde5bb9b2430a5f/kiwisolver-1.4.9-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:3b3115b2581ea35bb6d1f24a4c90af37e5d9b49dcff267eeed14c3893c5b86ab", size = 2321295, upload-time = "2025-08-10T21:26:20.11Z" }, + { url = "https://files.pythonhosted.org/packages/80/19/d3ec0d9ab711242f56ae0dc2fc5d70e298bb4a1f9dfab44c027668c673a1/kiwisolver-1.4.9-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:858e4c22fb075920b96a291928cb7dea5644e94c0ee4fcd5af7e865655e4ccf2", size = 2487987, upload-time = "2025-08-10T21:26:21.49Z" }, + { url = "https://files.pythonhosted.org/packages/39/e9/61e4813b2c97e86b6fdbd4dd824bf72d28bcd8d4849b8084a357bc0dd64d/kiwisolver-1.4.9-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ed0fecd28cc62c54b262e3736f8bb2512d8dcfdc2bcf08be5f47f96bf405b145", size = 2291817, upload-time = "2025-08-10T21:26:22.812Z" }, + { url = "https://files.pythonhosted.org/packages/a0/41/85d82b0291db7504da3c2defe35c9a8a5c9803a730f297bd823d11d5fb77/kiwisolver-1.4.9-cp312-cp312-win_amd64.whl", hash = "sha256:f68208a520c3d86ea51acf688a3e3002615a7f0238002cccc17affecc86a8a54", size = 73895, upload-time = "2025-08-10T21:26:24.37Z" }, + { url = "https://files.pythonhosted.org/packages/e2/92/5f3068cf15ee5cb624a0c7596e67e2a0bb2adee33f71c379054a491d07da/kiwisolver-1.4.9-cp312-cp312-win_arm64.whl", hash = "sha256:2c1a4f57df73965f3f14df20b80ee29e6a7930a57d2d9e8491a25f676e197c60", size = 64992, upload-time = "2025-08-10T21:26:25.732Z" }, + { url = "https://files.pythonhosted.org/packages/31/c1/c2686cda909742ab66c7388e9a1a8521a59eb89f8bcfbee28fc980d07e24/kiwisolver-1.4.9-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:a5d0432ccf1c7ab14f9949eec60c5d1f924f17c037e9f8b33352fa05799359b8", size = 123681, upload-time = "2025-08-10T21:26:26.725Z" }, + { url = "https://files.pythonhosted.org/packages/ca/f0/f44f50c9f5b1a1860261092e3bc91ecdc9acda848a8b8c6abfda4a24dd5c/kiwisolver-1.4.9-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:efb3a45b35622bb6c16dbfab491a8f5a391fe0e9d45ef32f4df85658232ca0e2", size = 66464, upload-time = "2025-08-10T21:26:27.733Z" }, + { url = "https://files.pythonhosted.org/packages/2d/7a/9d90a151f558e29c3936b8a47ac770235f436f2120aca41a6d5f3d62ae8d/kiwisolver-1.4.9-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:1a12cf6398e8a0a001a059747a1cbf24705e18fe413bc22de7b3d15c67cffe3f", size = 64961, upload-time = "2025-08-10T21:26:28.729Z" }, + { url = "https://files.pythonhosted.org/packages/e9/e9/f218a2cb3a9ffbe324ca29a9e399fa2d2866d7f348ec3a88df87fc248fc5/kiwisolver-1.4.9-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b67e6efbf68e077dd71d1a6b37e43e1a99d0bff1a3d51867d45ee8908b931098", size = 1474607, upload-time = "2025-08-10T21:26:29.798Z" }, + { url = "https://files.pythonhosted.org/packages/d9/28/aac26d4c882f14de59041636292bc838db8961373825df23b8eeb807e198/kiwisolver-1.4.9-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5656aa670507437af0207645273ccdfee4f14bacd7f7c67a4306d0dcaeaf6eed", size = 1276546, upload-time = "2025-08-10T21:26:31.401Z" }, + { url = "https://files.pythonhosted.org/packages/8b/ad/8bfc1c93d4cc565e5069162f610ba2f48ff39b7de4b5b8d93f69f30c4bed/kiwisolver-1.4.9-cp313-cp313-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:bfc08add558155345129c7803b3671cf195e6a56e7a12f3dde7c57d9b417f525", size = 1294482, upload-time = "2025-08-10T21:26:32.721Z" }, + { url = "https://files.pythonhosted.org/packages/da/f1/6aca55ff798901d8ce403206d00e033191f63d82dd708a186e0ed2067e9c/kiwisolver-1.4.9-cp313-cp313-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:40092754720b174e6ccf9e845d0d8c7d8e12c3d71e7fc35f55f3813e96376f78", size = 1343720, upload-time = "2025-08-10T21:26:34.032Z" }, + { url = "https://files.pythonhosted.org/packages/d1/91/eed031876c595c81d90d0f6fc681ece250e14bf6998c3d7c419466b523b7/kiwisolver-1.4.9-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:497d05f29a1300d14e02e6441cf0f5ee81c1ff5a304b0d9fb77423974684e08b", size = 2224907, upload-time = "2025-08-10T21:26:35.824Z" }, + { url = "https://files.pythonhosted.org/packages/e9/ec/4d1925f2e49617b9cca9c34bfa11adefad49d00db038e692a559454dfb2e/kiwisolver-1.4.9-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:bdd1a81a1860476eb41ac4bc1e07b3f07259e6d55bbf739b79c8aaedcf512799", size = 2321334, upload-time = "2025-08-10T21:26:37.534Z" }, + { url = "https://files.pythonhosted.org/packages/43/cb/450cd4499356f68802750c6ddc18647b8ea01ffa28f50d20598e0befe6e9/kiwisolver-1.4.9-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:e6b93f13371d341afee3be9f7c5964e3fe61d5fa30f6a30eb49856935dfe4fc3", size = 2488313, upload-time = "2025-08-10T21:26:39.191Z" }, + { url = "https://files.pythonhosted.org/packages/71/67/fc76242bd99f885651128a5d4fa6083e5524694b7c88b489b1b55fdc491d/kiwisolver-1.4.9-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:d75aa530ccfaa593da12834b86a0724f58bff12706659baa9227c2ccaa06264c", size = 2291970, upload-time = "2025-08-10T21:26:40.828Z" }, + { url = "https://files.pythonhosted.org/packages/75/bd/f1a5d894000941739f2ae1b65a32892349423ad49c2e6d0771d0bad3fae4/kiwisolver-1.4.9-cp313-cp313-win_amd64.whl", hash = "sha256:dd0a578400839256df88c16abddf9ba14813ec5f21362e1fe65022e00c883d4d", size = 73894, upload-time = "2025-08-10T21:26:42.33Z" }, + { url = "https://files.pythonhosted.org/packages/95/38/dce480814d25b99a391abbddadc78f7c117c6da34be68ca8b02d5848b424/kiwisolver-1.4.9-cp313-cp313-win_arm64.whl", hash = "sha256:d4188e73af84ca82468f09cadc5ac4db578109e52acb4518d8154698d3a87ca2", size = 64995, upload-time = "2025-08-10T21:26:43.889Z" }, + { url = "https://files.pythonhosted.org/packages/e2/37/7d218ce5d92dadc5ebdd9070d903e0c7cf7edfe03f179433ac4d13ce659c/kiwisolver-1.4.9-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:5a0f2724dfd4e3b3ac5a82436a8e6fd16baa7d507117e4279b660fe8ca38a3a1", size = 126510, upload-time = "2025-08-10T21:26:44.915Z" }, + { url = "https://files.pythonhosted.org/packages/23/b0/e85a2b48233daef4b648fb657ebbb6f8367696a2d9548a00b4ee0eb67803/kiwisolver-1.4.9-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:1b11d6a633e4ed84fc0ddafd4ebfd8ea49b3f25082c04ad12b8315c11d504dc1", size = 67903, upload-time = "2025-08-10T21:26:45.934Z" }, + { url = "https://files.pythonhosted.org/packages/44/98/f2425bc0113ad7de24da6bb4dae1343476e95e1d738be7c04d31a5d037fd/kiwisolver-1.4.9-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:61874cdb0a36016354853593cffc38e56fc9ca5aa97d2c05d3dcf6922cd55a11", size = 66402, upload-time = "2025-08-10T21:26:47.101Z" }, + { url = "https://files.pythonhosted.org/packages/98/d8/594657886df9f34c4177cc353cc28ca7e6e5eb562d37ccc233bff43bbe2a/kiwisolver-1.4.9-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:60c439763a969a6af93b4881db0eed8fadf93ee98e18cbc35bc8da868d0c4f0c", size = 1582135, upload-time = "2025-08-10T21:26:48.665Z" }, + { url = "https://files.pythonhosted.org/packages/5c/c6/38a115b7170f8b306fc929e166340c24958347308ea3012c2b44e7e295db/kiwisolver-1.4.9-cp313-cp313t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:92a2f997387a1b79a75e7803aa7ded2cfbe2823852ccf1ba3bcf613b62ae3197", size = 1389409, upload-time = "2025-08-10T21:26:50.335Z" }, + { url = "https://files.pythonhosted.org/packages/bf/3b/e04883dace81f24a568bcee6eb3001da4ba05114afa622ec9b6fafdc1f5e/kiwisolver-1.4.9-cp313-cp313t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a31d512c812daea6d8b3be3b2bfcbeb091dbb09177706569bcfc6240dcf8b41c", size = 1401763, upload-time = "2025-08-10T21:26:51.867Z" }, + { url = "https://files.pythonhosted.org/packages/9f/80/20ace48e33408947af49d7d15c341eaee69e4e0304aab4b7660e234d6288/kiwisolver-1.4.9-cp313-cp313t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:52a15b0f35dad39862d376df10c5230155243a2c1a436e39eb55623ccbd68185", size = 1453643, upload-time = "2025-08-10T21:26:53.592Z" }, + { url = "https://files.pythonhosted.org/packages/64/31/6ce4380a4cd1f515bdda976a1e90e547ccd47b67a1546d63884463c92ca9/kiwisolver-1.4.9-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:a30fd6fdef1430fd9e1ba7b3398b5ee4e2887783917a687d86ba69985fb08748", size = 2330818, upload-time = "2025-08-10T21:26:55.051Z" }, + { url = "https://files.pythonhosted.org/packages/fa/e9/3f3fcba3bcc7432c795b82646306e822f3fd74df0ee81f0fa067a1f95668/kiwisolver-1.4.9-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:cc9617b46837c6468197b5945e196ee9ca43057bb7d9d1ae688101e4e1dddf64", size = 2419963, upload-time = "2025-08-10T21:26:56.421Z" }, + { url = "https://files.pythonhosted.org/packages/99/43/7320c50e4133575c66e9f7dadead35ab22d7c012a3b09bb35647792b2a6d/kiwisolver-1.4.9-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:0ab74e19f6a2b027ea4f845a78827969af45ce790e6cb3e1ebab71bdf9f215ff", size = 2594639, upload-time = "2025-08-10T21:26:57.882Z" }, + { url = "https://files.pythonhosted.org/packages/65/d6/17ae4a270d4a987ef8a385b906d2bdfc9fce502d6dc0d3aea865b47f548c/kiwisolver-1.4.9-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:dba5ee5d3981160c28d5490f0d1b7ed730c22470ff7f6cc26cfcfaacb9896a07", size = 2391741, upload-time = "2025-08-10T21:26:59.237Z" }, + { url = "https://files.pythonhosted.org/packages/2a/8f/8f6f491d595a9e5912971f3f863d81baddccc8a4d0c3749d6a0dd9ffc9df/kiwisolver-1.4.9-cp313-cp313t-win_arm64.whl", hash = "sha256:0749fd8f4218ad2e851e11cc4dc05c7cbc0cbc4267bdfdb31782e65aace4ee9c", size = 68646, upload-time = "2025-08-10T21:27:00.52Z" }, + { url = "https://files.pythonhosted.org/packages/6b/32/6cc0fbc9c54d06c2969faa9c1d29f5751a2e51809dd55c69055e62d9b426/kiwisolver-1.4.9-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:9928fe1eb816d11ae170885a74d074f57af3a0d65777ca47e9aeb854a1fba386", size = 123806, upload-time = "2025-08-10T21:27:01.537Z" }, + { url = "https://files.pythonhosted.org/packages/b2/dd/2bfb1d4a4823d92e8cbb420fe024b8d2167f72079b3bb941207c42570bdf/kiwisolver-1.4.9-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:d0005b053977e7b43388ddec89fa567f43d4f6d5c2c0affe57de5ebf290dc552", size = 66605, upload-time = "2025-08-10T21:27:03.335Z" }, + { url = "https://files.pythonhosted.org/packages/f7/69/00aafdb4e4509c2ca6064646cba9cd4b37933898f426756adb2cb92ebbed/kiwisolver-1.4.9-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:2635d352d67458b66fd0667c14cb1d4145e9560d503219034a18a87e971ce4f3", size = 64925, upload-time = "2025-08-10T21:27:04.339Z" }, + { url = "https://files.pythonhosted.org/packages/43/dc/51acc6791aa14e5cb6d8a2e28cefb0dc2886d8862795449d021334c0df20/kiwisolver-1.4.9-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:767c23ad1c58c9e827b649a9ab7809fd5fd9db266a9cf02b0e926ddc2c680d58", size = 1472414, upload-time = "2025-08-10T21:27:05.437Z" }, + { url = "https://files.pythonhosted.org/packages/3d/bb/93fa64a81db304ac8a246f834d5094fae4b13baf53c839d6bb6e81177129/kiwisolver-1.4.9-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:72d0eb9fba308b8311685c2268cf7d0a0639a6cd027d8128659f72bdd8a024b4", size = 1281272, upload-time = "2025-08-10T21:27:07.063Z" }, + { url = "https://files.pythonhosted.org/packages/70/e6/6df102916960fb8d05069d4bd92d6d9a8202d5a3e2444494e7cd50f65b7a/kiwisolver-1.4.9-cp314-cp314-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f68e4f3eeca8fb22cc3d731f9715a13b652795ef657a13df1ad0c7dc0e9731df", size = 1298578, upload-time = "2025-08-10T21:27:08.452Z" }, + { url = "https://files.pythonhosted.org/packages/7c/47/e142aaa612f5343736b087864dbaebc53ea8831453fb47e7521fa8658f30/kiwisolver-1.4.9-cp314-cp314-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d84cd4061ae292d8ac367b2c3fa3aad11cb8625a95d135fe93f286f914f3f5a6", size = 1345607, upload-time = "2025-08-10T21:27:10.125Z" }, + { url = "https://files.pythonhosted.org/packages/54/89/d641a746194a0f4d1a3670fb900d0dbaa786fb98341056814bc3f058fa52/kiwisolver-1.4.9-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:a60ea74330b91bd22a29638940d115df9dc00af5035a9a2a6ad9399ffb4ceca5", size = 2230150, upload-time = "2025-08-10T21:27:11.484Z" }, + { url = "https://files.pythonhosted.org/packages/aa/6b/5ee1207198febdf16ac11f78c5ae40861b809cbe0e6d2a8d5b0b3044b199/kiwisolver-1.4.9-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:ce6a3a4e106cf35c2d9c4fa17c05ce0b180db622736845d4315519397a77beaf", size = 2325979, upload-time = "2025-08-10T21:27:12.917Z" }, + { url = "https://files.pythonhosted.org/packages/fc/ff/b269eefd90f4ae14dcc74973d5a0f6d28d3b9bb1afd8c0340513afe6b39a/kiwisolver-1.4.9-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:77937e5e2a38a7b48eef0585114fe7930346993a88060d0bf886086d2aa49ef5", size = 2491456, upload-time = "2025-08-10T21:27:14.353Z" }, + { url = "https://files.pythonhosted.org/packages/fc/d4/10303190bd4d30de547534601e259a4fbf014eed94aae3e5521129215086/kiwisolver-1.4.9-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:24c175051354f4a28c5d6a31c93906dc653e2bf234e8a4bbfb964892078898ce", size = 2294621, upload-time = "2025-08-10T21:27:15.808Z" }, + { url = "https://files.pythonhosted.org/packages/28/e0/a9a90416fce5c0be25742729c2ea52105d62eda6c4be4d803c2a7be1fa50/kiwisolver-1.4.9-cp314-cp314-win_amd64.whl", hash = "sha256:0763515d4df10edf6d06a3c19734e2566368980d21ebec439f33f9eb936c07b7", size = 75417, upload-time = "2025-08-10T21:27:17.436Z" }, + { url = "https://files.pythonhosted.org/packages/1f/10/6949958215b7a9a264299a7db195564e87900f709db9245e4ebdd3c70779/kiwisolver-1.4.9-cp314-cp314-win_arm64.whl", hash = "sha256:0e4e2bf29574a6a7b7f6cb5fa69293b9f96c928949ac4a53ba3f525dffb87f9c", size = 66582, upload-time = "2025-08-10T21:27:18.436Z" }, + { url = "https://files.pythonhosted.org/packages/ec/79/60e53067903d3bc5469b369fe0dfc6b3482e2133e85dae9daa9527535991/kiwisolver-1.4.9-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:d976bbb382b202f71c67f77b0ac11244021cfa3f7dfd9e562eefcea2df711548", size = 126514, upload-time = "2025-08-10T21:27:19.465Z" }, + { url = "https://files.pythonhosted.org/packages/25/d1/4843d3e8d46b072c12a38c97c57fab4608d36e13fe47d47ee96b4d61ba6f/kiwisolver-1.4.9-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:2489e4e5d7ef9a1c300a5e0196e43d9c739f066ef23270607d45aba368b91f2d", size = 67905, upload-time = "2025-08-10T21:27:20.51Z" }, + { url = "https://files.pythonhosted.org/packages/8c/ae/29ffcbd239aea8b93108de1278271ae764dfc0d803a5693914975f200596/kiwisolver-1.4.9-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:e2ea9f7ab7fbf18fffb1b5434ce7c69a07582f7acc7717720f1d69f3e806f90c", size = 66399, upload-time = "2025-08-10T21:27:21.496Z" }, + { url = "https://files.pythonhosted.org/packages/a1/ae/d7ba902aa604152c2ceba5d352d7b62106bedbccc8e95c3934d94472bfa3/kiwisolver-1.4.9-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b34e51affded8faee0dfdb705416153819d8ea9250bbbf7ea1b249bdeb5f1122", size = 1582197, upload-time = "2025-08-10T21:27:22.604Z" }, + { url = "https://files.pythonhosted.org/packages/f2/41/27c70d427eddb8bc7e4f16420a20fefc6f480312122a59a959fdfe0445ad/kiwisolver-1.4.9-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d8aacd3d4b33b772542b2e01beb50187536967b514b00003bdda7589722d2a64", size = 1390125, upload-time = "2025-08-10T21:27:24.036Z" }, + { url = "https://files.pythonhosted.org/packages/41/42/b3799a12bafc76d962ad69083f8b43b12bf4fe78b097b12e105d75c9b8f1/kiwisolver-1.4.9-cp314-cp314t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7cf974dd4e35fa315563ac99d6287a1024e4dc2077b8a7d7cd3d2fb65d283134", size = 1402612, upload-time = "2025-08-10T21:27:25.773Z" }, + { url = "https://files.pythonhosted.org/packages/d2/b5/a210ea073ea1cfaca1bb5c55a62307d8252f531beb364e18aa1e0888b5a0/kiwisolver-1.4.9-cp314-cp314t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:85bd218b5ecfbee8c8a82e121802dcb519a86044c9c3b2e4aef02fa05c6da370", size = 1453990, upload-time = "2025-08-10T21:27:27.089Z" }, + { url = "https://files.pythonhosted.org/packages/5f/ce/a829eb8c033e977d7ea03ed32fb3c1781b4fa0433fbadfff29e39c676f32/kiwisolver-1.4.9-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:0856e241c2d3df4efef7c04a1e46b1936b6120c9bcf36dd216e3acd84bc4fb21", size = 2331601, upload-time = "2025-08-10T21:27:29.343Z" }, + { url = "https://files.pythonhosted.org/packages/e0/4b/b5e97eb142eb9cd0072dacfcdcd31b1c66dc7352b0f7c7255d339c0edf00/kiwisolver-1.4.9-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:9af39d6551f97d31a4deebeac6f45b156f9755ddc59c07b402c148f5dbb6482a", size = 2422041, upload-time = "2025-08-10T21:27:30.754Z" }, + { url = "https://files.pythonhosted.org/packages/40/be/8eb4cd53e1b85ba4edc3a9321666f12b83113a178845593307a3e7891f44/kiwisolver-1.4.9-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:bb4ae2b57fc1d8cbd1cf7b1d9913803681ffa903e7488012be5b76dedf49297f", size = 2594897, upload-time = "2025-08-10T21:27:32.803Z" }, + { url = "https://files.pythonhosted.org/packages/99/dd/841e9a66c4715477ea0abc78da039832fbb09dac5c35c58dc4c41a407b8a/kiwisolver-1.4.9-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:aedff62918805fb62d43a4aa2ecd4482c380dc76cd31bd7c8878588a61bd0369", size = 2391835, upload-time = "2025-08-10T21:27:34.23Z" }, + { url = "https://files.pythonhosted.org/packages/0c/28/4b2e5c47a0da96896fdfdb006340ade064afa1e63675d01ea5ac222b6d52/kiwisolver-1.4.9-cp314-cp314t-win_amd64.whl", hash = "sha256:1fa333e8b2ce4d9660f2cda9c0e1b6bafcfb2457a9d259faa82289e73ec24891", size = 79988, upload-time = "2025-08-10T21:27:35.587Z" }, + { url = "https://files.pythonhosted.org/packages/80/be/3578e8afd18c88cdf9cb4cffde75a96d2be38c5a903f1ed0ceec061bd09e/kiwisolver-1.4.9-cp314-cp314t-win_arm64.whl", hash = "sha256:4a48a2ce79d65d363597ef7b567ce3d14d68783d2b2263d98db3d9477805ba32", size = 70260, upload-time = "2025-08-10T21:27:36.606Z" }, +] + +[[package]] +name = "matplotlib" +version = "3.10.7" +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/ae/e2/d2d5295be2f44c678ebaf3544ba32d20c1f9ef08c49fe47f496180e1db15/matplotlib-3.10.7.tar.gz", hash = "sha256:a06ba7e2a2ef9131c79c49e63dad355d2d878413a0376c1727c8b9335ff731c7", size = 34804865, upload-time = "2025-10-09T00:28:00.669Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/be/b3/09eb0f7796932826ec20c25b517d568627754f6c6462fca19e12c02f2e12/matplotlib-3.10.7-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7a0edb7209e21840e8361e91ea84ea676658aa93edd5f8762793dec77a4a6748", size = 8272389, upload-time = "2025-10-09T00:26:42.474Z" }, + { url = "https://files.pythonhosted.org/packages/11/0b/1ae80ddafb8652fd8046cb5c8460ecc8d4afccb89e2c6d6bec61e04e1eaf/matplotlib-3.10.7-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c380371d3c23e0eadf8ebff114445b9f970aff2010198d498d4ab4c3b41eea4f", size = 8128247, upload-time = "2025-10-09T00:26:44.77Z" }, + { url = "https://files.pythonhosted.org/packages/7d/18/95ae2e242d4a5c98bd6e90e36e128d71cf1c7e39b0874feaed3ef782e789/matplotlib-3.10.7-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d5f256d49fea31f40f166a5e3131235a5d2f4b7f44520b1cf0baf1ce568ccff0", size = 8696996, upload-time = "2025-10-09T00:26:46.792Z" }, + { url = "https://files.pythonhosted.org/packages/7e/3d/5b559efc800bd05cb2033aa85f7e13af51958136a48327f7c261801ff90a/matplotlib-3.10.7-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:11ae579ac83cdf3fb72573bb89f70e0534de05266728740d478f0f818983c695", size = 9530153, upload-time = "2025-10-09T00:26:49.07Z" }, + { url = "https://files.pythonhosted.org/packages/88/57/eab4a719fd110312d3c220595d63a3c85ec2a39723f0f4e7fa7e6e3f74ba/matplotlib-3.10.7-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:4c14b6acd16cddc3569a2d515cfdd81c7a68ac5639b76548cfc1a9e48b20eb65", size = 9593093, upload-time = "2025-10-09T00:26:51.067Z" }, + { url = "https://files.pythonhosted.org/packages/31/3c/80816f027b3a4a28cd2a0a6ef7f89a2db22310e945cd886ec25bfb399221/matplotlib-3.10.7-cp312-cp312-win_amd64.whl", hash = "sha256:0d8c32b7ea6fb80b1aeff5a2ceb3fb9778e2759e899d9beff75584714afcc5ee", size = 8122771, upload-time = "2025-10-09T00:26:53.296Z" }, + { url = "https://files.pythonhosted.org/packages/de/77/ef1fc78bfe99999b2675435cc52120887191c566b25017d78beaabef7f2d/matplotlib-3.10.7-cp312-cp312-win_arm64.whl", hash = "sha256:5f3f6d315dcc176ba7ca6e74c7768fb7e4cf566c49cb143f6bc257b62e634ed8", size = 7992812, upload-time = "2025-10-09T00:26:54.882Z" }, + { url = "https://files.pythonhosted.org/packages/02/9c/207547916a02c78f6bdd83448d9b21afbc42f6379ed887ecf610984f3b4e/matplotlib-3.10.7-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:1d9d3713a237970569156cfb4de7533b7c4eacdd61789726f444f96a0d28f57f", size = 8273212, upload-time = "2025-10-09T00:26:56.752Z" }, + { url = "https://files.pythonhosted.org/packages/bc/d0/b3d3338d467d3fc937f0bb7f256711395cae6f78e22cef0656159950adf0/matplotlib-3.10.7-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:37a1fea41153dd6ee061d21ab69c9cf2cf543160b1b85d89cd3d2e2a7902ca4c", size = 8128713, upload-time = "2025-10-09T00:26:59.001Z" }, + { url = "https://files.pythonhosted.org/packages/22/ff/6425bf5c20d79aa5b959d1ce9e65f599632345391381c9a104133fe0b171/matplotlib-3.10.7-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b3c4ea4948d93c9c29dc01c0c23eef66f2101bf75158c291b88de6525c55c3d1", size = 8698527, upload-time = "2025-10-09T00:27:00.69Z" }, + { url = "https://files.pythonhosted.org/packages/d0/7f/ccdca06f4c2e6c7989270ed7829b8679466682f4cfc0f8c9986241c023b6/matplotlib-3.10.7-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:22df30ffaa89f6643206cf13877191c63a50e8f800b038bc39bee9d2d4957632", size = 9529690, upload-time = "2025-10-09T00:27:02.664Z" }, + { url = "https://files.pythonhosted.org/packages/b8/95/b80fc2c1f269f21ff3d193ca697358e24408c33ce2b106a7438a45407b63/matplotlib-3.10.7-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:b69676845a0a66f9da30e87f48be36734d6748024b525ec4710be40194282c84", size = 9593732, upload-time = "2025-10-09T00:27:04.653Z" }, + { url = "https://files.pythonhosted.org/packages/e1/b6/23064a96308b9aeceeffa65e96bcde459a2ea4934d311dee20afde7407a0/matplotlib-3.10.7-cp313-cp313-win_amd64.whl", hash = "sha256:744991e0cc863dd669c8dc9136ca4e6e0082be2070b9d793cbd64bec872a6815", size = 8122727, upload-time = "2025-10-09T00:27:06.814Z" }, + { url = "https://files.pythonhosted.org/packages/b3/a6/2faaf48133b82cf3607759027f82b5c702aa99cdfcefb7f93d6ccf26a424/matplotlib-3.10.7-cp313-cp313-win_arm64.whl", hash = "sha256:fba2974df0bf8ce3c995fa84b79cde38326e0f7b5409e7a3a481c1141340bcf7", size = 7992958, upload-time = "2025-10-09T00:27:08.567Z" }, + { url = "https://files.pythonhosted.org/packages/4a/f0/b018fed0b599bd48d84c08794cb242227fe3341952da102ee9d9682db574/matplotlib-3.10.7-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:932c55d1fa7af4423422cb6a492a31cbcbdbe68fd1a9a3f545aa5e7a143b5355", size = 8316849, upload-time = "2025-10-09T00:27:10.254Z" }, + { url = "https://files.pythonhosted.org/packages/b0/b7/bb4f23856197659f275e11a2a164e36e65e9b48ea3e93c4ec25b4f163198/matplotlib-3.10.7-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:5e38c2d581d62ee729a6e144c47a71b3f42fb4187508dbbf4fe71d5612c3433b", size = 8178225, upload-time = "2025-10-09T00:27:12.241Z" }, + { url = "https://files.pythonhosted.org/packages/62/56/0600609893ff277e6f3ab3c0cef4eafa6e61006c058e84286c467223d4d5/matplotlib-3.10.7-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:786656bb13c237bbcebcd402f65f44dd61ead60ee3deb045af429d889c8dbc67", size = 8711708, upload-time = "2025-10-09T00:27:13.879Z" }, + { url = "https://files.pythonhosted.org/packages/d8/1a/6bfecb0cafe94d6658f2f1af22c43b76cf7a1c2f0dc34ef84cbb6809617e/matplotlib-3.10.7-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:09d7945a70ea43bf9248f4b6582734c2fe726723204a76eca233f24cffc7ef67", size = 9541409, upload-time = "2025-10-09T00:27:15.684Z" }, + { url = "https://files.pythonhosted.org/packages/08/50/95122a407d7f2e446fd865e2388a232a23f2b81934960ea802f3171518e4/matplotlib-3.10.7-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:d0b181e9fa8daf1d9f2d4c547527b167cb8838fc587deabca7b5c01f97199e84", size = 9594054, upload-time = "2025-10-09T00:27:17.547Z" }, + { url = "https://files.pythonhosted.org/packages/13/76/75b194a43b81583478a81e78a07da8d9ca6ddf50dd0a2ccabf258059481d/matplotlib-3.10.7-cp313-cp313t-win_amd64.whl", hash = "sha256:31963603041634ce1a96053047b40961f7a29eb8f9a62e80cc2c0427aa1d22a2", size = 8200100, upload-time = "2025-10-09T00:27:20.039Z" }, + { url = "https://files.pythonhosted.org/packages/f5/9e/6aefebdc9f8235c12bdeeda44cc0383d89c1e41da2c400caf3ee2073a3ce/matplotlib-3.10.7-cp313-cp313t-win_arm64.whl", hash = "sha256:aebed7b50aa6ac698c90f60f854b47e48cd2252b30510e7a1feddaf5a3f72cbf", size = 8042131, upload-time = "2025-10-09T00:27:21.608Z" }, + { url = "https://files.pythonhosted.org/packages/0d/4b/e5bc2c321b6a7e3a75638d937d19ea267c34bd5a90e12bee76c4d7c7a0d9/matplotlib-3.10.7-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:d883460c43e8c6b173fef244a2341f7f7c0e9725c7fe68306e8e44ed9c8fb100", size = 8273787, upload-time = "2025-10-09T00:27:23.27Z" }, + { url = "https://files.pythonhosted.org/packages/86/ad/6efae459c56c2fbc404da154e13e3a6039129f3c942b0152624f1c621f05/matplotlib-3.10.7-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:07124afcf7a6504eafcb8ce94091c5898bbdd351519a1beb5c45f7a38c67e77f", size = 8131348, upload-time = "2025-10-09T00:27:24.926Z" }, + { url = "https://files.pythonhosted.org/packages/a6/5a/a4284d2958dee4116359cc05d7e19c057e64ece1b4ac986ab0f2f4d52d5a/matplotlib-3.10.7-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c17398b709a6cce3d9fdb1595c33e356d91c098cd9486cb2cc21ea2ea418e715", size = 9533949, upload-time = "2025-10-09T00:27:26.704Z" }, + { url = "https://files.pythonhosted.org/packages/de/ff/f3781b5057fa3786623ad8976fc9f7b0d02b2f28534751fd5a44240de4cf/matplotlib-3.10.7-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7146d64f561498764561e9cd0ed64fcf582e570fc519e6f521e2d0cfd43365e1", size = 9804247, upload-time = "2025-10-09T00:27:28.514Z" }, + { url = "https://files.pythonhosted.org/packages/47/5a/993a59facb8444efb0e197bf55f545ee449902dcee86a4dfc580c3b61314/matplotlib-3.10.7-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:90ad854c0a435da3104c01e2c6f0028d7e719b690998a2333d7218db80950722", size = 9595497, upload-time = "2025-10-09T00:27:30.418Z" }, + { url = "https://files.pythonhosted.org/packages/0d/a5/77c95aaa9bb32c345cbb49626ad8eb15550cba2e6d4c88081a6c2ac7b08d/matplotlib-3.10.7-cp314-cp314-win_amd64.whl", hash = "sha256:4645fc5d9d20ffa3a39361fcdbcec731382763b623b72627806bf251b6388866", size = 8252732, upload-time = "2025-10-09T00:27:32.332Z" }, + { url = "https://files.pythonhosted.org/packages/74/04/45d269b4268d222390d7817dae77b159651909669a34ee9fdee336db5883/matplotlib-3.10.7-cp314-cp314-win_arm64.whl", hash = "sha256:9257be2f2a03415f9105c486d304a321168e61ad450f6153d77c69504ad764bb", size = 8124240, upload-time = "2025-10-09T00:27:33.94Z" }, + { url = "https://files.pythonhosted.org/packages/4b/c7/ca01c607bb827158b439208c153d6f14ddb9fb640768f06f7ca3488ae67b/matplotlib-3.10.7-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:1e4bbad66c177a8fdfa53972e5ef8be72a5f27e6a607cec0d8579abd0f3102b1", size = 8316938, upload-time = "2025-10-09T00:27:35.534Z" }, + { url = "https://files.pythonhosted.org/packages/84/d2/5539e66e9f56d2fdec94bb8436f5e449683b4e199bcc897c44fbe3c99e28/matplotlib-3.10.7-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:d8eb7194b084b12feb19142262165832fc6ee879b945491d1c3d4660748020c4", size = 8178245, upload-time = "2025-10-09T00:27:37.334Z" }, + { url = "https://files.pythonhosted.org/packages/77/b5/e6ca22901fd3e4fe433a82e583436dd872f6c966fca7e63cf806b40356f8/matplotlib-3.10.7-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b4d41379b05528091f00e1728004f9a8d7191260f3862178b88e8fd770206318", size = 9541411, upload-time = "2025-10-09T00:27:39.387Z" }, + { url = "https://files.pythonhosted.org/packages/9e/99/a4524db57cad8fee54b7237239a8f8360bfcfa3170d37c9e71c090c0f409/matplotlib-3.10.7-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4a74f79fafb2e177f240579bc83f0b60f82cc47d2f1d260f422a0627207008ca", size = 9803664, upload-time = "2025-10-09T00:27:41.492Z" }, + { url = "https://files.pythonhosted.org/packages/e6/a5/85e2edf76ea0ad4288d174926d9454ea85f3ce5390cc4e6fab196cbf250b/matplotlib-3.10.7-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:702590829c30aada1e8cef0568ddbffa77ca747b4d6e36c6d173f66e301f89cc", size = 9594066, upload-time = "2025-10-09T00:27:43.694Z" }, + { url = "https://files.pythonhosted.org/packages/39/69/9684368a314f6d83fe5c5ad2a4121a3a8e03723d2e5c8ea17b66c1bad0e7/matplotlib-3.10.7-cp314-cp314t-win_amd64.whl", hash = "sha256:f79d5de970fc90cd5591f60053aecfce1fcd736e0303d9f0bf86be649fa68fb8", size = 8342832, upload-time = "2025-10-09T00:27:45.543Z" }, + { url = "https://files.pythonhosted.org/packages/04/5f/e22e08da14bc1a0894184640d47819d2338b792732e20d292bf86e5ab785/matplotlib-3.10.7-cp314-cp314t-win_arm64.whl", hash = "sha256:cb783436e47fcf82064baca52ce748af71725d0352e1d31564cbe9c95df92b9c", size = 8172585, upload-time = "2025-10-09T00:27:47.185Z" }, +] + +[[package]] +name = "matplotlib-inline" +version = "0.1.7" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/99/5b/a36a337438a14116b16480db471ad061c36c3694df7c2084a0da7ba538b7/matplotlib_inline-0.1.7.tar.gz", hash = "sha256:8423b23ec666be3d16e16b60bdd8ac4e86e840ebd1dd11a30b9f117f2fa0ab90", size = 8159, upload-time = "2024-04-15T13:44:44.803Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8f/8e/9ad090d3553c280a8060fbf6e24dc1c0c29704ee7d1c372f0c174aa59285/matplotlib_inline-0.1.7-py3-none-any.whl", hash = "sha256:df192d39a4ff8f21b1895d72e6a13f5fcc5099f00fa84384e0ea28c2cc0653ca", size = 9899, upload-time = "2024-04-15T13:44:43.265Z" }, +] + +[[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 = "numpy" +version = "2.3.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b5/f4/098d2270d52b41f1bd7db9fc288aaa0400cb48c2a3e2af6fa365d9720947/numpy-2.3.4.tar.gz", hash = "sha256:a7d018bfedb375a8d979ac758b120ba846a7fe764911a64465fd87b8729f4a6a", size = 20582187, upload-time = "2025-10-15T16:18:11.77Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/96/7a/02420400b736f84317e759291b8edaeee9dc921f72b045475a9cbdb26b17/numpy-2.3.4-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:ef1b5a3e808bc40827b5fa2c8196151a4c5abe110e1726949d7abddfe5c7ae11", size = 20957727, upload-time = "2025-10-15T16:15:44.9Z" }, + { url = "https://files.pythonhosted.org/packages/18/90/a014805d627aa5750f6f0e878172afb6454552da929144b3c07fcae1bb13/numpy-2.3.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c2f91f496a87235c6aaf6d3f3d89b17dba64996abadccb289f48456cff931ca9", size = 14187262, upload-time = "2025-10-15T16:15:47.761Z" }, + { url = "https://files.pythonhosted.org/packages/c7/e4/0a94b09abe89e500dc748e7515f21a13e30c5c3fe3396e6d4ac108c25fca/numpy-2.3.4-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:f77e5b3d3da652b474cc80a14084927a5e86a5eccf54ca8ca5cbd697bf7f2667", size = 5115992, upload-time = "2025-10-15T16:15:50.144Z" }, + { url = "https://files.pythonhosted.org/packages/88/dd/db77c75b055c6157cbd4f9c92c4458daef0dd9cbe6d8d2fe7f803cb64c37/numpy-2.3.4-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:8ab1c5f5ee40d6e01cbe96de5863e39b215a4d24e7d007cad56c7184fdf4aeef", size = 6648672, upload-time = "2025-10-15T16:15:52.442Z" }, + { url = "https://files.pythonhosted.org/packages/e1/e6/e31b0d713719610e406c0ea3ae0d90760465b086da8783e2fd835ad59027/numpy-2.3.4-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:77b84453f3adcb994ddbd0d1c5d11db2d6bda1a2b7fd5ac5bd4649d6f5dc682e", size = 14284156, upload-time = "2025-10-15T16:15:54.351Z" }, + { url = "https://files.pythonhosted.org/packages/f9/58/30a85127bfee6f108282107caf8e06a1f0cc997cb6b52cdee699276fcce4/numpy-2.3.4-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4121c5beb58a7f9e6dfdee612cb24f4df5cd4db6e8261d7f4d7450a997a65d6a", size = 16641271, upload-time = "2025-10-15T16:15:56.67Z" }, + { url = "https://files.pythonhosted.org/packages/06/f2/2e06a0f2adf23e3ae29283ad96959267938d0efd20a2e25353b70065bfec/numpy-2.3.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:65611ecbb00ac9846efe04db15cbe6186f562f6bb7e5e05f077e53a599225d16", size = 16059531, upload-time = "2025-10-15T16:15:59.412Z" }, + { url = "https://files.pythonhosted.org/packages/b0/e7/b106253c7c0d5dc352b9c8fab91afd76a93950998167fa3e5afe4ef3a18f/numpy-2.3.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:dabc42f9c6577bcc13001b8810d300fe814b4cfbe8a92c873f269484594f9786", size = 18578983, upload-time = "2025-10-15T16:16:01.804Z" }, + { url = "https://files.pythonhosted.org/packages/73/e3/04ecc41e71462276ee867ccbef26a4448638eadecf1bc56772c9ed6d0255/numpy-2.3.4-cp312-cp312-win32.whl", hash = "sha256:a49d797192a8d950ca59ee2d0337a4d804f713bb5c3c50e8db26d49666e351dc", size = 6291380, upload-time = "2025-10-15T16:16:03.938Z" }, + { url = "https://files.pythonhosted.org/packages/3d/a8/566578b10d8d0e9955b1b6cd5db4e9d4592dd0026a941ff7994cedda030a/numpy-2.3.4-cp312-cp312-win_amd64.whl", hash = "sha256:985f1e46358f06c2a09921e8921e2c98168ed4ae12ccd6e5e87a4f1857923f32", size = 12787999, upload-time = "2025-10-15T16:16:05.801Z" }, + { url = "https://files.pythonhosted.org/packages/58/22/9c903a957d0a8071b607f5b1bff0761d6e608b9a965945411f867d515db1/numpy-2.3.4-cp312-cp312-win_arm64.whl", hash = "sha256:4635239814149e06e2cb9db3dd584b2fa64316c96f10656983b8026a82e6e4db", size = 10197412, upload-time = "2025-10-15T16:16:07.854Z" }, + { url = "https://files.pythonhosted.org/packages/57/7e/b72610cc91edf138bc588df5150957a4937221ca6058b825b4725c27be62/numpy-2.3.4-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:c090d4860032b857d94144d1a9976b8e36709e40386db289aaf6672de2a81966", size = 20950335, upload-time = "2025-10-15T16:16:10.304Z" }, + { url = "https://files.pythonhosted.org/packages/3e/46/bdd3370dcea2f95ef14af79dbf81e6927102ddf1cc54adc0024d61252fd9/numpy-2.3.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a13fc473b6db0be619e45f11f9e81260f7302f8d180c49a22b6e6120022596b3", size = 14179878, upload-time = "2025-10-15T16:16:12.595Z" }, + { url = "https://files.pythonhosted.org/packages/ac/01/5a67cb785bda60f45415d09c2bc245433f1c68dd82eef9c9002c508b5a65/numpy-2.3.4-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:3634093d0b428e6c32c3a69b78e554f0cd20ee420dcad5a9f3b2a63762ce4197", size = 5108673, upload-time = "2025-10-15T16:16:14.877Z" }, + { url = "https://files.pythonhosted.org/packages/c2/cd/8428e23a9fcebd33988f4cb61208fda832800ca03781f471f3727a820704/numpy-2.3.4-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:043885b4f7e6e232d7df4f51ffdef8c36320ee9d5f227b380ea636722c7ed12e", size = 6641438, upload-time = "2025-10-15T16:16:16.805Z" }, + { url = "https://files.pythonhosted.org/packages/3e/d1/913fe563820f3c6b079f992458f7331278dcd7ba8427e8e745af37ddb44f/numpy-2.3.4-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4ee6a571d1e4f0ea6d5f22d6e5fbd6ed1dc2b18542848e1e7301bd190500c9d7", size = 14281290, upload-time = "2025-10-15T16:16:18.764Z" }, + { url = "https://files.pythonhosted.org/packages/9e/7e/7d306ff7cb143e6d975cfa7eb98a93e73495c4deabb7d1b5ecf09ea0fd69/numpy-2.3.4-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fc8a63918b04b8571789688b2780ab2b4a33ab44bfe8ccea36d3eba51228c953", size = 16636543, upload-time = "2025-10-15T16:16:21.072Z" }, + { url = "https://files.pythonhosted.org/packages/47/6a/8cfc486237e56ccfb0db234945552a557ca266f022d281a2f577b98e955c/numpy-2.3.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:40cc556d5abbc54aabe2b1ae287042d7bdb80c08edede19f0c0afb36ae586f37", size = 16056117, upload-time = "2025-10-15T16:16:23.369Z" }, + { url = "https://files.pythonhosted.org/packages/b1/0e/42cb5e69ea901e06ce24bfcc4b5664a56f950a70efdcf221f30d9615f3f3/numpy-2.3.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ecb63014bb7f4ce653f8be7f1df8cbc6093a5a2811211770f6606cc92b5a78fd", size = 18577788, upload-time = "2025-10-15T16:16:27.496Z" }, + { url = "https://files.pythonhosted.org/packages/86/92/41c3d5157d3177559ef0a35da50f0cda7fa071f4ba2306dd36818591a5bc/numpy-2.3.4-cp313-cp313-win32.whl", hash = "sha256:e8370eb6925bb8c1c4264fec52b0384b44f675f191df91cbe0140ec9f0955646", size = 6282620, upload-time = "2025-10-15T16:16:29.811Z" }, + { url = "https://files.pythonhosted.org/packages/09/97/fd421e8bc50766665ad35536c2bb4ef916533ba1fdd053a62d96cc7c8b95/numpy-2.3.4-cp313-cp313-win_amd64.whl", hash = "sha256:56209416e81a7893036eea03abcb91c130643eb14233b2515c90dcac963fe99d", size = 12784672, upload-time = "2025-10-15T16:16:31.589Z" }, + { url = "https://files.pythonhosted.org/packages/ad/df/5474fb2f74970ca8eb978093969b125a84cc3d30e47f82191f981f13a8a0/numpy-2.3.4-cp313-cp313-win_arm64.whl", hash = "sha256:a700a4031bc0fd6936e78a752eefb79092cecad2599ea9c8039c548bc097f9bc", size = 10196702, upload-time = "2025-10-15T16:16:33.902Z" }, + { url = "https://files.pythonhosted.org/packages/11/83/66ac031464ec1767ea3ed48ce40f615eb441072945e98693bec0bcd056cc/numpy-2.3.4-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:86966db35c4040fdca64f0816a1c1dd8dbd027d90fca5a57e00e1ca4cd41b879", size = 21049003, upload-time = "2025-10-15T16:16:36.101Z" }, + { url = "https://files.pythonhosted.org/packages/5f/99/5b14e0e686e61371659a1d5bebd04596b1d72227ce36eed121bb0aeab798/numpy-2.3.4-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:838f045478638b26c375ee96ea89464d38428c69170360b23a1a50fa4baa3562", size = 14302980, upload-time = "2025-10-15T16:16:39.124Z" }, + { url = "https://files.pythonhosted.org/packages/2c/44/e9486649cd087d9fc6920e3fc3ac2aba10838d10804b1e179fb7cbc4e634/numpy-2.3.4-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:d7315ed1dab0286adca467377c8381cd748f3dc92235f22a7dfc42745644a96a", size = 5231472, upload-time = "2025-10-15T16:16:41.168Z" }, + { url = "https://files.pythonhosted.org/packages/3e/51/902b24fa8887e5fe2063fd61b1895a476d0bbf46811ab0c7fdf4bd127345/numpy-2.3.4-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:84f01a4d18b2cc4ade1814a08e5f3c907b079c847051d720fad15ce37aa930b6", size = 6739342, upload-time = "2025-10-15T16:16:43.777Z" }, + { url = "https://files.pythonhosted.org/packages/34/f1/4de9586d05b1962acdcdb1dc4af6646361a643f8c864cef7c852bf509740/numpy-2.3.4-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:817e719a868f0dacde4abdfc5c1910b301877970195db9ab6a5e2c4bd5b121f7", size = 14354338, upload-time = "2025-10-15T16:16:46.081Z" }, + { url = "https://files.pythonhosted.org/packages/1f/06/1c16103b425de7969d5a76bdf5ada0804b476fed05d5f9e17b777f1cbefd/numpy-2.3.4-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:85e071da78d92a214212cacea81c6da557cab307f2c34b5f85b628e94803f9c0", size = 16702392, upload-time = "2025-10-15T16:16:48.455Z" }, + { url = "https://files.pythonhosted.org/packages/34/b2/65f4dc1b89b5322093572b6e55161bb42e3e0487067af73627f795cc9d47/numpy-2.3.4-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:2ec646892819370cf3558f518797f16597b4e4669894a2ba712caccc9da53f1f", size = 16134998, upload-time = "2025-10-15T16:16:51.114Z" }, + { url = "https://files.pythonhosted.org/packages/d4/11/94ec578896cdb973aaf56425d6c7f2aff4186a5c00fac15ff2ec46998b46/numpy-2.3.4-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:035796aaaddfe2f9664b9a9372f089cfc88bd795a67bd1bfe15e6e770934cf64", size = 18651574, upload-time = "2025-10-15T16:16:53.429Z" }, + { url = "https://files.pythonhosted.org/packages/62/b7/7efa763ab33dbccf56dade36938a77345ce8e8192d6b39e470ca25ff3cd0/numpy-2.3.4-cp313-cp313t-win32.whl", hash = "sha256:fea80f4f4cf83b54c3a051f2f727870ee51e22f0248d3114b8e755d160b38cfb", size = 6413135, upload-time = "2025-10-15T16:16:55.992Z" }, + { url = "https://files.pythonhosted.org/packages/43/70/aba4c38e8400abcc2f345e13d972fb36c26409b3e644366db7649015f291/numpy-2.3.4-cp313-cp313t-win_amd64.whl", hash = "sha256:15eea9f306b98e0be91eb344a94c0e630689ef302e10c2ce5f7e11905c704f9c", size = 12928582, upload-time = "2025-10-15T16:16:57.943Z" }, + { url = "https://files.pythonhosted.org/packages/67/63/871fad5f0073fc00fbbdd7232962ea1ac40eeaae2bba66c76214f7954236/numpy-2.3.4-cp313-cp313t-win_arm64.whl", hash = "sha256:b6c231c9c2fadbae4011ca5e7e83e12dc4a5072f1a1d85a0a7b3ed754d145a40", size = 10266691, upload-time = "2025-10-15T16:17:00.048Z" }, + { url = "https://files.pythonhosted.org/packages/72/71/ae6170143c115732470ae3a2d01512870dd16e0953f8a6dc89525696069b/numpy-2.3.4-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:81c3e6d8c97295a7360d367f9f8553973651b76907988bb6066376bc2252f24e", size = 20955580, upload-time = "2025-10-15T16:17:02.509Z" }, + { url = "https://files.pythonhosted.org/packages/af/39/4be9222ffd6ca8a30eda033d5f753276a9c3426c397bb137d8e19dedd200/numpy-2.3.4-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:7c26b0b2bf58009ed1f38a641f3db4be8d960a417ca96d14e5b06df1506d41ff", size = 14188056, upload-time = "2025-10-15T16:17:04.873Z" }, + { url = "https://files.pythonhosted.org/packages/6c/3d/d85f6700d0a4aa4f9491030e1021c2b2b7421b2b38d01acd16734a2bfdc7/numpy-2.3.4-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:62b2198c438058a20b6704351b35a1d7db881812d8512d67a69c9de1f18ca05f", size = 5116555, upload-time = "2025-10-15T16:17:07.499Z" }, + { url = "https://files.pythonhosted.org/packages/bf/04/82c1467d86f47eee8a19a464c92f90a9bb68ccf14a54c5224d7031241ffb/numpy-2.3.4-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:9d729d60f8d53a7361707f4b68a9663c968882dd4f09e0d58c044c8bf5faee7b", size = 6643581, upload-time = "2025-10-15T16:17:09.774Z" }, + { url = "https://files.pythonhosted.org/packages/0c/d3/c79841741b837e293f48bd7db89d0ac7a4f2503b382b78a790ef1dc778a5/numpy-2.3.4-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bd0c630cf256b0a7fd9d0a11c9413b42fef5101219ce6ed5a09624f5a65392c7", size = 14299186, upload-time = "2025-10-15T16:17:11.937Z" }, + { url = "https://files.pythonhosted.org/packages/e8/7e/4a14a769741fbf237eec5a12a2cbc7a4c4e061852b6533bcb9e9a796c908/numpy-2.3.4-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d5e081bc082825f8b139f9e9fe42942cb4054524598aaeb177ff476cc76d09d2", size = 16638601, upload-time = "2025-10-15T16:17:14.391Z" }, + { url = "https://files.pythonhosted.org/packages/93/87/1c1de269f002ff0a41173fe01dcc925f4ecff59264cd8f96cf3b60d12c9b/numpy-2.3.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:15fb27364ed84114438fff8aaf998c9e19adbeba08c0b75409f8c452a8692c52", size = 16074219, upload-time = "2025-10-15T16:17:17.058Z" }, + { url = "https://files.pythonhosted.org/packages/cd/28/18f72ee77408e40a76d691001ae599e712ca2a47ddd2c4f695b16c65f077/numpy-2.3.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:85d9fb2d8cd998c84d13a79a09cc0c1091648e848e4e6249b0ccd7f6b487fa26", size = 18576702, upload-time = "2025-10-15T16:17:19.379Z" }, + { url = "https://files.pythonhosted.org/packages/c3/76/95650169b465ececa8cf4b2e8f6df255d4bf662775e797ade2025cc51ae6/numpy-2.3.4-cp314-cp314-win32.whl", hash = "sha256:e73d63fd04e3a9d6bc187f5455d81abfad05660b212c8804bf3b407e984cd2bc", size = 6337136, upload-time = "2025-10-15T16:17:22.886Z" }, + { url = "https://files.pythonhosted.org/packages/dc/89/a231a5c43ede5d6f77ba4a91e915a87dea4aeea76560ba4d2bf185c683f0/numpy-2.3.4-cp314-cp314-win_amd64.whl", hash = "sha256:3da3491cee49cf16157e70f607c03a217ea6647b1cea4819c4f48e53d49139b9", size = 12920542, upload-time = "2025-10-15T16:17:24.783Z" }, + { url = "https://files.pythonhosted.org/packages/0d/0c/ae9434a888f717c5ed2ff2393b3f344f0ff6f1c793519fa0c540461dc530/numpy-2.3.4-cp314-cp314-win_arm64.whl", hash = "sha256:6d9cd732068e8288dbe2717177320723ccec4fb064123f0caf9bbd90ab5be868", size = 10480213, upload-time = "2025-10-15T16:17:26.935Z" }, + { url = "https://files.pythonhosted.org/packages/83/4b/c4a5f0841f92536f6b9592694a5b5f68c9ab37b775ff342649eadf9055d3/numpy-2.3.4-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:22758999b256b595cf0b1d102b133bb61866ba5ceecf15f759623b64c020c9ec", size = 21052280, upload-time = "2025-10-15T16:17:29.638Z" }, + { url = "https://files.pythonhosted.org/packages/3e/80/90308845fc93b984d2cc96d83e2324ce8ad1fd6efea81b324cba4b673854/numpy-2.3.4-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:9cb177bc55b010b19798dc5497d540dea67fd13a8d9e882b2dae71de0cf09eb3", size = 14302930, upload-time = "2025-10-15T16:17:32.384Z" }, + { url = "https://files.pythonhosted.org/packages/3d/4e/07439f22f2a3b247cec4d63a713faae55e1141a36e77fb212881f7cda3fb/numpy-2.3.4-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:0f2bcc76f1e05e5ab58893407c63d90b2029908fa41f9f1cc51eecce936c3365", size = 5231504, upload-time = "2025-10-15T16:17:34.515Z" }, + { url = "https://files.pythonhosted.org/packages/ab/de/1e11f2547e2fe3d00482b19721855348b94ada8359aef5d40dd57bfae9df/numpy-2.3.4-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:8dc20bde86802df2ed8397a08d793da0ad7a5fd4ea3ac85d757bf5dd4ad7c252", size = 6739405, upload-time = "2025-10-15T16:17:36.128Z" }, + { url = "https://files.pythonhosted.org/packages/3b/40/8cd57393a26cebe2e923005db5134a946c62fa56a1087dc7c478f3e30837/numpy-2.3.4-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5e199c087e2aa71c8f9ce1cb7a8e10677dc12457e7cc1be4798632da37c3e86e", size = 14354866, upload-time = "2025-10-15T16:17:38.884Z" }, + { url = "https://files.pythonhosted.org/packages/93/39/5b3510f023f96874ee6fea2e40dfa99313a00bf3ab779f3c92978f34aace/numpy-2.3.4-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:85597b2d25ddf655495e2363fe044b0ae999b75bc4d630dc0d886484b03a5eb0", size = 16703296, upload-time = "2025-10-15T16:17:41.564Z" }, + { url = "https://files.pythonhosted.org/packages/41/0d/19bb163617c8045209c1996c4e427bccbc4bbff1e2c711f39203c8ddbb4a/numpy-2.3.4-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:04a69abe45b49c5955923cf2c407843d1c85013b424ae8a560bba16c92fe44a0", size = 16136046, upload-time = "2025-10-15T16:17:43.901Z" }, + { url = "https://files.pythonhosted.org/packages/e2/c1/6dba12fdf68b02a21ac411c9df19afa66bed2540f467150ca64d246b463d/numpy-2.3.4-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:e1708fac43ef8b419c975926ce1eaf793b0c13b7356cfab6ab0dc34c0a02ac0f", size = 18652691, upload-time = "2025-10-15T16:17:46.247Z" }, + { url = "https://files.pythonhosted.org/packages/f8/73/f85056701dbbbb910c51d846c58d29fd46b30eecd2b6ba760fc8b8a1641b/numpy-2.3.4-cp314-cp314t-win32.whl", hash = "sha256:863e3b5f4d9915aaf1b8ec79ae560ad21f0b8d5e3adc31e73126491bb86dee1d", size = 6485782, upload-time = "2025-10-15T16:17:48.872Z" }, + { url = "https://files.pythonhosted.org/packages/17/90/28fa6f9865181cb817c2471ee65678afa8a7e2a1fb16141473d5fa6bacc3/numpy-2.3.4-cp314-cp314t-win_amd64.whl", hash = "sha256:962064de37b9aef801d33bc579690f8bfe6c5e70e29b61783f60bcba838a14d6", size = 13113301, upload-time = "2025-10-15T16:17:50.938Z" }, + { url = "https://files.pythonhosted.org/packages/54/23/08c002201a8e7e1f9afba93b97deceb813252d9cfd0d3351caed123dcf97/numpy-2.3.4-cp314-cp314t-win_arm64.whl", hash = "sha256:8b5a9a39c45d852b62693d9b3f3e0fe052541f804296ff401a72a1b60edafb29", size = 10547532, upload-time = "2025-10-15T16:17:53.48Z" }, +] + +[[package]] +name = "packaging" +version = "25.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a1/d4/1fc4078c65507b51b96ca8f8c3ba19e6a61c8253c72794544580a7b6c24d/packaging-25.0.tar.gz", hash = "sha256:d443872c98d677bf60f6a1f2f8c1cb748e8fe762d2bf9d3148b5599295b0fc4f", size = 165727, upload-time = "2025-04-19T11:48:59.673Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/20/12/38679034af332785aac8774540895e234f4d07f7545804097de4b666afd8/packaging-25.0-py3-none-any.whl", hash = "sha256:29572ef2b1f17581046b3a2227d5c611fb25ec70ca1ba8554b24b0e69331a484", size = 66469, upload-time = "2025-04-19T11:48:57.875Z" }, +] + +[[package]] +name = "pandas" +version = "2.3.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, + { name = "python-dateutil" }, + { name = "pytz" }, + { name = "tzdata" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/33/01/d40b85317f86cf08d853a4f495195c73815fdf205eef3993821720274518/pandas-2.3.3.tar.gz", hash = "sha256:e05e1af93b977f7eafa636d043f9f94c7ee3ac81af99c13508215942e64c993b", size = 4495223, upload-time = "2025-09-29T23:34:51.853Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9c/fb/231d89e8637c808b997d172b18e9d4a4bc7bf31296196c260526055d1ea0/pandas-2.3.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6d21f6d74eb1725c2efaa71a2bfc661a0689579b58e9c0ca58a739ff0b002b53", size = 11597846, upload-time = "2025-09-29T23:19:48.856Z" }, + { url = "https://files.pythonhosted.org/packages/5c/bd/bf8064d9cfa214294356c2d6702b716d3cf3bb24be59287a6a21e24cae6b/pandas-2.3.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3fd2f887589c7aa868e02632612ba39acb0b8948faf5cc58f0850e165bd46f35", size = 10729618, upload-time = "2025-09-29T23:39:08.659Z" }, + { url = "https://files.pythonhosted.org/packages/57/56/cf2dbe1a3f5271370669475ead12ce77c61726ffd19a35546e31aa8edf4e/pandas-2.3.3-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ecaf1e12bdc03c86ad4a7ea848d66c685cb6851d807a26aa245ca3d2017a1908", size = 11737212, upload-time = "2025-09-29T23:19:59.765Z" }, + { url = "https://files.pythonhosted.org/packages/e5/63/cd7d615331b328e287d8233ba9fdf191a9c2d11b6af0c7a59cfcec23de68/pandas-2.3.3-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b3d11d2fda7eb164ef27ffc14b4fcab16a80e1ce67e9f57e19ec0afaf715ba89", size = 12362693, upload-time = "2025-09-29T23:20:14.098Z" }, + { url = "https://files.pythonhosted.org/packages/a6/de/8b1895b107277d52f2b42d3a6806e69cfef0d5cf1d0ba343470b9d8e0a04/pandas-2.3.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a68e15f780eddf2b07d242e17a04aa187a7ee12b40b930bfdd78070556550e98", size = 12771002, upload-time = "2025-09-29T23:20:26.76Z" }, + { url = "https://files.pythonhosted.org/packages/87/21/84072af3187a677c5893b170ba2c8fbe450a6ff911234916da889b698220/pandas-2.3.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:371a4ab48e950033bcf52b6527eccb564f52dc826c02afd9a1bc0ab731bba084", size = 13450971, upload-time = "2025-09-29T23:20:41.344Z" }, + { url = "https://files.pythonhosted.org/packages/86/41/585a168330ff063014880a80d744219dbf1dd7a1c706e75ab3425a987384/pandas-2.3.3-cp312-cp312-win_amd64.whl", hash = "sha256:a16dcec078a01eeef8ee61bf64074b4e524a2a3f4b3be9326420cabe59c4778b", size = 10992722, upload-time = "2025-09-29T23:20:54.139Z" }, + { url = "https://files.pythonhosted.org/packages/cd/4b/18b035ee18f97c1040d94debd8f2e737000ad70ccc8f5513f4eefad75f4b/pandas-2.3.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:56851a737e3470de7fa88e6131f41281ed440d29a9268dcbf0002da5ac366713", size = 11544671, upload-time = "2025-09-29T23:21:05.024Z" }, + { url = "https://files.pythonhosted.org/packages/31/94/72fac03573102779920099bcac1c3b05975c2cb5f01eac609faf34bed1ca/pandas-2.3.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:bdcd9d1167f4885211e401b3036c0c8d9e274eee67ea8d0758a256d60704cfe8", size = 10680807, upload-time = "2025-09-29T23:21:15.979Z" }, + { url = "https://files.pythonhosted.org/packages/16/87/9472cf4a487d848476865321de18cc8c920b8cab98453ab79dbbc98db63a/pandas-2.3.3-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e32e7cc9af0f1cc15548288a51a3b681cc2a219faa838e995f7dc53dbab1062d", size = 11709872, upload-time = "2025-09-29T23:21:27.165Z" }, + { url = "https://files.pythonhosted.org/packages/15/07/284f757f63f8a8d69ed4472bfd85122bd086e637bf4ed09de572d575a693/pandas-2.3.3-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:318d77e0e42a628c04dc56bcef4b40de67918f7041c2b061af1da41dcff670ac", size = 12306371, upload-time = "2025-09-29T23:21:40.532Z" }, + { url = "https://files.pythonhosted.org/packages/33/81/a3afc88fca4aa925804a27d2676d22dcd2031c2ebe08aabd0ae55b9ff282/pandas-2.3.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4e0a175408804d566144e170d0476b15d78458795bb18f1304fb94160cabf40c", size = 12765333, upload-time = "2025-09-29T23:21:55.77Z" }, + { url = "https://files.pythonhosted.org/packages/8d/0f/b4d4ae743a83742f1153464cf1a8ecfafc3ac59722a0b5c8602310cb7158/pandas-2.3.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:93c2d9ab0fc11822b5eece72ec9587e172f63cff87c00b062f6e37448ced4493", size = 13418120, upload-time = "2025-09-29T23:22:10.109Z" }, + { url = "https://files.pythonhosted.org/packages/4f/c7/e54682c96a895d0c808453269e0b5928a07a127a15704fedb643e9b0a4c8/pandas-2.3.3-cp313-cp313-win_amd64.whl", hash = "sha256:f8bfc0e12dc78f777f323f55c58649591b2cd0c43534e8355c51d3fede5f4dee", size = 10993991, upload-time = "2025-09-29T23:25:04.889Z" }, + { url = "https://files.pythonhosted.org/packages/f9/ca/3f8d4f49740799189e1395812f3bf23b5e8fc7c190827d55a610da72ce55/pandas-2.3.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:75ea25f9529fdec2d2e93a42c523962261e567d250b0013b16210e1d40d7c2e5", size = 12048227, upload-time = "2025-09-29T23:22:24.343Z" }, + { url = "https://files.pythonhosted.org/packages/0e/5a/f43efec3e8c0cc92c4663ccad372dbdff72b60bdb56b2749f04aa1d07d7e/pandas-2.3.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:74ecdf1d301e812db96a465a525952f4dde225fdb6d8e5a521d47e1f42041e21", size = 11411056, upload-time = "2025-09-29T23:22:37.762Z" }, + { url = "https://files.pythonhosted.org/packages/46/b1/85331edfc591208c9d1a63a06baa67b21d332e63b7a591a5ba42a10bb507/pandas-2.3.3-cp313-cp313t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6435cb949cb34ec11cc9860246ccb2fdc9ecd742c12d3304989017d53f039a78", size = 11645189, upload-time = "2025-09-29T23:22:51.688Z" }, + { url = "https://files.pythonhosted.org/packages/44/23/78d645adc35d94d1ac4f2a3c4112ab6f5b8999f4898b8cdf01252f8df4a9/pandas-2.3.3-cp313-cp313t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:900f47d8f20860de523a1ac881c4c36d65efcb2eb850e6948140fa781736e110", size = 12121912, upload-time = "2025-09-29T23:23:05.042Z" }, + { url = "https://files.pythonhosted.org/packages/53/da/d10013df5e6aaef6b425aa0c32e1fc1f3e431e4bcabd420517dceadce354/pandas-2.3.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:a45c765238e2ed7d7c608fc5bc4a6f88b642f2f01e70c0c23d2224dd21829d86", size = 12712160, upload-time = "2025-09-29T23:23:28.57Z" }, + { url = "https://files.pythonhosted.org/packages/bd/17/e756653095a083d8a37cbd816cb87148debcfcd920129b25f99dd8d04271/pandas-2.3.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:c4fc4c21971a1a9f4bdb4c73978c7f7256caa3e62b323f70d6cb80db583350bc", size = 13199233, upload-time = "2025-09-29T23:24:24.876Z" }, + { url = "https://files.pythonhosted.org/packages/04/fd/74903979833db8390b73b3a8a7d30d146d710bd32703724dd9083950386f/pandas-2.3.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:ee15f284898e7b246df8087fc82b87b01686f98ee67d85a17b7ab44143a3a9a0", size = 11540635, upload-time = "2025-09-29T23:25:52.486Z" }, + { url = "https://files.pythonhosted.org/packages/21/00/266d6b357ad5e6d3ad55093a7e8efc7dd245f5a842b584db9f30b0f0a287/pandas-2.3.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1611aedd912e1ff81ff41c745822980c49ce4a7907537be8692c8dbc31924593", size = 10759079, upload-time = "2025-09-29T23:26:33.204Z" }, + { url = "https://files.pythonhosted.org/packages/ca/05/d01ef80a7a3a12b2f8bbf16daba1e17c98a2f039cbc8e2f77a2c5a63d382/pandas-2.3.3-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6d2cefc361461662ac48810cb14365a365ce864afe85ef1f447ff5a1e99ea81c", size = 11814049, upload-time = "2025-09-29T23:27:15.384Z" }, + { url = "https://files.pythonhosted.org/packages/15/b2/0e62f78c0c5ba7e3d2c5945a82456f4fac76c480940f805e0b97fcbc2f65/pandas-2.3.3-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ee67acbbf05014ea6c763beb097e03cd629961c8a632075eeb34247120abcb4b", size = 12332638, upload-time = "2025-09-29T23:27:51.625Z" }, + { url = "https://files.pythonhosted.org/packages/c5/33/dd70400631b62b9b29c3c93d2feee1d0964dc2bae2e5ad7a6c73a7f25325/pandas-2.3.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c46467899aaa4da076d5abc11084634e2d197e9460643dd455ac3db5856b24d6", size = 12886834, upload-time = "2025-09-29T23:28:21.289Z" }, + { url = "https://files.pythonhosted.org/packages/d3/18/b5d48f55821228d0d2692b34fd5034bb185e854bdb592e9c640f6290e012/pandas-2.3.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:6253c72c6a1d990a410bc7de641d34053364ef8bcd3126f7e7450125887dffe3", size = 13409925, upload-time = "2025-09-29T23:28:58.261Z" }, + { url = "https://files.pythonhosted.org/packages/a6/3d/124ac75fcd0ecc09b8fdccb0246ef65e35b012030defb0e0eba2cbbbe948/pandas-2.3.3-cp314-cp314-win_amd64.whl", hash = "sha256:1b07204a219b3b7350abaae088f451860223a52cfb8a6c53358e7948735158e5", size = 11109071, upload-time = "2025-09-29T23:32:27.484Z" }, + { url = "https://files.pythonhosted.org/packages/89/9c/0e21c895c38a157e0faa1fb64587a9226d6dd46452cac4532d80c3c4a244/pandas-2.3.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:2462b1a365b6109d275250baaae7b760fd25c726aaca0054649286bcfbb3e8ec", size = 12048504, upload-time = "2025-09-29T23:29:31.47Z" }, + { url = "https://files.pythonhosted.org/packages/d7/82/b69a1c95df796858777b68fbe6a81d37443a33319761d7c652ce77797475/pandas-2.3.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:0242fe9a49aa8b4d78a4fa03acb397a58833ef6199e9aa40a95f027bb3a1b6e7", size = 11410702, upload-time = "2025-09-29T23:29:54.591Z" }, + { url = "https://files.pythonhosted.org/packages/f9/88/702bde3ba0a94b8c73a0181e05144b10f13f29ebfc2150c3a79062a8195d/pandas-2.3.3-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a21d830e78df0a515db2b3d2f5570610f5e6bd2e27749770e8bb7b524b89b450", size = 11634535, upload-time = "2025-09-29T23:30:21.003Z" }, + { url = "https://files.pythonhosted.org/packages/a4/1e/1bac1a839d12e6a82ec6cb40cda2edde64a2013a66963293696bbf31fbbb/pandas-2.3.3-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2e3ebdb170b5ef78f19bfb71b0dc5dc58775032361fa188e814959b74d726dd5", size = 12121582, upload-time = "2025-09-29T23:30:43.391Z" }, + { url = "https://files.pythonhosted.org/packages/44/91/483de934193e12a3b1d6ae7c8645d083ff88dec75f46e827562f1e4b4da6/pandas-2.3.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:d051c0e065b94b7a3cea50eb1ec32e912cd96dba41647eb24104b6c6c14c5788", size = 12699963, upload-time = "2025-09-29T23:31:10.009Z" }, + { url = "https://files.pythonhosted.org/packages/70/44/5191d2e4026f86a2a109053e194d3ba7a31a2d10a9c2348368c63ed4e85a/pandas-2.3.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:3869faf4bd07b3b66a9f462417d0ca3a9df29a9f6abd5d0d0dbab15dac7abe87", size = 13202175, upload-time = "2025-09-29T23:31:59.173Z" }, +] + +[[package]] +name = "parso" +version = "0.8.5" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d4/de/53e0bcf53d13e005bd8c92e7855142494f41171b34c2536b86187474184d/parso-0.8.5.tar.gz", hash = "sha256:034d7354a9a018bdce352f48b2a8a450f05e9d6ee85db84764e9b6bd96dafe5a", size = 401205, upload-time = "2025-08-23T15:15:28.028Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/16/32/f8e3c85d1d5250232a5d3477a2a28cc291968ff175caeadaf3cc19ce0e4a/parso-0.8.5-py2.py3-none-any.whl", hash = "sha256:646204b5ee239c396d040b90f9e272e9a8017c630092bf59980beb62fd033887", size = 106668, upload-time = "2025-08-23T15:15:25.663Z" }, +] + +[[package]] +name = "pexpect" +version = "4.9.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ptyprocess" }, +] +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]] +name = "pillow" +version = "12.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/5a/b0/cace85a1b0c9775a9f8f5d5423c8261c858760e2466c79b2dd184638b056/pillow-12.0.0.tar.gz", hash = "sha256:87d4f8125c9988bfbed67af47dd7a953e2fc7b0cc1e7800ec6d2080d490bb353", size = 47008828, upload-time = "2025-10-15T18:24:14.008Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2c/90/4fcce2c22caf044e660a198d740e7fbc14395619e3cb1abad12192c0826c/pillow-12.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:53561a4ddc36facb432fae7a9d8afbfaf94795414f5cdc5fc52f28c1dca90371", size = 5249377, upload-time = "2025-10-15T18:22:05.993Z" }, + { url = "https://files.pythonhosted.org/packages/fd/e0/ed960067543d080691d47d6938ebccbf3976a931c9567ab2fbfab983a5dd/pillow-12.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:71db6b4c1653045dacc1585c1b0d184004f0d7e694c7b34ac165ca70c0838082", size = 4650343, upload-time = "2025-10-15T18:22:07.718Z" }, + { url = "https://files.pythonhosted.org/packages/e7/a1/f81fdeddcb99c044bf7d6faa47e12850f13cee0849537a7d27eeab5534d4/pillow-12.0.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:2fa5f0b6716fc88f11380b88b31fe591a06c6315e955c096c35715788b339e3f", size = 6232981, upload-time = "2025-10-15T18:22:09.287Z" }, + { url = "https://files.pythonhosted.org/packages/88/e1/9098d3ce341a8750b55b0e00c03f1630d6178f38ac191c81c97a3b047b44/pillow-12.0.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:82240051c6ca513c616f7f9da06e871f61bfd7805f566275841af15015b8f98d", size = 8041399, upload-time = "2025-10-15T18:22:10.872Z" }, + { url = "https://files.pythonhosted.org/packages/a7/62/a22e8d3b602ae8cc01446d0c57a54e982737f44b6f2e1e019a925143771d/pillow-12.0.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:55f818bd74fe2f11d4d7cbc65880a843c4075e0ac7226bc1a23261dbea531953", size = 6347740, upload-time = "2025-10-15T18:22:12.769Z" }, + { url = "https://files.pythonhosted.org/packages/4f/87/424511bdcd02c8d7acf9f65caa09f291a519b16bd83c3fb3374b3d4ae951/pillow-12.0.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b87843e225e74576437fd5b6a4c2205d422754f84a06942cfaf1dc32243e45a8", size = 7040201, upload-time = "2025-10-15T18:22:14.813Z" }, + { url = "https://files.pythonhosted.org/packages/dc/4d/435c8ac688c54d11755aedfdd9f29c9eeddf68d150fe42d1d3dbd2365149/pillow-12.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:c607c90ba67533e1b2355b821fef6764d1dd2cbe26b8c1005ae84f7aea25ff79", size = 6462334, upload-time = "2025-10-15T18:22:16.375Z" }, + { url = "https://files.pythonhosted.org/packages/2b/f2/ad34167a8059a59b8ad10bc5c72d4d9b35acc6b7c0877af8ac885b5f2044/pillow-12.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:21f241bdd5080a15bc86d3466a9f6074a9c2c2b314100dd896ac81ee6db2f1ba", size = 7134162, upload-time = "2025-10-15T18:22:17.996Z" }, + { url = "https://files.pythonhosted.org/packages/0c/b1/a7391df6adacf0a5c2cf6ac1cf1fcc1369e7d439d28f637a847f8803beb3/pillow-12.0.0-cp312-cp312-win32.whl", hash = "sha256:dd333073e0cacdc3089525c7df7d39b211bcdf31fc2824e49d01c6b6187b07d0", size = 6298769, upload-time = "2025-10-15T18:22:19.923Z" }, + { url = "https://files.pythonhosted.org/packages/a2/0b/d87733741526541c909bbf159e338dcace4f982daac6e5a8d6be225ca32d/pillow-12.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:9fe611163f6303d1619bbcb653540a4d60f9e55e622d60a3108be0d5b441017a", size = 7001107, upload-time = "2025-10-15T18:22:21.644Z" }, + { url = "https://files.pythonhosted.org/packages/bc/96/aaa61ce33cc98421fb6088af2a03be4157b1e7e0e87087c888e2370a7f45/pillow-12.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:7dfb439562f234f7d57b1ac6bc8fe7f838a4bd49c79230e0f6a1da93e82f1fad", size = 2436012, upload-time = "2025-10-15T18:22:23.621Z" }, + { url = "https://files.pythonhosted.org/packages/62/f2/de993bb2d21b33a98d031ecf6a978e4b61da207bef02f7b43093774c480d/pillow-12.0.0-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:0869154a2d0546545cde61d1789a6524319fc1897d9ee31218eae7a60ccc5643", size = 4045493, upload-time = "2025-10-15T18:22:25.758Z" }, + { url = "https://files.pythonhosted.org/packages/0e/b6/bc8d0c4c9f6f111a783d045310945deb769b806d7574764234ffd50bc5ea/pillow-12.0.0-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:a7921c5a6d31b3d756ec980f2f47c0cfdbce0fc48c22a39347a895f41f4a6ea4", size = 4120461, upload-time = "2025-10-15T18:22:27.286Z" }, + { url = "https://files.pythonhosted.org/packages/5d/57/d60d343709366a353dc56adb4ee1e7d8a2cc34e3fbc22905f4167cfec119/pillow-12.0.0-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:1ee80a59f6ce048ae13cda1abf7fbd2a34ab9ee7d401c46be3ca685d1999a399", size = 3576912, upload-time = "2025-10-15T18:22:28.751Z" }, + { url = "https://files.pythonhosted.org/packages/a4/a4/a0a31467e3f83b94d37568294b01d22b43ae3c5d85f2811769b9c66389dd/pillow-12.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:c50f36a62a22d350c96e49ad02d0da41dbd17ddc2e29750dbdba4323f85eb4a5", size = 5249132, upload-time = "2025-10-15T18:22:30.641Z" }, + { url = "https://files.pythonhosted.org/packages/83/06/48eab21dd561de2914242711434c0c0eb992ed08ff3f6107a5f44527f5e9/pillow-12.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:5193fde9a5f23c331ea26d0cf171fbf67e3f247585f50c08b3e205c7aeb4589b", size = 4650099, upload-time = "2025-10-15T18:22:32.73Z" }, + { url = "https://files.pythonhosted.org/packages/fc/bd/69ed99fd46a8dba7c1887156d3572fe4484e3f031405fcc5a92e31c04035/pillow-12.0.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:bde737cff1a975b70652b62d626f7785e0480918dece11e8fef3c0cf057351c3", size = 6230808, upload-time = "2025-10-15T18:22:34.337Z" }, + { url = "https://files.pythonhosted.org/packages/ea/94/8fad659bcdbf86ed70099cb60ae40be6acca434bbc8c4c0d4ef356d7e0de/pillow-12.0.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a6597ff2b61d121172f5844b53f21467f7082f5fb385a9a29c01414463f93b07", size = 8037804, upload-time = "2025-10-15T18:22:36.402Z" }, + { url = "https://files.pythonhosted.org/packages/20/39/c685d05c06deecfd4e2d1950e9a908aa2ca8bc4e6c3b12d93b9cafbd7837/pillow-12.0.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0b817e7035ea7f6b942c13aa03bb554fc44fea70838ea21f8eb31c638326584e", size = 6345553, upload-time = "2025-10-15T18:22:38.066Z" }, + { url = "https://files.pythonhosted.org/packages/38/57/755dbd06530a27a5ed74f8cb0a7a44a21722ebf318edbe67ddbd7fb28f88/pillow-12.0.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f4f1231b7dec408e8670264ce63e9c71409d9583dd21d32c163e25213ee2a344", size = 7037729, upload-time = "2025-10-15T18:22:39.769Z" }, + { url = "https://files.pythonhosted.org/packages/ca/b6/7e94f4c41d238615674d06ed677c14883103dce1c52e4af16f000338cfd7/pillow-12.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:6e51b71417049ad6ab14c49608b4a24d8fb3fe605e5dfabfe523b58064dc3d27", size = 6459789, upload-time = "2025-10-15T18:22:41.437Z" }, + { url = "https://files.pythonhosted.org/packages/9c/14/4448bb0b5e0f22dd865290536d20ec8a23b64e2d04280b89139f09a36bb6/pillow-12.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:d120c38a42c234dc9a8c5de7ceaaf899cf33561956acb4941653f8bdc657aa79", size = 7130917, upload-time = "2025-10-15T18:22:43.152Z" }, + { url = "https://files.pythonhosted.org/packages/dd/ca/16c6926cc1c015845745d5c16c9358e24282f1e588237a4c36d2b30f182f/pillow-12.0.0-cp313-cp313-win32.whl", hash = "sha256:4cc6b3b2efff105c6a1656cfe59da4fdde2cda9af1c5e0b58529b24525d0a098", size = 6302391, upload-time = "2025-10-15T18:22:44.753Z" }, + { url = "https://files.pythonhosted.org/packages/6d/2a/dd43dcfd6dae9b6a49ee28a8eedb98c7d5ff2de94a5d834565164667b97b/pillow-12.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:4cf7fed4b4580601c4345ceb5d4cbf5a980d030fd5ad07c4d2ec589f95f09905", size = 7007477, upload-time = "2025-10-15T18:22:46.838Z" }, + { url = "https://files.pythonhosted.org/packages/77/f0/72ea067f4b5ae5ead653053212af05ce3705807906ba3f3e8f58ddf617e6/pillow-12.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:9f0b04c6b8584c2c193babcccc908b38ed29524b29dd464bc8801bf10d746a3a", size = 2435918, upload-time = "2025-10-15T18:22:48.399Z" }, + { url = "https://files.pythonhosted.org/packages/f5/5e/9046b423735c21f0487ea6cb5b10f89ea8f8dfbe32576fe052b5ba9d4e5b/pillow-12.0.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:7fa22993bac7b77b78cae22bad1e2a987ddf0d9015c63358032f84a53f23cdc3", size = 5251406, upload-time = "2025-10-15T18:22:49.905Z" }, + { url = "https://files.pythonhosted.org/packages/12/66/982ceebcdb13c97270ef7a56c3969635b4ee7cd45227fa707c94719229c5/pillow-12.0.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:f135c702ac42262573fe9714dfe99c944b4ba307af5eb507abef1667e2cbbced", size = 4653218, upload-time = "2025-10-15T18:22:51.587Z" }, + { url = "https://files.pythonhosted.org/packages/16/b3/81e625524688c31859450119bf12674619429cab3119eec0e30a7a1029cb/pillow-12.0.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:c85de1136429c524e55cfa4e033b4a7940ac5c8ee4d9401cc2d1bf48154bbc7b", size = 6266564, upload-time = "2025-10-15T18:22:53.215Z" }, + { url = "https://files.pythonhosted.org/packages/98/59/dfb38f2a41240d2408096e1a76c671d0a105a4a8471b1871c6902719450c/pillow-12.0.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:38df9b4bfd3db902c9c2bd369bcacaf9d935b2fff73709429d95cc41554f7b3d", size = 8069260, upload-time = "2025-10-15T18:22:54.933Z" }, + { url = "https://files.pythonhosted.org/packages/dc/3d/378dbea5cd1874b94c312425ca77b0f47776c78e0df2df751b820c8c1d6c/pillow-12.0.0-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7d87ef5795da03d742bf49439f9ca4d027cde49c82c5371ba52464aee266699a", size = 6379248, upload-time = "2025-10-15T18:22:56.605Z" }, + { url = "https://files.pythonhosted.org/packages/84/b0/d525ef47d71590f1621510327acec75ae58c721dc071b17d8d652ca494d8/pillow-12.0.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:aff9e4d82d082ff9513bdd6acd4f5bd359f5b2c870907d2b0a9c5e10d40c88fe", size = 7066043, upload-time = "2025-10-15T18:22:58.53Z" }, + { url = "https://files.pythonhosted.org/packages/61/2c/aced60e9cf9d0cde341d54bf7932c9ffc33ddb4a1595798b3a5150c7ec4e/pillow-12.0.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:8d8ca2b210ada074d57fcee40c30446c9562e542fc46aedc19baf758a93532ee", size = 6490915, upload-time = "2025-10-15T18:23:00.582Z" }, + { url = "https://files.pythonhosted.org/packages/ef/26/69dcb9b91f4e59f8f34b2332a4a0a951b44f547c4ed39d3e4dcfcff48f89/pillow-12.0.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:99a7f72fb6249302aa62245680754862a44179b545ded638cf1fef59befb57ef", size = 7157998, upload-time = "2025-10-15T18:23:02.627Z" }, + { url = "https://files.pythonhosted.org/packages/61/2b/726235842220ca95fa441ddf55dd2382b52ab5b8d9c0596fe6b3f23dafe8/pillow-12.0.0-cp313-cp313t-win32.whl", hash = "sha256:4078242472387600b2ce8d93ade8899c12bf33fa89e55ec89fe126e9d6d5d9e9", size = 6306201, upload-time = "2025-10-15T18:23:04.709Z" }, + { url = "https://files.pythonhosted.org/packages/c0/3d/2afaf4e840b2df71344ababf2f8edd75a705ce500e5dc1e7227808312ae1/pillow-12.0.0-cp313-cp313t-win_amd64.whl", hash = "sha256:2c54c1a783d6d60595d3514f0efe9b37c8808746a66920315bfd34a938d7994b", size = 7013165, upload-time = "2025-10-15T18:23:06.46Z" }, + { url = "https://files.pythonhosted.org/packages/6f/75/3fa09aa5cf6ed04bee3fa575798ddf1ce0bace8edb47249c798077a81f7f/pillow-12.0.0-cp313-cp313t-win_arm64.whl", hash = "sha256:26d9f7d2b604cd23aba3e9faf795787456ac25634d82cd060556998e39c6fa47", size = 2437834, upload-time = "2025-10-15T18:23:08.194Z" }, + { url = "https://files.pythonhosted.org/packages/54/2a/9a8c6ba2c2c07b71bec92cf63e03370ca5e5f5c5b119b742bcc0cde3f9c5/pillow-12.0.0-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:beeae3f27f62308f1ddbcfb0690bf44b10732f2ef43758f169d5e9303165d3f9", size = 4045531, upload-time = "2025-10-15T18:23:10.121Z" }, + { url = "https://files.pythonhosted.org/packages/84/54/836fdbf1bfb3d66a59f0189ff0b9f5f666cee09c6188309300df04ad71fa/pillow-12.0.0-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:d4827615da15cd59784ce39d3388275ec093ae3ee8d7f0c089b76fa87af756c2", size = 4120554, upload-time = "2025-10-15T18:23:12.14Z" }, + { url = "https://files.pythonhosted.org/packages/0d/cd/16aec9f0da4793e98e6b54778a5fbce4f375c6646fe662e80600b8797379/pillow-12.0.0-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:3e42edad50b6909089750e65c91aa09aaf1e0a71310d383f11321b27c224ed8a", size = 3576812, upload-time = "2025-10-15T18:23:13.962Z" }, + { url = "https://files.pythonhosted.org/packages/f6/b7/13957fda356dc46339298b351cae0d327704986337c3c69bb54628c88155/pillow-12.0.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:e5d8efac84c9afcb40914ab49ba063d94f5dbdf5066db4482c66a992f47a3a3b", size = 5252689, upload-time = "2025-10-15T18:23:15.562Z" }, + { url = "https://files.pythonhosted.org/packages/fc/f5/eae31a306341d8f331f43edb2e9122c7661b975433de5e447939ae61c5da/pillow-12.0.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:266cd5f2b63ff316d5a1bba46268e603c9caf5606d44f38c2873c380950576ad", size = 4650186, upload-time = "2025-10-15T18:23:17.379Z" }, + { url = "https://files.pythonhosted.org/packages/86/62/2a88339aa40c4c77e79108facbd307d6091e2c0eb5b8d3cf4977cfca2fe6/pillow-12.0.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:58eea5ebe51504057dd95c5b77d21700b77615ab0243d8152793dc00eb4faf01", size = 6230308, upload-time = "2025-10-15T18:23:18.971Z" }, + { url = "https://files.pythonhosted.org/packages/c7/33/5425a8992bcb32d1cb9fa3dd39a89e613d09a22f2c8083b7bf43c455f760/pillow-12.0.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f13711b1a5ba512d647a0e4ba79280d3a9a045aaf7e0cc6fbe96b91d4cdf6b0c", size = 8039222, upload-time = "2025-10-15T18:23:20.909Z" }, + { url = "https://files.pythonhosted.org/packages/d8/61/3f5d3b35c5728f37953d3eec5b5f3e77111949523bd2dd7f31a851e50690/pillow-12.0.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6846bd2d116ff42cba6b646edf5bf61d37e5cbd256425fa089fee4ff5c07a99e", size = 6346657, upload-time = "2025-10-15T18:23:23.077Z" }, + { url = "https://files.pythonhosted.org/packages/3a/be/ee90a3d79271227e0f0a33c453531efd6ed14b2e708596ba5dd9be948da3/pillow-12.0.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c98fa880d695de164b4135a52fd2e9cd7b7c90a9d8ac5e9e443a24a95ef9248e", size = 7038482, upload-time = "2025-10-15T18:23:25.005Z" }, + { url = "https://files.pythonhosted.org/packages/44/34/a16b6a4d1ad727de390e9bd9f19f5f669e079e5826ec0f329010ddea492f/pillow-12.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:fa3ed2a29a9e9d2d488b4da81dcb54720ac3104a20bf0bd273f1e4648aff5af9", size = 6461416, upload-time = "2025-10-15T18:23:27.009Z" }, + { url = "https://files.pythonhosted.org/packages/b6/39/1aa5850d2ade7d7ba9f54e4e4c17077244ff7a2d9e25998c38a29749eb3f/pillow-12.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:d034140032870024e6b9892c692fe2968493790dd57208b2c37e3fb35f6df3ab", size = 7131584, upload-time = "2025-10-15T18:23:29.752Z" }, + { url = "https://files.pythonhosted.org/packages/bf/db/4fae862f8fad0167073a7733973bfa955f47e2cac3dc3e3e6257d10fab4a/pillow-12.0.0-cp314-cp314-win32.whl", hash = "sha256:1b1b133e6e16105f524a8dec491e0586d072948ce15c9b914e41cdadd209052b", size = 6400621, upload-time = "2025-10-15T18:23:32.06Z" }, + { url = "https://files.pythonhosted.org/packages/2b/24/b350c31543fb0107ab2599464d7e28e6f856027aadda995022e695313d94/pillow-12.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:8dc232e39d409036af549c86f24aed8273a40ffa459981146829a324e0848b4b", size = 7142916, upload-time = "2025-10-15T18:23:34.71Z" }, + { url = "https://files.pythonhosted.org/packages/0f/9b/0ba5a6fd9351793996ef7487c4fdbde8d3f5f75dbedc093bb598648fddf0/pillow-12.0.0-cp314-cp314-win_arm64.whl", hash = "sha256:d52610d51e265a51518692045e372a4c363056130d922a7351429ac9f27e70b0", size = 2523836, upload-time = "2025-10-15T18:23:36.967Z" }, + { url = "https://files.pythonhosted.org/packages/f5/7a/ceee0840aebc579af529b523d530840338ecf63992395842e54edc805987/pillow-12.0.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:1979f4566bb96c1e50a62d9831e2ea2d1211761e5662afc545fa766f996632f6", size = 5255092, upload-time = "2025-10-15T18:23:38.573Z" }, + { url = "https://files.pythonhosted.org/packages/44/76/20776057b4bfd1aef4eeca992ebde0f53a4dce874f3ae693d0ec90a4f79b/pillow-12.0.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b2e4b27a6e15b04832fe9bf292b94b5ca156016bbc1ea9c2c20098a0320d6cf6", size = 4653158, upload-time = "2025-10-15T18:23:40.238Z" }, + { url = "https://files.pythonhosted.org/packages/82/3f/d9ff92ace07be8836b4e7e87e6a4c7a8318d47c2f1463ffcf121fc57d9cb/pillow-12.0.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:fb3096c30df99fd01c7bf8e544f392103d0795b9f98ba71a8054bcbf56b255f1", size = 6267882, upload-time = "2025-10-15T18:23:42.434Z" }, + { url = "https://files.pythonhosted.org/packages/9f/7a/4f7ff87f00d3ad33ba21af78bfcd2f032107710baf8280e3722ceec28cda/pillow-12.0.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7438839e9e053ef79f7112c881cef684013855016f928b168b81ed5835f3e75e", size = 8071001, upload-time = "2025-10-15T18:23:44.29Z" }, + { url = "https://files.pythonhosted.org/packages/75/87/fcea108944a52dad8cca0715ae6247e271eb80459364a98518f1e4f480c1/pillow-12.0.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5d5c411a8eaa2299322b647cd932586b1427367fd3184ffbb8f7a219ea2041ca", size = 6380146, upload-time = "2025-10-15T18:23:46.065Z" }, + { url = "https://files.pythonhosted.org/packages/91/52/0d31b5e571ef5fd111d2978b84603fce26aba1b6092f28e941cb46570745/pillow-12.0.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d7e091d464ac59d2c7ad8e7e08105eaf9dafbc3883fd7265ffccc2baad6ac925", size = 7067344, upload-time = "2025-10-15T18:23:47.898Z" }, + { url = "https://files.pythonhosted.org/packages/7b/f4/2dd3d721f875f928d48e83bb30a434dee75a2531bca839bb996bb0aa5a91/pillow-12.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:792a2c0be4dcc18af9d4a2dfd8a11a17d5e25274a1062b0ec1c2d79c76f3e7f8", size = 6491864, upload-time = "2025-10-15T18:23:49.607Z" }, + { url = "https://files.pythonhosted.org/packages/30/4b/667dfcf3d61fc309ba5a15b141845cece5915e39b99c1ceab0f34bf1d124/pillow-12.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:afbefa430092f71a9593a99ab6a4e7538bc9eabbf7bf94f91510d3503943edc4", size = 7158911, upload-time = "2025-10-15T18:23:51.351Z" }, + { url = "https://files.pythonhosted.org/packages/a2/2f/16cabcc6426c32218ace36bf0d55955e813f2958afddbf1d391849fee9d1/pillow-12.0.0-cp314-cp314t-win32.whl", hash = "sha256:3830c769decf88f1289680a59d4f4c46c72573446352e2befec9a8512104fa52", size = 6408045, upload-time = "2025-10-15T18:23:53.177Z" }, + { url = "https://files.pythonhosted.org/packages/35/73/e29aa0c9c666cf787628d3f0dcf379f4791fba79f4936d02f8b37165bdf8/pillow-12.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:905b0365b210c73afb0ebe9101a32572152dfd1c144c7e28968a331b9217b94a", size = 7148282, upload-time = "2025-10-15T18:23:55.316Z" }, + { url = "https://files.pythonhosted.org/packages/c1/70/6b41bdcddf541b437bbb9f47f94d2db5d9ddef6c37ccab8c9107743748a4/pillow-12.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:99353a06902c2e43b43e8ff74ee65a7d90307d82370604746738a1e0661ccca7", size = 2525630, upload-time = "2025-10-15T18:23:57.149Z" }, +] + +[[package]] +name = "platformdirs" +version = "4.5.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/61/33/9611380c2bdb1225fdef633e2a9610622310fed35ab11dac9620972ee088/platformdirs-4.5.0.tar.gz", hash = "sha256:70ddccdd7c99fc5942e9fc25636a8b34d04c24b335100223152c2803e4063312", size = 21632, upload-time = "2025-10-08T17:44:48.791Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/73/cb/ac7874b3e5d58441674fb70742e6c374b28b0c7cb988d37d991cde47166c/platformdirs-4.5.0-py3-none-any.whl", hash = "sha256:e578a81bb873cbb89a41fcc904c7ef523cc18284b7e3b3ccf06aca1403b7ebd3", size = 18651, upload-time = "2025-10-08T17:44:47.223Z" }, +] + +[[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 = "psutil" +version = "7.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b3/31/4723d756b59344b643542936e37a31d1d3204bcdc42a7daa8ee9eb06fb50/psutil-7.1.0.tar.gz", hash = "sha256:655708b3c069387c8b77b072fc429a57d0e214221d01c0a772df7dfedcb3bcd2", size = 497660, upload-time = "2025-09-17T20:14:52.902Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/46/62/ce4051019ee20ce0ed74432dd73a5bb087a6704284a470bb8adff69a0932/psutil-7.1.0-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:76168cef4397494250e9f4e73eb3752b146de1dd950040b29186d0cce1d5ca13", size = 245242, upload-time = "2025-09-17T20:14:56.126Z" }, + { url = "https://files.pythonhosted.org/packages/38/61/f76959fba841bf5b61123fbf4b650886dc4094c6858008b5bf73d9057216/psutil-7.1.0-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:5d007560c8c372efdff9e4579c2846d71de737e4605f611437255e81efcca2c5", size = 246682, upload-time = "2025-09-17T20:14:58.25Z" }, + { url = "https://files.pythonhosted.org/packages/88/7a/37c99d2e77ec30d63398ffa6a660450b8a62517cabe44b3e9bae97696e8d/psutil-7.1.0-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:22e4454970b32472ce7deaa45d045b34d3648ce478e26a04c7e858a0a6e75ff3", size = 287994, upload-time = "2025-09-17T20:14:59.901Z" }, + { url = "https://files.pythonhosted.org/packages/9d/de/04c8c61232f7244aa0a4b9a9fbd63a89d5aeaf94b2fc9d1d16e2faa5cbb0/psutil-7.1.0-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8c70e113920d51e89f212dd7be06219a9b88014e63a4cec69b684c327bc474e3", size = 291163, upload-time = "2025-09-17T20:15:01.481Z" }, + { url = "https://files.pythonhosted.org/packages/f4/58/c4f976234bf6d4737bc8c02a81192f045c307b72cf39c9e5c5a2d78927f6/psutil-7.1.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7d4a113425c037300de3ac8b331637293da9be9713855c4fc9d2d97436d7259d", size = 293625, upload-time = "2025-09-17T20:15:04.492Z" }, + { url = "https://files.pythonhosted.org/packages/79/87/157c8e7959ec39ced1b11cc93c730c4fb7f9d408569a6c59dbd92ceb35db/psutil-7.1.0-cp37-abi3-win32.whl", hash = "sha256:09ad740870c8d219ed8daae0ad3b726d3bf9a028a198e7f3080f6a1888b99bca", size = 244812, upload-time = "2025-09-17T20:15:07.462Z" }, + { url = "https://files.pythonhosted.org/packages/bf/e9/b44c4f697276a7a95b8e94d0e320a7bf7f3318521b23de69035540b39838/psutil-7.1.0-cp37-abi3-win_amd64.whl", hash = "sha256:57f5e987c36d3146c0dd2528cd42151cf96cd359b9d67cfff836995cc5df9a3d", size = 247965, upload-time = "2025-09-17T20:15:09.673Z" }, + { url = "https://files.pythonhosted.org/packages/26/65/1070a6e3c036f39142c2820c4b52e9243246fcfc3f96239ac84472ba361e/psutil-7.1.0-cp37-abi3-win_arm64.whl", hash = "sha256:6937cb68133e7c97b6cc9649a570c9a18ba0efebed46d8c5dae4c07fa1b67a07", size = 244971, upload-time = "2025-09-17T20:15:12.262Z" }, +] + +[[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 = "2.23" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/fe/cf/d2d3b9f5699fb1e4615c8e32ff220203e43b248e1dfcc6736ad9057731ca/pycparser-2.23.tar.gz", hash = "sha256:78816d4f24add8f10a06d6f05b4d424ad9e96cfebf68a4ddc99c65c0720d00c2", size = 173734, upload-time = "2025-09-09T13:23:47.91Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a0/e3/59cd50310fc9b59512193629e1984c1f95e5c8ae6e5d8c69532ccc65a7fe/pycparser-2.23-py3-none-any.whl", hash = "sha256:e5c6e8d3fbad53479cab09ac03729e0a9faf2bee3db8208a550daf5af81a5934", size = 118140, upload-time = "2025-09-09T13:23:46.651Z" }, +] + +[[package]] +name = "pygments" +version = "2.19.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b0/77/a5b8c569bf593b0140bde72ea885a803b82086995367bf2037de0159d924/pygments-2.19.2.tar.gz", hash = "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887", size = 4968631, upload-time = "2025-06-21T13:39:12.283Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217, upload-time = "2025-06-21T13:39:07.939Z" }, +] + +[[package]] +name = "pyparsing" +version = "3.2.5" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f2/a5/181488fc2b9d093e3972d2a472855aae8a03f000592dbfce716a512b3359/pyparsing-3.2.5.tar.gz", hash = "sha256:2df8d5b7b2802ef88e8d016a2eb9c7aeaa923529cd251ed0fe4608275d4105b6", size = 1099274, upload-time = "2025-09-21T04:11:06.277Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/10/5e/1aa9a93198c6b64513c9d7752de7422c06402de6600a8767da1524f9570b/pyparsing-3.2.5-py3-none-any.whl", hash = "sha256:e38a4f02064cf41fe6593d328d0512495ad1f3d8a91c4f73fc401b3079a59a5e", size = 113890, upload-time = "2025-09-21T04:11:04.117Z" }, +] + +[[package]] +name = "python-dateutil" +version = "2.9.0.post0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "six" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432, upload-time = "2024-03-01T18:36:20.211Z" } +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 = "pytz" +version = "2025.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f8/bf/abbd3cdfb8fbc7fb3d4d38d320f2441b1e7cbe29be4f23797b4a2b5d8aac/pytz-2025.2.tar.gz", hash = "sha256:360b9e3dbb49a209c21ad61809c7fb453643e048b38924c765813546746e81c3", size = 320884, upload-time = "2025-03-25T02:25:00.538Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/81/c4/34e93fe5f5429d7570ec1fa436f1986fb1f00c3e0f43a589fe2bbcd22c3f/pytz-2025.2-py2.py3-none-any.whl", hash = "sha256:5ddf76296dd8c44c26eb8f4b6f35488f3ccbf6fbbd7adee0b7262d43f0ec2f00", size = 509225, upload-time = "2025-03-25T02:24:58.468Z" }, +] + +[[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 = "seaborn" +version = "0.13.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "matplotlib" }, + { name = "numpy" }, + { name = "pandas" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/86/59/a451d7420a77ab0b98f7affa3a1d78a313d2f7281a57afb1a34bae8ab412/seaborn-0.13.2.tar.gz", hash = "sha256:93e60a40988f4d65e9f4885df477e2fdaff6b73a9ded434c1ab356dd57eefff7", size = 1457696, upload-time = "2024-01-25T13:21:52.551Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/83/11/00d3c3dfc25ad54e731d91449895a79e4bf2384dc3ac01809010ba88f6d5/seaborn-0.13.2-py3-none-any.whl", hash = "sha256:636f8336facf092165e27924f223d3c62ca560b1f2bb5dff7ab7fad265361987", size = 294914, upload-time = "2024-01-25T13:21:49.598Z" }, +] + +[[package]] +name = "six" +version = "1.17.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031, upload-time = "2024-12-04T17:35:28.174Z" } +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 = "tornado" +version = "6.5.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/09/ce/1eb500eae19f4648281bb2186927bb062d2438c2e5093d1360391afd2f90/tornado-6.5.2.tar.gz", hash = "sha256:ab53c8f9a0fa351e2c0741284e06c7a45da86afb544133201c5cc8578eb076a0", size = 510821, upload-time = "2025-08-08T18:27:00.78Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f6/48/6a7529df2c9cc12efd2e8f5dd219516184d703b34c06786809670df5b3bd/tornado-6.5.2-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:2436822940d37cde62771cff8774f4f00b3c8024fe482e16ca8387b8a2724db6", size = 442563, upload-time = "2025-08-08T18:26:42.945Z" }, + { url = "https://files.pythonhosted.org/packages/f2/b5/9b575a0ed3e50b00c40b08cbce82eb618229091d09f6d14bce80fc01cb0b/tornado-6.5.2-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:583a52c7aa94ee046854ba81d9ebb6c81ec0fd30386d96f7640c96dad45a03ef", size = 440729, upload-time = "2025-08-08T18:26:44.473Z" }, + { url = "https://files.pythonhosted.org/packages/1b/4e/619174f52b120efcf23633c817fd3fed867c30bff785e2cd5a53a70e483c/tornado-6.5.2-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b0fe179f28d597deab2842b86ed4060deec7388f1fd9c1b4a41adf8af058907e", size = 444295, upload-time = "2025-08-08T18:26:46.021Z" }, + { url = "https://files.pythonhosted.org/packages/95/fa/87b41709552bbd393c85dd18e4e3499dcd8983f66e7972926db8d96aa065/tornado-6.5.2-cp39-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b186e85d1e3536d69583d2298423744740986018e393d0321df7340e71898882", size = 443644, upload-time = "2025-08-08T18:26:47.625Z" }, + { url = "https://files.pythonhosted.org/packages/f9/41/fb15f06e33d7430ca89420283a8762a4e6b8025b800ea51796ab5e6d9559/tornado-6.5.2-cp39-abi3-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e792706668c87709709c18b353da1f7662317b563ff69f00bab83595940c7108", size = 443878, upload-time = "2025-08-08T18:26:50.599Z" }, + { url = "https://files.pythonhosted.org/packages/11/92/fe6d57da897776ad2e01e279170ea8ae726755b045fe5ac73b75357a5a3f/tornado-6.5.2-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:06ceb1300fd70cb20e43b1ad8aaee0266e69e7ced38fa910ad2e03285009ce7c", size = 444549, upload-time = "2025-08-08T18:26:51.864Z" }, + { url = "https://files.pythonhosted.org/packages/9b/02/c8f4f6c9204526daf3d760f4aa555a7a33ad0e60843eac025ccfd6ff4a93/tornado-6.5.2-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:74db443e0f5251be86cbf37929f84d8c20c27a355dd452a5cfa2aada0d001ec4", size = 443973, upload-time = "2025-08-08T18:26:53.625Z" }, + { url = "https://files.pythonhosted.org/packages/ae/2d/f5f5707b655ce2317190183868cd0f6822a1121b4baeae509ceb9590d0bd/tornado-6.5.2-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:b5e735ab2889d7ed33b32a459cac490eda71a1ba6857b0118de476ab6c366c04", size = 443954, upload-time = "2025-08-08T18:26:55.072Z" }, + { url = "https://files.pythonhosted.org/packages/e8/59/593bd0f40f7355806bf6573b47b8c22f8e1374c9b6fd03114bd6b7a3dcfd/tornado-6.5.2-cp39-abi3-win32.whl", hash = "sha256:c6f29e94d9b37a95013bb669616352ddb82e3bfe8326fccee50583caebc8a5f0", size = 445023, upload-time = "2025-08-08T18:26:56.677Z" }, + { url = "https://files.pythonhosted.org/packages/c7/2a/f609b420c2f564a748a2d80ebfb2ee02a73ca80223af712fca591386cafb/tornado-6.5.2-cp39-abi3-win_amd64.whl", hash = "sha256:e56a5af51cc30dd2cae649429af65ca2f6571da29504a07995175df14c18f35f", size = 445427, upload-time = "2025-08-08T18:26:57.91Z" }, + { url = "https://files.pythonhosted.org/packages/5e/4f/e1f65e8f8c76d73658b33d33b81eed4322fb5085350e4328d5c956f0c8f9/tornado-6.5.2-cp39-abi3-win_arm64.whl", hash = "sha256:d6c33dc3672e3a1f3618eb63b7ef4683a7688e7b9e6e8f0d9aa5726360a004af", size = 444456, upload-time = "2025-08-08T18:26:59.207Z" }, +] + +[[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 = "tzdata" +version = "2025.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/95/32/1a225d6164441be760d75c2c42e2780dc0873fe382da3e98a2e1e48361e5/tzdata-2025.2.tar.gz", hash = "sha256:b60a638fcc0daffadf82fe0f57e53d06bdec2f36c4df66280ae79bce6bd6f2b9", size = 196380, upload-time = "2025-03-23T13:54:43.652Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5c/23/c7abc0ca0a1526a0774eca151daeb8de62ec457e77262b66b359c3c7679e/tzdata-2025.2-py2.py3-none-any.whl", hash = "sha256:1a403fada01ff9221ca8044d701868fa132215d84beb92242d9acd2147f667a8", size = 347839, upload-time = "2025-03-23T13:54:41.845Z" }, +] + +[[package]] +name = "wcwidth" +version = "0.2.14" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/24/30/6b0809f4510673dc723187aeaf24c7f5459922d01e2f794277a3dfb90345/wcwidth-0.2.14.tar.gz", hash = "sha256:4d478375d31bc5395a3c55c40ccdf3354688364cd61c4f6adacaa9215d0b3605", size = 102293, upload-time = "2025-09-22T16:29:53.023Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/af/b5/123f13c975e9f27ab9c0770f514345bd406d0e8d3b7a0723af9d43f710af/wcwidth-0.2.14-py2.py3-none-any.whl", hash = "sha256:a7bb560c8aee30f9957e5f9895805edd20602f2d7f720186dfd906e82b4982e1", size = 37286, upload-time = "2025-09-22T16:29:51.641Z" }, +]