From b4bfef24406a94eaf747287be56cbb9d66d535f9 Mon Sep 17 00:00:00 2001 From: Andrei Chernov Date: Sun, 2 Nov 2025 15:31:05 +0100 Subject: [PATCH 01/10] added new model and new erro contract --- examples/flowstate_simple_example.ipynb | 150 +++-- examples/generate_data.py | 268 ++++++++ ..._forecast_model_name_model_version_post.py | 605 ++++++++++++++---- .../api/health/health_check_health_get.py | 10 +- faim_client/client.py | 18 +- faim_client/models/__init__.py | 12 +- faim_client/models/error_code.py | 34 + faim_client/models/error_response.py | 70 +- faim_client/models/http_validation_error.py | 75 +++ faim_client/models/model_name.py | 3 +- faim_client/models/validation_error.py | 88 +++ faim_client/types.py | 12 +- faim_sdk/__init__.py | 20 +- faim_sdk/client.py | 276 +++++--- faim_sdk/exceptions.py | 122 +++- faim_sdk/models.py | 83 ++- scripts/regenerate_client.sh | 162 +++++ 17 files changed, 1650 insertions(+), 358 deletions(-) create mode 100644 examples/generate_data.py create mode 100644 faim_client/models/error_code.py create mode 100644 faim_client/models/http_validation_error.py create mode 100644 faim_client/models/validation_error.py create mode 100755 scripts/regenerate_client.sh diff --git a/examples/flowstate_simple_example.ipynb b/examples/flowstate_simple_example.ipynb index 7f7850c..a0fff6a 100644 --- a/examples/flowstate_simple_example.ipynb +++ b/examples/flowstate_simple_example.ipynb @@ -16,8 +16,8 @@ "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2025-10-30T16:19:55.580574Z", - "start_time": "2025-10-30T16:19:55.572729Z" + "end_time": "2025-11-02T13:09:29.782458Z", + "start_time": "2025-11-02T13:09:29.780008Z" } }, "source": [ @@ -25,14 +25,14 @@ "# !pip install numpy pandas matplotlib statsmodels" ], "outputs": [], - "execution_count": 60 + "execution_count": 1 }, { "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2025-10-30T16:19:55.594776Z", - "start_time": "2025-10-30T16:19:55.592104Z" + "end_time": "2025-11-02T13:09:30.664688Z", + "start_time": "2025-11-02T13:09:29.885721Z" } }, "source": [ @@ -48,7 +48,7 @@ "from faim_sdk import FlowStateForecastRequest, ForecastClient" ], "outputs": [], - "execution_count": 61 + "execution_count": 2 }, { "cell_type": "markdown", @@ -59,8 +59,8 @@ "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2025-10-30T16:19:55.637833Z", - "start_time": "2025-10-30T16:19:55.620782Z" + "end_time": "2025-11-02T13:09:31.749271Z", + "start_time": "2025-11-02T13:09:30.681133Z" } }, "source": [ @@ -106,14 +106,14 @@ ] } ], - "execution_count": 62 + "execution_count": 3 }, { "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2025-10-30T16:19:55.666166Z", - "start_time": "2025-10-30T16:19:55.660954Z" + "end_time": "2025-11-02T13:09:31.764649Z", + "start_time": "2025-11-02T13:09:31.759429Z" } }, "source": [ @@ -184,19 +184,19 @@ "" ] }, - "execution_count": 63, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], - "execution_count": 63 + "execution_count": 4 }, { "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2025-10-30T16:19:55.729968Z", - "start_time": "2025-10-30T16:19:55.716535Z" + "end_time": "2025-11-02T13:09:31.803405Z", + "start_time": "2025-11-02T13:09:31.796959Z" } }, "source": [ @@ -227,7 +227,7 @@ ] } ], - "execution_count": 64 + "execution_count": 5 }, { "cell_type": "markdown", @@ -240,8 +240,8 @@ "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2025-10-30T16:19:55.994396Z", - "start_time": "2025-10-30T16:19:55.906651Z" + "end_time": "2025-11-02T13:09:31.971193Z", + "start_time": "2025-11-02T13:09:31.871029Z" } }, "source": [ @@ -284,14 +284,14 @@ "output_type": "display_data" } ], - "execution_count": 65 + "execution_count": 6 }, { "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2025-10-30T16:19:56.025546Z", - "start_time": "2025-10-30T16:19:56.022577Z" + "end_time": "2025-11-02T13:09:31.986196Z", + "start_time": "2025-11-02T13:09:31.983898Z" } }, "source": [ @@ -326,7 +326,7 @@ ] } ], - "execution_count": 66 + "execution_count": 7 }, { "cell_type": "markdown", @@ -337,12 +337,24 @@ "**Note**: Replace `base_url` with your actual FAIM inference API endpoint." ] }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-11-02T13:09:32.012024Z", + "start_time": "2025-11-02T13:09:32.010425Z" + } + }, + "cell_type": "code", + "source": "", + "outputs": [], + "execution_count": null + }, { "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2025-10-30T16:19:56.053034Z", - "start_time": "2025-10-30T16:19:56.043036Z" + "end_time": "2025-11-02T13:09:32.047796Z", + "start_time": "2025-11-02T13:09:32.044621Z" } }, "source": [ @@ -351,7 +363,8 @@ "# BASE_URL = \"http://localhost:8003\" # Example: \"https://api.faim.example.com\"\n", "# BASE_URL = (\"http://34.141.187.117\") # Example: \"https://api.faim.example.com\"\n", "BASE_URL = (\"https://api.faim.it.com\") # Example: \"https://api.faim.example.com\"\n", - "FAIM_API_KEY = os.environ[\"FAIM_API_KEY\"] # \"your-secret-api-key\"\n", + "# FAIM_API_KEY = os.environ[\"FAIM_API_KEY\"] # \"your-secret-api-key\"\n", + "FAIM_API_KEY = \"api_key_1_28bbe832-bbb3-4444-83bd-06d8615bffbb_6hCNkGmAy4TUgcXD8s71t9ALz39CIxJKksHRKBU-dzM\"\n", "client = ForecastClient(\n", " base_url=BASE_URL,\n", " api_key=FAIM_API_KEY, # Optional: API key for authentication\n", @@ -367,13 +380,6 @@ " assert False, 'you need to set up your API key'" ], "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:faim_sdk.client:Initialized ForecastClient with authentication: base_url=https://api.faim.it.com, timeout=60.0s\n" - ] - }, { "name": "stdout", "output_type": "stream", @@ -383,24 +389,47 @@ ] } ], - "execution_count": 67 + "execution_count": 8 }, { "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2025-10-30T16:19:56.105543Z", - "start_time": "2025-10-30T16:19:56.099754Z" + "end_time": "2025-11-02T13:09:32.064134Z", + "start_time": "2025-11-02T13:09:32.062414Z" } }, "source": [ "import logging\n", "\n", "# Enable debug logging\n", - "logging.basicConfig(level=logging.DEBUG)\n" + "# logging.basicConfig(level=logging.DEBUG)\n" ], "outputs": [], - "execution_count": 68 + "execution_count": 9 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-11-02T13:09:32.077835Z", + "start_time": "2025-11-02T13:09:32.075596Z" + } + }, + "cell_type": "code", + "source": "x.shape", + "outputs": [ + { + "data": { + "text/plain": [ + "(1, 250, 1)" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 10 }, { "cell_type": "markdown", @@ -411,8 +440,8 @@ "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2025-10-30T16:19:56.133897Z", - "start_time": "2025-10-30T16:19:56.131085Z" + "end_time": "2025-11-02T13:09:32.091706Z", + "start_time": "2025-11-02T13:09:32.088676Z" } }, "source": [ @@ -445,7 +474,7 @@ ] } ], - "execution_count": 69 + "execution_count": 11 }, { "cell_type": "markdown", @@ -458,8 +487,8 @@ "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2025-10-30T16:19:58.648828Z", - "start_time": "2025-10-30T16:19:56.151677Z" + "end_time": "2025-11-02T13:09:32.883338Z", + "start_time": "2025-11-02T13:09:32.114395Z" } }, "source": [ @@ -488,50 +517,33 @@ "name": "stderr", "output_type": "stream", "text": [ - "DEBUG:faim_sdk.client:Starting forecast: model=flowstate, version=1, x.shape=(1, 250, 1), horizon=20\n", - "DEBUG:faim_sdk.client:Serialized request: 1520 bytes, metadata={'horizon': 20, 'output_type': 'point', 'scale_factor': 0.65, 'prediction_type': 'mean'}\n", - "DEBUG:httpcore.connection:connect_tcp.started host='api.faim.it.com' port=443 local_address=None timeout=60.0 socket_options=None\n", - "DEBUG:httpcore.connection:connect_tcp.complete return_value=\n", - "DEBUG:httpcore.connection:start_tls.started ssl_context= server_hostname='api.faim.it.com' timeout=60.0\n", - "DEBUG:httpcore.connection:start_tls.complete return_value=\n", - "DEBUG:httpcore.http11:send_request_headers.started request=\n", - "DEBUG:httpcore.http11:send_request_headers.complete\n", - "DEBUG:httpcore.http11:send_request_body.started request=\n", - "DEBUG:httpcore.http11:send_request_body.complete\n", - "DEBUG:httpcore.http11:receive_response_headers.started request=\n", - "DEBUG:httpcore.http11:receive_response_headers.complete return_value=(b'HTTP/1.1', 401, b'Unauthorized', [(b'date', b'Thu, 30 Oct 2025 16:19:57 GMT'), (b'server', b'uvicorn'), (b'Content-Length', b'74'), (b'content-type', b'application/json'), (b'Via', b'1.1 google'), (b'Alt-Svc', b'h3=\":443\"; ma=2592000,h3-29=\":443\"; ma=2592000')])\n", - "INFO:httpx:HTTP Request: POST https://api.faim.it.com/v1/ts/forecast/flowstate/1 \"HTTP/1.1 401 Unauthorized\"\n", - "DEBUG:httpcore.http11:receive_response_body.started request=\n", - "DEBUG:httpcore.http11:receive_response_body.complete\n", - "DEBUG:httpcore.http11:response_closed.started\n", - "DEBUG:httpcore.http11:response_closed.complete\n", - "ERROR:faim_sdk.client:Unexpected status code: 401\n" + "API error: status=401, code=INVALID_API_KEY, message=API key not found or inactive, request_id=\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "✗ Forecast failed: Unexpected status code: 401 | status=401\n", + "✗ Forecast failed: API key not found or inactive | status=401 | error_code=INVALID_API_KEY\n", "\n", - "Error type: APIError\n", + "Error type: AuthenticationError\n", "Details: {}\n" ] }, { - "ename": "APIError", - "evalue": "Unexpected status code: 401 | status=401", + "ename": "AuthenticationError", + "evalue": "API key not found or inactive | status=401 | error_code=INVALID_API_KEY", "output_type": "error", "traceback": [ "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m", - "\u001B[0;31mAPIError\u001B[0m Traceback (most recent call last)", - "Cell \u001B[0;32mIn[70], line 3\u001B[0m\n\u001B[1;32m 1\u001B[0m \u001B[38;5;28;01mtry\u001B[39;00m:\n\u001B[1;32m 2\u001B[0m \u001B[38;5;66;03m# Make forecast request\u001B[39;00m\n\u001B[0;32m----> 3\u001B[0m response \u001B[38;5;241m=\u001B[39m \u001B[43mclient\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mforecast\u001B[49m\u001B[43m(\u001B[49m\u001B[43mModelName\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mFLOWSTATE\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mrequest\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 5\u001B[0m \u001B[38;5;28mprint\u001B[39m(\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124m✓ Forecast successful!\u001B[39m\u001B[38;5;124m\"\u001B[39m)\n\u001B[1;32m 6\u001B[0m \u001B[38;5;28mprint\u001B[39m(\u001B[38;5;124mf\u001B[39m\u001B[38;5;124m\"\u001B[39m\u001B[38;5;130;01m\\n\u001B[39;00m\u001B[38;5;124mResponse: \u001B[39m\u001B[38;5;132;01m{\u001B[39;00mresponse\u001B[38;5;132;01m}\u001B[39;00m\u001B[38;5;124m\"\u001B[39m)\n", - "File \u001B[0;32m~/Documents/Personal/research/FAIM/faim-client/faim_sdk/client.py:225\u001B[0m, in \u001B[0;36mForecastClient.forecast\u001B[0;34m(self, model, request)\u001B[0m\n\u001B[1;32m 223\u001B[0m \u001B[38;5;28;01melif\u001B[39;00m response\u001B[38;5;241m.\u001B[39mstatus_code \u001B[38;5;241m!=\u001B[39m \u001B[38;5;241m200\u001B[39m:\n\u001B[1;32m 224\u001B[0m logger\u001B[38;5;241m.\u001B[39merror(\u001B[38;5;124mf\u001B[39m\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mUnexpected status code: \u001B[39m\u001B[38;5;132;01m{\u001B[39;00mresponse\u001B[38;5;241m.\u001B[39mstatus_code\u001B[38;5;132;01m}\u001B[39;00m\u001B[38;5;124m\"\u001B[39m)\n\u001B[0;32m--> 225\u001B[0m \u001B[38;5;28;01mraise\u001B[39;00m APIError(\n\u001B[1;32m 226\u001B[0m \u001B[38;5;124mf\u001B[39m\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mUnexpected status code: \u001B[39m\u001B[38;5;132;01m{\u001B[39;00mresponse\u001B[38;5;241m.\u001B[39mstatus_code\u001B[38;5;132;01m}\u001B[39;00m\u001B[38;5;124m\"\u001B[39m,\n\u001B[1;32m 227\u001B[0m status_code\u001B[38;5;241m=\u001B[39mresponse\u001B[38;5;241m.\u001B[39mstatus_code,\n\u001B[1;32m 228\u001B[0m response\u001B[38;5;241m=\u001B[39mresponse\u001B[38;5;241m.\u001B[39mparsed \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;28mhasattr\u001B[39m(response, \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mparsed\u001B[39m\u001B[38;5;124m\"\u001B[39m) \u001B[38;5;28;01melse\u001B[39;00m \u001B[38;5;28;01mNone\u001B[39;00m,\n\u001B[1;32m 229\u001B[0m )\n\u001B[1;32m 231\u001B[0m \u001B[38;5;66;03m# Deserialize successful response\u001B[39;00m\n\u001B[1;32m 232\u001B[0m \u001B[38;5;28;01mtry\u001B[39;00m:\n", - "\u001B[0;31mAPIError\u001B[0m: Unexpected status code: 401 | status=401" + "\u001B[0;31mAuthenticationError\u001B[0m Traceback (most recent call last)", + "Cell \u001B[0;32mIn[12], line 3\u001B[0m\n\u001B[1;32m 1\u001B[0m \u001B[38;5;28;01mtry\u001B[39;00m:\n\u001B[1;32m 2\u001B[0m \u001B[38;5;66;03m# Make forecast request\u001B[39;00m\n\u001B[0;32m----> 3\u001B[0m response \u001B[38;5;241m=\u001B[39m \u001B[43mclient\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mforecast\u001B[49m\u001B[43m(\u001B[49m\u001B[43mModelName\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mFLOWSTATE\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mrequest\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 5\u001B[0m \u001B[38;5;28mprint\u001B[39m(\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124m✓ Forecast successful!\u001B[39m\u001B[38;5;124m\"\u001B[39m)\n\u001B[1;32m 6\u001B[0m \u001B[38;5;28mprint\u001B[39m(\u001B[38;5;124mf\u001B[39m\u001B[38;5;124m\"\u001B[39m\u001B[38;5;130;01m\\n\u001B[39;00m\u001B[38;5;124mResponse: \u001B[39m\u001B[38;5;132;01m{\u001B[39;00mresponse\u001B[38;5;132;01m}\u001B[39;00m\u001B[38;5;124m\"\u001B[39m)\n", + "File \u001B[0;32m~/Documents/Personal/research/FAIM/faim-client/faim_sdk/client.py:247\u001B[0m, in \u001B[0;36mForecastClient.forecast\u001B[0;34m(self, model, request)\u001B[0m\n\u001B[1;32m 245\u001B[0m \u001B[38;5;66;03m# Map HTTP status code to exception class\u001B[39;00m\n\u001B[1;32m 246\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m response\u001B[38;5;241m.\u001B[39mstatus_code \u001B[38;5;129;01min\u001B[39;00m (\u001B[38;5;241m401\u001B[39m, \u001B[38;5;241m403\u001B[39m):\n\u001B[0;32m--> 247\u001B[0m \u001B[38;5;28;01mraise\u001B[39;00m AuthenticationError(\n\u001B[1;32m 248\u001B[0m message\u001B[38;5;241m=\u001B[39mmessage,\n\u001B[1;32m 249\u001B[0m status_code\u001B[38;5;241m=\u001B[39mresponse\u001B[38;5;241m.\u001B[39mstatus_code,\n\u001B[1;32m 250\u001B[0m error_response\u001B[38;5;241m=\u001B[39merror_response,\n\u001B[1;32m 251\u001B[0m )\n\u001B[1;32m 252\u001B[0m \u001B[38;5;28;01melif\u001B[39;00m response\u001B[38;5;241m.\u001B[39mstatus_code \u001B[38;5;241m==\u001B[39m \u001B[38;5;241m402\u001B[39m:\n\u001B[1;32m 253\u001B[0m \u001B[38;5;28;01mraise\u001B[39;00m InsufficientFundsError(\n\u001B[1;32m 254\u001B[0m message\u001B[38;5;241m=\u001B[39mmessage,\n\u001B[1;32m 255\u001B[0m status_code\u001B[38;5;241m=\u001B[39mresponse\u001B[38;5;241m.\u001B[39mstatus_code,\n\u001B[1;32m 256\u001B[0m error_response\u001B[38;5;241m=\u001B[39merror_response,\n\u001B[1;32m 257\u001B[0m )\n", + "\u001B[0;31mAuthenticationError\u001B[0m: API key not found or inactive | status=401 | error_code=INVALID_API_KEY" ] } ], - "execution_count": 70 + "execution_count": 12 }, { "cell_type": "markdown", diff --git a/examples/generate_data.py b/examples/generate_data.py new file mode 100644 index 0000000..fe9240d --- /dev/null +++ b/examples/generate_data.py @@ -0,0 +1,268 @@ +""" +Synthetic time series data generation for FAIM SDK examples. + +This module provides functions to generate synthetic time series data with clear patterns +for testing and demonstrating forecasting capabilities. +""" + +import numpy as np +from typing import Tuple + + +def generate_linear_trend_series( + batch_size: int = 1, + context_length: int = 256, + trend_slope: float = 0.05, + noise_std: float = 0.5, + seed: int | None = None +) -> np.ndarray: + """ + Generate simple time series with linear trend and Gaussian noise. + + Pattern: y(t) = trend_slope * t + noise + This creates an easily forecastable upward or downward trend. + + Args: + batch_size: Number of independent time series to generate + context_length: Length of each time series + trend_slope: Slope of the linear trend (positive for upward, negative for downward) + noise_std: Standard deviation of Gaussian noise + seed: Random seed for reproducibility + + Returns: + np.ndarray: Shape (batch_size, context_length, 1) + """ + if seed is not None: + np.random.seed(seed) + + # Generate time indices + t = np.arange(context_length) + + # Create linear trend + trend = trend_slope * t + + # Add Gaussian noise + noise = np.random.normal(0, noise_std, size=(batch_size, context_length)) + + # Combine trend and noise + series = trend[np.newaxis, :] + noise + + # Reshape to (batch_size, context_length, 1) + return series[:, :, np.newaxis] + + +def generate_correlated_multi_series( + batch_size: int = 1, + context_length: int = 256, + correlation: float = 0.8, + seasonal_period: int = 24, + seasonal_amplitude: float = 2.0, + trend_slope: float = 0.02, + noise_std: float = 0.3, + seed: int | None = None +) -> np.ndarray: + """ + Generate two correlated time series with seasonal patterns. + + Pattern: + - Series 1: trend + seasonality + noise + - Series 2: correlation * Series1 + (1-correlation) * independent_pattern + noise + + This creates two related time series where forecasting one can help predict the other. + + Args: + batch_size: Number of independent time series pairs to generate + context_length: Length of each time series + correlation: Correlation coefficient between the two series (0 to 1) + seasonal_period: Period of seasonal component (e.g., 24 for daily pattern) + seasonal_amplitude: Amplitude of seasonal oscillation + trend_slope: Slope of the linear trend + noise_std: Standard deviation of Gaussian noise + seed: Random seed for reproducibility + + Returns: + np.ndarray: Shape (batch_size, context_length, 2) - two correlated features + """ + if seed is not None: + np.random.seed(seed) + + # Generate time indices + t = np.arange(context_length) + + # Create shared components + trend = trend_slope * t + seasonal = seasonal_amplitude * np.sin(2 * np.pi * t / seasonal_period) + + # Generate first series + series1_base = trend + seasonal + noise1 = np.random.normal(0, noise_std, size=(batch_size, context_length)) + series1 = series1_base[np.newaxis, :] + noise1 + + # Generate second series correlated with first + # Create independent pattern for mixing + independent_seasonal = seasonal_amplitude * np.cos(2 * np.pi * t / (seasonal_period * 1.5)) + independent_base = trend * 0.8 + independent_seasonal + noise2 = np.random.normal(0, noise_std, size=(batch_size, context_length)) + + # Mix correlated and independent components + series2 = ( + correlation * series1 + + (1 - correlation) * (independent_base[np.newaxis, :] + noise2) + ) + + # Stack into (batch_size, context_length, 2) + multi_series = np.stack([series1, series2], axis=-1) + + return multi_series + + +def generate_heavy_payload( + batch_size: int = 100, + context_length: int = 2048, + num_features: int = 1, + pattern_type: str = "mixed", + noise_std: float = 0.4, + seed: int | None = None +) -> np.ndarray: + """ + Generate large batch of time series for stress testing and performance evaluation. + + Pattern options: + - "mixed": Combination of trends, seasonality, and cyclic patterns + - "seasonal": Pure seasonal patterns with varying periods + - "trend": Linear trends with varying slopes + + Args: + batch_size: Number of independent time series (default 100 for heavy load) + context_length: Length of each time series (default 2048 for long sequences) + num_features: Number of features per time step + pattern_type: Type of pattern to generate ("mixed", "seasonal", or "trend") + noise_std: Standard deviation of Gaussian noise + seed: Random seed for reproducibility + + Returns: + np.ndarray: Shape (batch_size, context_length, num_features) + """ + if seed is not None: + np.random.seed(seed) + + # Generate time indices + t = np.arange(context_length) + + # Initialize output array + series = np.zeros((batch_size, context_length, num_features)) + + for i in range(batch_size): + for f in range(num_features): + if pattern_type == "mixed": + # Combine trend, multiple seasonal components, and noise + trend = (0.01 + 0.02 * np.random.rand()) * t + + # Primary seasonal component + period1 = 100 + np.random.randint(-20, 20) + amp1 = 1.0 + 2.0 * np.random.rand() + seasonal1 = amp1 * np.sin(2 * np.pi * t / period1 + 2 * np.pi * np.random.rand()) + + # Secondary seasonal component + period2 = 500 + np.random.randint(-100, 100) + amp2 = 0.5 + 1.0 * np.random.rand() + seasonal2 = amp2 * np.cos(2 * np.pi * t / period2 + 2 * np.pi * np.random.rand()) + + # Combine components + base = trend + seasonal1 + seasonal2 + + elif pattern_type == "seasonal": + # Pure seasonal patterns with varying periods + period = 50 + np.random.randint(0, 200) + amplitude = 1.0 + 3.0 * np.random.rand() + phase = 2 * np.pi * np.random.rand() + base = amplitude * np.sin(2 * np.pi * t / period + phase) + + elif pattern_type == "trend": + # Linear trends with varying slopes and intercepts + slope = -0.05 + 0.1 * np.random.rand() + intercept = -5.0 + 10.0 * np.random.rand() + base = slope * t + intercept + + else: + raise ValueError(f"Unknown pattern_type: {pattern_type}") + + # Add Gaussian noise + noise = np.random.normal(0, noise_std, size=context_length) + + # Assign to output array + series[i, :, f] = base + noise + + return series + + +def generate_test_suite(seed: int = 42) -> dict[str, np.ndarray]: + """ + Generate a complete test suite with all data patterns. + + Args: + seed: Random seed for reproducibility + + Returns: + dict: Dictionary containing all generated datasets with descriptive keys + """ + return { + # Simple patterns + "linear_trend_single": generate_linear_trend_series( + batch_size=1, context_length=256, seed=seed + ), + "linear_trend_batch": generate_linear_trend_series( + batch_size=16, context_length=256, seed=seed + ), + + # Correlated multi-series + "correlated_multi_single": generate_correlated_multi_series( + batch_size=1, context_length=256, seed=seed + ), + "correlated_multi_batch": generate_correlated_multi_series( + batch_size=16, context_length=256, seed=seed + ), + + # Heavy payloads + "heavy_mixed": generate_heavy_payload( + batch_size=100, context_length=2048, pattern_type="mixed", seed=seed + ), + "heavy_seasonal": generate_heavy_payload( + batch_size=100, context_length=2048, pattern_type="seasonal", seed=seed + ), + "heavy_trend": generate_heavy_payload( + batch_size=100, context_length=2048, pattern_type="trend", seed=seed + ), + } + + +if __name__ == "__main__": + # Example usage and validation + print("Generating synthetic time series data...\n") + + # Test linear trend series + linear_data = generate_linear_trend_series(batch_size=5, context_length=100, seed=42) + print(f"Linear trend series shape: {linear_data.shape}") + print(f" Expected: (5, 100, 1)") + print(f" Min: {linear_data.min():.2f}, Max: {linear_data.max():.2f}, Mean: {linear_data.mean():.2f}\n") + + # Test correlated multi-series + multi_data = generate_correlated_multi_series(batch_size=3, context_length=100, seed=42) + print(f"Correlated multi-series shape: {multi_data.shape}") + print(f" Expected: (3, 100, 2)") + # Calculate correlation between the two series + corr = np.corrcoef(multi_data[0, :, 0], multi_data[0, :, 1])[0, 1] + print(f" Correlation between series: {corr:.2f}\n") + + # Test heavy payload + heavy_data = generate_heavy_payload(batch_size=100, context_length=2048, seed=42) + print(f"Heavy payload shape: {heavy_data.shape}") + print(f" Expected: (100, 2048, 1)") + print(f" Memory size: {heavy_data.nbytes / 1024 / 1024:.2f} MB\n") + + # Generate full test suite + print("Generating full test suite...") + test_suite = generate_test_suite(seed=42) + print(f"Generated {len(test_suite)} datasets:") + for name, data in test_suite.items(): + print(f" {name}: {data.shape}") \ No newline at end of file diff --git a/faim_client/api/forecast/forecast_v1_ts_forecast_model_name_model_version_post.py b/faim_client/api/forecast/forecast_v1_ts_forecast_model_name_model_version_post.py index 656976a..972c118 100644 --- a/faim_client/api/forecast/forecast_v1_ts_forecast_model_name_model_version_post.py +++ b/faim_client/api/forecast/forecast_v1_ts_forecast_model_name_model_version_post.py @@ -1,11 +1,12 @@ from http import HTTPStatus from io import BytesIO -from typing import Any, cast +from typing import Any, Optional, Union import httpx from ... import errors from ...client import AuthenticatedClient, Client +from ...models.error_response import ErrorResponse from ...models.model_name import ModelName from ...types import File, Response @@ -32,33 +33,53 @@ def _get_kwargs( def _parse_response( - *, client: AuthenticatedClient | Client, response: httpx.Response -) -> Any | File | None: + *, client: Union[AuthenticatedClient, Client], response: httpx.Response +) -> Optional[Union[ErrorResponse, File]]: if response.status_code == 200: response_200 = File(payload=BytesIO(response.content)) return response_200 if response.status_code == 401: - response_401 = cast(Any, None) + response_401 = ErrorResponse.from_dict(response.json()) + return response_401 + if response.status_code == 402: + response_402 = ErrorResponse.from_dict(response.json()) + + return response_402 + if response.status_code == 404: - response_404 = cast(Any, None) + response_404 = ErrorResponse.from_dict(response.json()) + return response_404 if response.status_code == 413: - response_413 = cast(Any, None) + response_413 = ErrorResponse.from_dict(response.json()) + return response_413 if response.status_code == 422: - response_422 = cast(Any, None) + response_422 = ErrorResponse.from_dict(response.json()) + return response_422 if response.status_code == 500: - response_500 = cast(Any, None) + response_500 = ErrorResponse.from_dict(response.json()) + return response_500 + if response.status_code == 503: + response_503 = ErrorResponse.from_dict(response.json()) + + return response_503 + + if response.status_code == 504: + response_504 = ErrorResponse.from_dict(response.json()) + + return response_504 + if client.raise_on_unexpected_status: raise errors.UnexpectedStatus(response.status_code, response.content) else: @@ -66,8 +87,8 @@ def _parse_response( def _build_response( - *, client: AuthenticatedClient | Client, response: httpx.Response -) -> Response[Any | File]: + *, client: Union[AuthenticatedClient, Client], response: httpx.Response +) -> Response[Union[ErrorResponse, File]]: return Response( status_code=HTTPStatus(response.status_code), content=response.content, @@ -80,37 +101,128 @@ def sync_detailed( model_name: ModelName, model_version: str, *, - client: AuthenticatedClient | Client, + client: Union[AuthenticatedClient, Client], body: File, -) -> Response[Any | File]: - r"""Generate model forecast +) -> Response[Union[ErrorResponse, File]]: + r"""Generate time series forecast Generate time series forecasts using the specified Triton model. - **Authentication**: Requires valid API key in Authorization header as `Bearer ` + ## Authentication + Requires valid API key in Authorization header as `Bearer ` + - API keys can be created via `/v1/user/api-keys/create` endpoint + - Keys must follow the format: `sk--` + - Invalid or expired keys return 401 INVALID_API_KEY - **Request Format**: Apache Arrow IPC Stream (`application/vnd.apache.arrow.stream`) + ## Request Format + Apache Arrow IPC Stream (`application/vnd.apache.arrow.stream`) - Large arrays (x, padding_mask, etc.) sent as Arrow columns - Small parameters (horizon, quantiles, etc.) sent in schema metadata - - **Required Inputs**: - - `x`: Time series data (numpy array) - - `horizon`: Forecast horizon length (integer, in metadata) - - `output_type`: Output type - \"point\", \"quantiles\", or \"samples\" (string, in metadata) - - **Model-Specific Inputs**: - - *FlowState*: - - `scale_factor` (optional): Scaling factor (float) - - `prediction_type` (optional): Prediction type (string) - - *ToTo*: - - `padding_mask`: Mask for padded values (numpy array) - - `id_mask`: Identifier mask (numpy array) - - `num_samples` (optional): Number of samples (integer) - - `quantiles` (optional): Quantile levels (list of floats) - - **Response**: Arrow IPC stream with predictions and metadata + - Request timeout: 20 seconds (configurable on server) + - Maximum request size: 100MB (configurable on server) + + ## Required Inputs + - `x`: Time series data (numpy array, 1D or 2D) + - `horizon`: Forecast horizon length (integer, positive, in metadata) + - `output_type`: Output type (string, in metadata) + - Valid values: `\"point\"`, `\"quantiles\"`, `\"samples\"` + - Determines output format in response + + ## Model-Specific Inputs + + ### FlowState Model + - `scale_factor` (float, optional): Scaling factor for input time series (default: None) + - `prediction_type` (string, optional): Type of prediction (default: None) + + ### Chronos2 Model + - `quantiles` (float array, optional): Quantile levels for quantiles output (list of floats, + 0.0-1.0) + + ### TiRex Model + + ## Response Format + Successful responses return Apache Arrow IPC stream with: + + ### Common Response Metadata (All Models) + - `model_name` (string): Name of model used + - `model_version` (string): Version of model used + - `transaction_id` (string): Unique identifier for billing tracking + - `cost_amount` (string): Amount charged for this inference (in currency units) + - `cost_currency` (string): Currency code (e.g., \"USD\") + + ### Response Output Arrays by Model & output_type + + **FlowState:** + - `output_type=\"point\"`: Single point forecast array (shape: batch x horizon) + - `output_type=\"quantiles\"`: Quantile forecasts array (shape: batch x horizon x num_quantiles) + + **Chronos2:** + - `output_type=\"point\"`: Point forecast array (shape: batch x horizon) + - `output_type=\"quantiles\"`: Quantile predictions array (shape: batch x horizon x + num_quantiles) + + **TiRex:** + - `output_type=\"point\"`: Point forecast array (shape: batch x horizon) + - `output_type=\"quantiles\"`: Quantile predictions array (shape: batch x horizon x + num_quantiles) + + ## Error Handling + All errors return `ErrorResponse` (HTTP JSON) with: + - `error_code`: Machine-readable code for programmatic handling (see ErrorCode enum) + - `message`: Human-readable error message + - `detail`: Optional detailed explanation + - `request_id`: Request identifier for debugging + + ### Error Categories + + **Authentication & Authorization (401, 403)** + - AUTHENTICATION_REQUIRED: Missing or malformed Authorization header + - AUTHENTICATION_FAILED: Bearer format invalid + - INVALID_API_KEY: API key not found, expired, or revoked + - AUTHORIZATION_FAILED: Valid credentials but insufficient permissions + + **Validation Errors (422)** + - MISSING_REQUIRED_FIELD: Required input missing (x, horizon, output_type) + - INVALID_PARAMETER: Parameter out of valid range or invalid type + - INVALID_SHAPE: Input tensor shape incompatible with model + - INVALID_DTYPE: Input data type incorrect for model + - INVALID_VALUE_RANGE: Input values outside acceptable range + - VALIDATION_ERROR: Invalid Arrow format or other validation failure + + **Resource Errors (404, 402)** + - MODEL_NOT_FOUND: Model or version doesn't exist + - PRICING_NOT_FOUND: Pricing configuration missing for model/version + - INSUFFICIENT_FUNDS: User billing account balance insufficient + - REQUEST_TOO_LARGE: Request payload exceeds 100MB limit + + **Inference Errors (500, 503, 504)** + - INFERENCE_ERROR: Model inference failed (check detail for reason) + - TIMEOUT_ERROR: Inference exceeded 20 second deadline + - OUT_OF_MEMORY: GPU/CPU memory exhausted during inference + - RESOURCE_EXHAUSTED: Compute resources temporarily unavailable + - MODEL_INITIALIZATION_ERROR: Model failed to load or initialize + + **System Errors (500, 503)** + - TRITON_CONNECTION_ERROR: Cannot connect to Triton server + - DATABASE_ERROR: Database operation failed + - INTERNAL_SERVER_ERROR: Unexpected server error + - BILLING_TRANSACTION_FAILED: Billing system error (insufficient funds, etc.) + + ### Retry Strategy + **Retryable Errors** (transient, safe to retry with exponential backoff): + - TIMEOUT_ERROR (504): Retry after 2-5 seconds + - OUT_OF_MEMORY (503): Retry after 5-10 seconds or reduce batch size + - RESOURCE_EXHAUSTED (503): Retry after 5-10 seconds + - TRITON_CONNECTION_ERROR (503): Retry after 5-10 seconds + - DATABASE_ERROR (500): Retry after 2-5 seconds + + **Non-Retryable Errors** (permanent failures, don't retry): + - All 401/403 auth errors: Fix credentials and resubmit + - All 404 errors: Resource doesn't exist, fix request + - All 422 validation errors: Fix input data and resubmit + - INSUFFICIENT_FUNDS (402): Add credit to account + - REQUEST_TOO_LARGE (413): Reduce payload size + - INFERENCE_ERROR (500): Check error detail, may require model update Args: model_name (ModelName): Available model names for inference. @@ -122,7 +234,7 @@ def sync_detailed( httpx.TimeoutException: If the request takes longer than Client.timeout. Returns: - Response[Union[Any, File]] + Response[Union[ErrorResponse, File]] """ kwargs = _get_kwargs( @@ -142,37 +254,128 @@ def sync( model_name: ModelName, model_version: str, *, - client: AuthenticatedClient | Client, + client: Union[AuthenticatedClient, Client], body: File, -) -> Any | File | None: - r"""Generate model forecast +) -> Optional[Union[ErrorResponse, File]]: + r"""Generate time series forecast Generate time series forecasts using the specified Triton model. - **Authentication**: Requires valid API key in Authorization header as `Bearer ` + ## Authentication + Requires valid API key in Authorization header as `Bearer ` + - API keys can be created via `/v1/user/api-keys/create` endpoint + - Keys must follow the format: `sk--` + - Invalid or expired keys return 401 INVALID_API_KEY - **Request Format**: Apache Arrow IPC Stream (`application/vnd.apache.arrow.stream`) + ## Request Format + Apache Arrow IPC Stream (`application/vnd.apache.arrow.stream`) - Large arrays (x, padding_mask, etc.) sent as Arrow columns - Small parameters (horizon, quantiles, etc.) sent in schema metadata - - **Required Inputs**: - - `x`: Time series data (numpy array) - - `horizon`: Forecast horizon length (integer, in metadata) - - `output_type`: Output type - \"point\", \"quantiles\", or \"samples\" (string, in metadata) - - **Model-Specific Inputs**: - - *FlowState*: - - `scale_factor` (optional): Scaling factor (float) - - `prediction_type` (optional): Prediction type (string) - - *ToTo*: - - `padding_mask`: Mask for padded values (numpy array) - - `id_mask`: Identifier mask (numpy array) - - `num_samples` (optional): Number of samples (integer) - - `quantiles` (optional): Quantile levels (list of floats) - - **Response**: Arrow IPC stream with predictions and metadata + - Request timeout: 20 seconds (configurable on server) + - Maximum request size: 100MB (configurable on server) + + ## Required Inputs + - `x`: Time series data (numpy array, 1D or 2D) + - `horizon`: Forecast horizon length (integer, positive, in metadata) + - `output_type`: Output type (string, in metadata) + - Valid values: `\"point\"`, `\"quantiles\"`, `\"samples\"` + - Determines output format in response + + ## Model-Specific Inputs + + ### FlowState Model + - `scale_factor` (float, optional): Scaling factor for input time series (default: None) + - `prediction_type` (string, optional): Type of prediction (default: None) + + ### Chronos2 Model + - `quantiles` (float array, optional): Quantile levels for quantiles output (list of floats, + 0.0-1.0) + + ### TiRex Model + + ## Response Format + Successful responses return Apache Arrow IPC stream with: + + ### Common Response Metadata (All Models) + - `model_name` (string): Name of model used + - `model_version` (string): Version of model used + - `transaction_id` (string): Unique identifier for billing tracking + - `cost_amount` (string): Amount charged for this inference (in currency units) + - `cost_currency` (string): Currency code (e.g., \"USD\") + + ### Response Output Arrays by Model & output_type + + **FlowState:** + - `output_type=\"point\"`: Single point forecast array (shape: batch x horizon) + - `output_type=\"quantiles\"`: Quantile forecasts array (shape: batch x horizon x num_quantiles) + + **Chronos2:** + - `output_type=\"point\"`: Point forecast array (shape: batch x horizon) + - `output_type=\"quantiles\"`: Quantile predictions array (shape: batch x horizon x + num_quantiles) + + **TiRex:** + - `output_type=\"point\"`: Point forecast array (shape: batch x horizon) + - `output_type=\"quantiles\"`: Quantile predictions array (shape: batch x horizon x + num_quantiles) + + ## Error Handling + All errors return `ErrorResponse` (HTTP JSON) with: + - `error_code`: Machine-readable code for programmatic handling (see ErrorCode enum) + - `message`: Human-readable error message + - `detail`: Optional detailed explanation + - `request_id`: Request identifier for debugging + + ### Error Categories + + **Authentication & Authorization (401, 403)** + - AUTHENTICATION_REQUIRED: Missing or malformed Authorization header + - AUTHENTICATION_FAILED: Bearer format invalid + - INVALID_API_KEY: API key not found, expired, or revoked + - AUTHORIZATION_FAILED: Valid credentials but insufficient permissions + + **Validation Errors (422)** + - MISSING_REQUIRED_FIELD: Required input missing (x, horizon, output_type) + - INVALID_PARAMETER: Parameter out of valid range or invalid type + - INVALID_SHAPE: Input tensor shape incompatible with model + - INVALID_DTYPE: Input data type incorrect for model + - INVALID_VALUE_RANGE: Input values outside acceptable range + - VALIDATION_ERROR: Invalid Arrow format or other validation failure + + **Resource Errors (404, 402)** + - MODEL_NOT_FOUND: Model or version doesn't exist + - PRICING_NOT_FOUND: Pricing configuration missing for model/version + - INSUFFICIENT_FUNDS: User billing account balance insufficient + - REQUEST_TOO_LARGE: Request payload exceeds 100MB limit + + **Inference Errors (500, 503, 504)** + - INFERENCE_ERROR: Model inference failed (check detail for reason) + - TIMEOUT_ERROR: Inference exceeded 20 second deadline + - OUT_OF_MEMORY: GPU/CPU memory exhausted during inference + - RESOURCE_EXHAUSTED: Compute resources temporarily unavailable + - MODEL_INITIALIZATION_ERROR: Model failed to load or initialize + + **System Errors (500, 503)** + - TRITON_CONNECTION_ERROR: Cannot connect to Triton server + - DATABASE_ERROR: Database operation failed + - INTERNAL_SERVER_ERROR: Unexpected server error + - BILLING_TRANSACTION_FAILED: Billing system error (insufficient funds, etc.) + + ### Retry Strategy + **Retryable Errors** (transient, safe to retry with exponential backoff): + - TIMEOUT_ERROR (504): Retry after 2-5 seconds + - OUT_OF_MEMORY (503): Retry after 5-10 seconds or reduce batch size + - RESOURCE_EXHAUSTED (503): Retry after 5-10 seconds + - TRITON_CONNECTION_ERROR (503): Retry after 5-10 seconds + - DATABASE_ERROR (500): Retry after 2-5 seconds + + **Non-Retryable Errors** (permanent failures, don't retry): + - All 401/403 auth errors: Fix credentials and resubmit + - All 404 errors: Resource doesn't exist, fix request + - All 422 validation errors: Fix input data and resubmit + - INSUFFICIENT_FUNDS (402): Add credit to account + - REQUEST_TOO_LARGE (413): Reduce payload size + - INFERENCE_ERROR (500): Check error detail, may require model update Args: model_name (ModelName): Available model names for inference. @@ -184,7 +387,7 @@ def sync( httpx.TimeoutException: If the request takes longer than Client.timeout. Returns: - Union[Any, File] + Union[ErrorResponse, File] """ return sync_detailed( @@ -199,37 +402,128 @@ async def asyncio_detailed( model_name: ModelName, model_version: str, *, - client: AuthenticatedClient | Client, + client: Union[AuthenticatedClient, Client], body: File, -) -> Response[Any | File]: - r"""Generate model forecast +) -> Response[Union[ErrorResponse, File]]: + r"""Generate time series forecast Generate time series forecasts using the specified Triton model. - **Authentication**: Requires valid API key in Authorization header as `Bearer ` + ## Authentication + Requires valid API key in Authorization header as `Bearer ` + - API keys can be created via `/v1/user/api-keys/create` endpoint + - Keys must follow the format: `sk--` + - Invalid or expired keys return 401 INVALID_API_KEY - **Request Format**: Apache Arrow IPC Stream (`application/vnd.apache.arrow.stream`) + ## Request Format + Apache Arrow IPC Stream (`application/vnd.apache.arrow.stream`) - Large arrays (x, padding_mask, etc.) sent as Arrow columns - Small parameters (horizon, quantiles, etc.) sent in schema metadata - - **Required Inputs**: - - `x`: Time series data (numpy array) - - `horizon`: Forecast horizon length (integer, in metadata) - - `output_type`: Output type - \"point\", \"quantiles\", or \"samples\" (string, in metadata) - - **Model-Specific Inputs**: - - *FlowState*: - - `scale_factor` (optional): Scaling factor (float) - - `prediction_type` (optional): Prediction type (string) - - *ToTo*: - - `padding_mask`: Mask for padded values (numpy array) - - `id_mask`: Identifier mask (numpy array) - - `num_samples` (optional): Number of samples (integer) - - `quantiles` (optional): Quantile levels (list of floats) - - **Response**: Arrow IPC stream with predictions and metadata + - Request timeout: 20 seconds (configurable on server) + - Maximum request size: 100MB (configurable on server) + + ## Required Inputs + - `x`: Time series data (numpy array, 1D or 2D) + - `horizon`: Forecast horizon length (integer, positive, in metadata) + - `output_type`: Output type (string, in metadata) + - Valid values: `\"point\"`, `\"quantiles\"`, `\"samples\"` + - Determines output format in response + + ## Model-Specific Inputs + + ### FlowState Model + - `scale_factor` (float, optional): Scaling factor for input time series (default: None) + - `prediction_type` (string, optional): Type of prediction (default: None) + + ### Chronos2 Model + - `quantiles` (float array, optional): Quantile levels for quantiles output (list of floats, + 0.0-1.0) + + ### TiRex Model + + ## Response Format + Successful responses return Apache Arrow IPC stream with: + + ### Common Response Metadata (All Models) + - `model_name` (string): Name of model used + - `model_version` (string): Version of model used + - `transaction_id` (string): Unique identifier for billing tracking + - `cost_amount` (string): Amount charged for this inference (in currency units) + - `cost_currency` (string): Currency code (e.g., \"USD\") + + ### Response Output Arrays by Model & output_type + + **FlowState:** + - `output_type=\"point\"`: Single point forecast array (shape: batch x horizon) + - `output_type=\"quantiles\"`: Quantile forecasts array (shape: batch x horizon x num_quantiles) + + **Chronos2:** + - `output_type=\"point\"`: Point forecast array (shape: batch x horizon) + - `output_type=\"quantiles\"`: Quantile predictions array (shape: batch x horizon x + num_quantiles) + + **TiRex:** + - `output_type=\"point\"`: Point forecast array (shape: batch x horizon) + - `output_type=\"quantiles\"`: Quantile predictions array (shape: batch x horizon x + num_quantiles) + + ## Error Handling + All errors return `ErrorResponse` (HTTP JSON) with: + - `error_code`: Machine-readable code for programmatic handling (see ErrorCode enum) + - `message`: Human-readable error message + - `detail`: Optional detailed explanation + - `request_id`: Request identifier for debugging + + ### Error Categories + + **Authentication & Authorization (401, 403)** + - AUTHENTICATION_REQUIRED: Missing or malformed Authorization header + - AUTHENTICATION_FAILED: Bearer format invalid + - INVALID_API_KEY: API key not found, expired, or revoked + - AUTHORIZATION_FAILED: Valid credentials but insufficient permissions + + **Validation Errors (422)** + - MISSING_REQUIRED_FIELD: Required input missing (x, horizon, output_type) + - INVALID_PARAMETER: Parameter out of valid range or invalid type + - INVALID_SHAPE: Input tensor shape incompatible with model + - INVALID_DTYPE: Input data type incorrect for model + - INVALID_VALUE_RANGE: Input values outside acceptable range + - VALIDATION_ERROR: Invalid Arrow format or other validation failure + + **Resource Errors (404, 402)** + - MODEL_NOT_FOUND: Model or version doesn't exist + - PRICING_NOT_FOUND: Pricing configuration missing for model/version + - INSUFFICIENT_FUNDS: User billing account balance insufficient + - REQUEST_TOO_LARGE: Request payload exceeds 100MB limit + + **Inference Errors (500, 503, 504)** + - INFERENCE_ERROR: Model inference failed (check detail for reason) + - TIMEOUT_ERROR: Inference exceeded 20 second deadline + - OUT_OF_MEMORY: GPU/CPU memory exhausted during inference + - RESOURCE_EXHAUSTED: Compute resources temporarily unavailable + - MODEL_INITIALIZATION_ERROR: Model failed to load or initialize + + **System Errors (500, 503)** + - TRITON_CONNECTION_ERROR: Cannot connect to Triton server + - DATABASE_ERROR: Database operation failed + - INTERNAL_SERVER_ERROR: Unexpected server error + - BILLING_TRANSACTION_FAILED: Billing system error (insufficient funds, etc.) + + ### Retry Strategy + **Retryable Errors** (transient, safe to retry with exponential backoff): + - TIMEOUT_ERROR (504): Retry after 2-5 seconds + - OUT_OF_MEMORY (503): Retry after 5-10 seconds or reduce batch size + - RESOURCE_EXHAUSTED (503): Retry after 5-10 seconds + - TRITON_CONNECTION_ERROR (503): Retry after 5-10 seconds + - DATABASE_ERROR (500): Retry after 2-5 seconds + + **Non-Retryable Errors** (permanent failures, don't retry): + - All 401/403 auth errors: Fix credentials and resubmit + - All 404 errors: Resource doesn't exist, fix request + - All 422 validation errors: Fix input data and resubmit + - INSUFFICIENT_FUNDS (402): Add credit to account + - REQUEST_TOO_LARGE (413): Reduce payload size + - INFERENCE_ERROR (500): Check error detail, may require model update Args: model_name (ModelName): Available model names for inference. @@ -241,7 +535,7 @@ async def asyncio_detailed( httpx.TimeoutException: If the request takes longer than Client.timeout. Returns: - Response[Union[Any, File]] + Response[Union[ErrorResponse, File]] """ kwargs = _get_kwargs( @@ -259,37 +553,128 @@ async def asyncio( model_name: ModelName, model_version: str, *, - client: AuthenticatedClient | Client, + client: Union[AuthenticatedClient, Client], body: File, -) -> Any | File | None: - r"""Generate model forecast +) -> Optional[Union[ErrorResponse, File]]: + r"""Generate time series forecast Generate time series forecasts using the specified Triton model. - **Authentication**: Requires valid API key in Authorization header as `Bearer ` + ## Authentication + Requires valid API key in Authorization header as `Bearer ` + - API keys can be created via `/v1/user/api-keys/create` endpoint + - Keys must follow the format: `sk--` + - Invalid or expired keys return 401 INVALID_API_KEY - **Request Format**: Apache Arrow IPC Stream (`application/vnd.apache.arrow.stream`) + ## Request Format + Apache Arrow IPC Stream (`application/vnd.apache.arrow.stream`) - Large arrays (x, padding_mask, etc.) sent as Arrow columns - Small parameters (horizon, quantiles, etc.) sent in schema metadata - - **Required Inputs**: - - `x`: Time series data (numpy array) - - `horizon`: Forecast horizon length (integer, in metadata) - - `output_type`: Output type - \"point\", \"quantiles\", or \"samples\" (string, in metadata) - - **Model-Specific Inputs**: - - *FlowState*: - - `scale_factor` (optional): Scaling factor (float) - - `prediction_type` (optional): Prediction type (string) - - *ToTo*: - - `padding_mask`: Mask for padded values (numpy array) - - `id_mask`: Identifier mask (numpy array) - - `num_samples` (optional): Number of samples (integer) - - `quantiles` (optional): Quantile levels (list of floats) - - **Response**: Arrow IPC stream with predictions and metadata + - Request timeout: 20 seconds (configurable on server) + - Maximum request size: 100MB (configurable on server) + + ## Required Inputs + - `x`: Time series data (numpy array, 1D or 2D) + - `horizon`: Forecast horizon length (integer, positive, in metadata) + - `output_type`: Output type (string, in metadata) + - Valid values: `\"point\"`, `\"quantiles\"`, `\"samples\"` + - Determines output format in response + + ## Model-Specific Inputs + + ### FlowState Model + - `scale_factor` (float, optional): Scaling factor for input time series (default: None) + - `prediction_type` (string, optional): Type of prediction (default: None) + + ### Chronos2 Model + - `quantiles` (float array, optional): Quantile levels for quantiles output (list of floats, + 0.0-1.0) + + ### TiRex Model + + ## Response Format + Successful responses return Apache Arrow IPC stream with: + + ### Common Response Metadata (All Models) + - `model_name` (string): Name of model used + - `model_version` (string): Version of model used + - `transaction_id` (string): Unique identifier for billing tracking + - `cost_amount` (string): Amount charged for this inference (in currency units) + - `cost_currency` (string): Currency code (e.g., \"USD\") + + ### Response Output Arrays by Model & output_type + + **FlowState:** + - `output_type=\"point\"`: Single point forecast array (shape: batch x horizon) + - `output_type=\"quantiles\"`: Quantile forecasts array (shape: batch x horizon x num_quantiles) + + **Chronos2:** + - `output_type=\"point\"`: Point forecast array (shape: batch x horizon) + - `output_type=\"quantiles\"`: Quantile predictions array (shape: batch x horizon x + num_quantiles) + + **TiRex:** + - `output_type=\"point\"`: Point forecast array (shape: batch x horizon) + - `output_type=\"quantiles\"`: Quantile predictions array (shape: batch x horizon x + num_quantiles) + + ## Error Handling + All errors return `ErrorResponse` (HTTP JSON) with: + - `error_code`: Machine-readable code for programmatic handling (see ErrorCode enum) + - `message`: Human-readable error message + - `detail`: Optional detailed explanation + - `request_id`: Request identifier for debugging + + ### Error Categories + + **Authentication & Authorization (401, 403)** + - AUTHENTICATION_REQUIRED: Missing or malformed Authorization header + - AUTHENTICATION_FAILED: Bearer format invalid + - INVALID_API_KEY: API key not found, expired, or revoked + - AUTHORIZATION_FAILED: Valid credentials but insufficient permissions + + **Validation Errors (422)** + - MISSING_REQUIRED_FIELD: Required input missing (x, horizon, output_type) + - INVALID_PARAMETER: Parameter out of valid range or invalid type + - INVALID_SHAPE: Input tensor shape incompatible with model + - INVALID_DTYPE: Input data type incorrect for model + - INVALID_VALUE_RANGE: Input values outside acceptable range + - VALIDATION_ERROR: Invalid Arrow format or other validation failure + + **Resource Errors (404, 402)** + - MODEL_NOT_FOUND: Model or version doesn't exist + - PRICING_NOT_FOUND: Pricing configuration missing for model/version + - INSUFFICIENT_FUNDS: User billing account balance insufficient + - REQUEST_TOO_LARGE: Request payload exceeds 100MB limit + + **Inference Errors (500, 503, 504)** + - INFERENCE_ERROR: Model inference failed (check detail for reason) + - TIMEOUT_ERROR: Inference exceeded 20 second deadline + - OUT_OF_MEMORY: GPU/CPU memory exhausted during inference + - RESOURCE_EXHAUSTED: Compute resources temporarily unavailable + - MODEL_INITIALIZATION_ERROR: Model failed to load or initialize + + **System Errors (500, 503)** + - TRITON_CONNECTION_ERROR: Cannot connect to Triton server + - DATABASE_ERROR: Database operation failed + - INTERNAL_SERVER_ERROR: Unexpected server error + - BILLING_TRANSACTION_FAILED: Billing system error (insufficient funds, etc.) + + ### Retry Strategy + **Retryable Errors** (transient, safe to retry with exponential backoff): + - TIMEOUT_ERROR (504): Retry after 2-5 seconds + - OUT_OF_MEMORY (503): Retry after 5-10 seconds or reduce batch size + - RESOURCE_EXHAUSTED (503): Retry after 5-10 seconds + - TRITON_CONNECTION_ERROR (503): Retry after 5-10 seconds + - DATABASE_ERROR (500): Retry after 2-5 seconds + + **Non-Retryable Errors** (permanent failures, don't retry): + - All 401/403 auth errors: Fix credentials and resubmit + - All 404 errors: Resource doesn't exist, fix request + - All 422 validation errors: Fix input data and resubmit + - INSUFFICIENT_FUNDS (402): Add credit to account + - REQUEST_TOO_LARGE (413): Reduce payload size + - INFERENCE_ERROR (500): Check error detail, may require model update Args: model_name (ModelName): Available model names for inference. @@ -301,7 +686,7 @@ async def asyncio( httpx.TimeoutException: If the request takes longer than Client.timeout. Returns: - Union[Any, File] + Union[ErrorResponse, File] """ return ( diff --git a/faim_client/api/health/health_check_health_get.py b/faim_client/api/health/health_check_health_get.py index 0fb5e6c..86daf0b 100644 --- a/faim_client/api/health/health_check_health_get.py +++ b/faim_client/api/health/health_check_health_get.py @@ -1,5 +1,5 @@ from http import HTTPStatus -from typing import Any +from typing import Any, Optional, Union import httpx @@ -17,7 +17,7 @@ def _get_kwargs() -> dict[str, Any]: return _kwargs -def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | None: +def _parse_response(*, client: Union[AuthenticatedClient, Client], response: httpx.Response) -> Optional[Any]: if response.status_code == 200: return None @@ -27,7 +27,7 @@ def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Res return None -def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any]: +def _build_response(*, client: Union[AuthenticatedClient, Client], response: httpx.Response) -> Response[Any]: return Response( status_code=HTTPStatus(response.status_code), content=response.content, @@ -38,7 +38,7 @@ def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Res def sync_detailed( *, - client: AuthenticatedClient | Client, + client: Union[AuthenticatedClient, Client], ) -> Response[Any]: """Health check @@ -63,7 +63,7 @@ def sync_detailed( async def asyncio_detailed( *, - client: AuthenticatedClient | Client, + client: Union[AuthenticatedClient, Client], ) -> Response[Any]: """Health check diff --git a/faim_client/client.py b/faim_client/client.py index 3f312fb..e80446f 100644 --- a/faim_client/client.py +++ b/faim_client/client.py @@ -1,5 +1,5 @@ import ssl -from typing import Any +from typing import Any, Optional, Union import httpx from attrs import define, evolve, field @@ -38,12 +38,12 @@ class Client: _base_url: str = field(alias="base_url") _cookies: dict[str, str] = field(factory=dict, kw_only=True, alias="cookies") _headers: dict[str, str] = field(factory=dict, kw_only=True, alias="headers") - _timeout: httpx.Timeout | None = field(default=None, kw_only=True, alias="timeout") - _verify_ssl: str | bool | ssl.SSLContext = field(default=True, kw_only=True, alias="verify_ssl") + _timeout: Optional[httpx.Timeout] = field(default=None, kw_only=True, alias="timeout") + _verify_ssl: Union[str, bool, ssl.SSLContext] = field(default=True, kw_only=True, alias="verify_ssl") _follow_redirects: bool = field(default=False, kw_only=True, alias="follow_redirects") _httpx_args: dict[str, Any] = field(factory=dict, kw_only=True, alias="httpx_args") - _client: httpx.Client | None = field(default=None, init=False) - _async_client: httpx.AsyncClient | None = field(default=None, init=False) + _client: Optional[httpx.Client] = field(default=None, init=False) + _async_client: Optional[httpx.AsyncClient] = field(default=None, init=False) def with_headers(self, headers: dict[str, str]) -> "Client": """Get a new client matching this one with additional headers""" @@ -168,12 +168,12 @@ class AuthenticatedClient: _base_url: str = field(alias="base_url") _cookies: dict[str, str] = field(factory=dict, kw_only=True, alias="cookies") _headers: dict[str, str] = field(factory=dict, kw_only=True, alias="headers") - _timeout: httpx.Timeout | None = field(default=None, kw_only=True, alias="timeout") - _verify_ssl: str | bool | ssl.SSLContext = field(default=True, kw_only=True, alias="verify_ssl") + _timeout: Optional[httpx.Timeout] = field(default=None, kw_only=True, alias="timeout") + _verify_ssl: Union[str, bool, ssl.SSLContext] = field(default=True, kw_only=True, alias="verify_ssl") _follow_redirects: bool = field(default=False, kw_only=True, alias="follow_redirects") _httpx_args: dict[str, Any] = field(factory=dict, kw_only=True, alias="httpx_args") - _client: httpx.Client | None = field(default=None, init=False) - _async_client: httpx.AsyncClient | None = field(default=None, init=False) + _client: Optional[httpx.Client] = field(default=None, init=False) + _async_client: Optional[httpx.AsyncClient] = field(default=None, init=False) token: str prefix: str = "Bearer" diff --git a/faim_client/models/__init__.py b/faim_client/models/__init__.py index 6e1d2b7..c44b98d 100644 --- a/faim_client/models/__init__.py +++ b/faim_client/models/__init__.py @@ -1,5 +1,15 @@ """Contains all the data models used in inputs/outputs""" +from .error_code import ErrorCode +from .error_response import ErrorResponse +from .http_validation_error import HTTPValidationError from .model_name import ModelName +from .validation_error import ValidationError -__all__ = ("ModelName",) +__all__ = ( + "ErrorCode", + "ErrorResponse", + "HTTPValidationError", + "ModelName", + "ValidationError", +) diff --git a/faim_client/models/error_code.py b/faim_client/models/error_code.py new file mode 100644 index 0000000..9e96e55 --- /dev/null +++ b/faim_client/models/error_code.py @@ -0,0 +1,34 @@ +from enum import Enum + + +class ErrorCode(str, Enum): + AUTHENTICATION_FAILED = "AUTHENTICATION_FAILED" + AUTHENTICATION_REQUIRED = "AUTHENTICATION_REQUIRED" + AUTHORIZATION_FAILED = "AUTHORIZATION_FAILED" + BILLING_TRANSACTION_FAILED = "BILLING_TRANSACTION_FAILED" + CONFIGURATION_ERROR = "CONFIGURATION_ERROR" + DATABASE_ERROR = "DATABASE_ERROR" + INFERENCE_ERROR = "INFERENCE_ERROR" + INSUFFICIENT_FUNDS = "INSUFFICIENT_FUNDS" + INTERNAL_SERVER_ERROR = "INTERNAL_SERVER_ERROR" + INVALID_API_KEY = "INVALID_API_KEY" + INVALID_DTYPE = "INVALID_DTYPE" + INVALID_MODEL_INPUT = "INVALID_MODEL_INPUT" + INVALID_PARAMETER = "INVALID_PARAMETER" + INVALID_SHAPE = "INVALID_SHAPE" + INVALID_VALUE_RANGE = "INVALID_VALUE_RANGE" + MISSING_REQUIRED_FIELD = "MISSING_REQUIRED_FIELD" + MODEL_INITIALIZATION_ERROR = "MODEL_INITIALIZATION_ERROR" + MODEL_NOT_FOUND = "MODEL_NOT_FOUND" + OUT_OF_MEMORY = "OUT_OF_MEMORY" + PRICING_NOT_FOUND = "PRICING_NOT_FOUND" + RATE_LIMIT_EXCEEDED = "RATE_LIMIT_EXCEEDED" + REQUEST_TOO_LARGE = "REQUEST_TOO_LARGE" + RESOURCE_EXHAUSTED = "RESOURCE_EXHAUSTED" + RESOURCE_NOT_FOUND = "RESOURCE_NOT_FOUND" + TIMEOUT_ERROR = "TIMEOUT_ERROR" + TRITON_CONNECTION_ERROR = "TRITON_CONNECTION_ERROR" + VALIDATION_ERROR = "VALIDATION_ERROR" + + def __str__(self) -> str: + return str(self.value) diff --git a/faim_client/models/error_response.py b/faim_client/models/error_response.py index 1848b05..79e3b76 100644 --- a/faim_client/models/error_response.py +++ b/faim_client/models/error_response.py @@ -1,9 +1,10 @@ from collections.abc import Mapping -from typing import Any, TypeVar, cast +from typing import Any, TypeVar, Union, cast from attrs import define as _attrs_define from attrs import field as _attrs_field +from ..models.error_code import ErrorCode from ..types import UNSET, Unset T = TypeVar("T", bound="ErrorResponse") @@ -11,58 +12,97 @@ @_attrs_define class ErrorResponse: - """Error response model for API errors. + """Canonical error response structure for the entire FAIM system. - Example: - {'detail': "Model 'unknown_model' version '1' is not available", 'error': 'Model not found'} + This model is used by: + 1. Triton Python backends (serialized to JSON string in error metadata) + 2. Proxy Server (returned as HTTP JSON response body) + 3. Client SDK (deserialized from HTTP response) Attributes: - error (str): Error message - detail (Union[None, Unset, str]): Additional error details + error_code: Machine-readable error code for programmatic handling + message: Human-readable error message + detail: Optional detailed explanation (backward compatible with SDK) + request_id: Request identifier for tracing + + Attributes: + error_code (ErrorCode): Canonical error codes used across the entire system. + + These codes are stable identifiers that clients can use for + programmatic error handling (retries, fallbacks, user messaging). + message (str): Human-readable error message + detail (Union[None, Unset, str]): Detailed error explanation (backward compatible with SDK ErrorResponse.detail) + request_id (Union[None, Unset, str]): Request identifier for distributed tracing """ - error: str - detail: None | Unset | str = UNSET + error_code: ErrorCode + message: str + detail: Union[None, Unset, str] = UNSET + request_id: Union[None, Unset, str] = UNSET additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict) def to_dict(self) -> dict[str, Any]: - error = self.error + error_code = self.error_code.value - detail: None | Unset | str + message = self.message + + detail: Union[None, Unset, str] if isinstance(self.detail, Unset): detail = UNSET else: detail = self.detail + request_id: Union[None, Unset, str] + if isinstance(self.request_id, Unset): + request_id = UNSET + else: + request_id = self.request_id + field_dict: dict[str, Any] = {} field_dict.update(self.additional_properties) field_dict.update( { - "error": error, + "error_code": error_code, + "message": message, } ) if detail is not UNSET: field_dict["detail"] = detail + if request_id is not UNSET: + field_dict["request_id"] = request_id return field_dict @classmethod def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T: d = dict(src_dict) - error = d.pop("error") + error_code = ErrorCode(d.pop("error_code")) - def _parse_detail(data: object) -> None | Unset | str: + message = d.pop("message") + + def _parse_detail(data: object) -> Union[None, Unset, str]: if data is None: return data if isinstance(data, Unset): return data - return cast(None | Unset | str, data) + return cast(Union[None, Unset, str], data) detail = _parse_detail(d.pop("detail", UNSET)) + def _parse_request_id(data: object) -> Union[None, Unset, str]: + if data is None: + return data + if isinstance(data, Unset): + return data + return cast(Union[None, Unset, str], data) + + request_id = _parse_request_id(d.pop("request_id", UNSET)) + error_response = cls( - error=error, + error_code=error_code, + message=message, detail=detail, + request_id=request_id, ) error_response.additional_properties = d diff --git a/faim_client/models/http_validation_error.py b/faim_client/models/http_validation_error.py new file mode 100644 index 0000000..36bb758 --- /dev/null +++ b/faim_client/models/http_validation_error.py @@ -0,0 +1,75 @@ +from collections.abc import Mapping +from typing import TYPE_CHECKING, Any, TypeVar, Union + +from attrs import define as _attrs_define +from attrs import field as _attrs_field + +from ..types import UNSET, Unset + +if TYPE_CHECKING: + from ..models.validation_error import ValidationError + + +T = TypeVar("T", bound="HTTPValidationError") + + +@_attrs_define +class HTTPValidationError: + """ + Attributes: + detail (Union[Unset, list['ValidationError']]): + """ + + detail: Union[Unset, list["ValidationError"]] = UNSET + additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict) + + def to_dict(self) -> dict[str, Any]: + detail: Union[Unset, list[dict[str, Any]]] = UNSET + if not isinstance(self.detail, Unset): + detail = [] + for detail_item_data in self.detail: + detail_item = detail_item_data.to_dict() + detail.append(detail_item) + + field_dict: dict[str, Any] = {} + field_dict.update(self.additional_properties) + field_dict.update({}) + if detail is not UNSET: + field_dict["detail"] = detail + + return field_dict + + @classmethod + def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T: + from ..models.validation_error import ValidationError + + d = dict(src_dict) + detail = [] + _detail = d.pop("detail", UNSET) + for detail_item_data in _detail or []: + detail_item = ValidationError.from_dict(detail_item_data) + + detail.append(detail_item) + + http_validation_error = cls( + detail=detail, + ) + + http_validation_error.additional_properties = d + return http_validation_error + + @property + def additional_keys(self) -> list[str]: + return list(self.additional_properties.keys()) + + def __getitem__(self, key: str) -> Any: + return self.additional_properties[key] + + def __setitem__(self, key: str, value: Any) -> None: + self.additional_properties[key] = value + + def __delitem__(self, key: str) -> None: + del self.additional_properties[key] + + def __contains__(self, key: str) -> bool: + return key in self.additional_properties diff --git a/faim_client/models/model_name.py b/faim_client/models/model_name.py index 2ea44ad..cfe67d1 100644 --- a/faim_client/models/model_name.py +++ b/faim_client/models/model_name.py @@ -2,8 +2,9 @@ class ModelName(str, Enum): + CHRONOS2 = "chronos2" FLOWSTATE = "flowstate" - TOTO = "toto" + TIREX = "tirex" def __str__(self) -> str: return str(self.value) diff --git a/faim_client/models/validation_error.py b/faim_client/models/validation_error.py new file mode 100644 index 0000000..e298833 --- /dev/null +++ b/faim_client/models/validation_error.py @@ -0,0 +1,88 @@ +from collections.abc import Mapping +from typing import Any, TypeVar, Union, cast + +from attrs import define as _attrs_define +from attrs import field as _attrs_field + +T = TypeVar("T", bound="ValidationError") + + +@_attrs_define +class ValidationError: + """ + Attributes: + loc (list[Union[int, str]]): + msg (str): + type_ (str): + """ + + loc: list[Union[int, str]] + msg: str + type_: str + additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict) + + def to_dict(self) -> dict[str, Any]: + loc = [] + for loc_item_data in self.loc: + loc_item: Union[int, str] + loc_item = loc_item_data + loc.append(loc_item) + + msg = self.msg + + type_ = self.type_ + + field_dict: dict[str, Any] = {} + field_dict.update(self.additional_properties) + field_dict.update( + { + "loc": loc, + "msg": msg, + "type": type_, + } + ) + + return field_dict + + @classmethod + def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T: + d = dict(src_dict) + loc = [] + _loc = d.pop("loc") + for loc_item_data in _loc: + + def _parse_loc_item(data: object) -> Union[int, str]: + return cast(Union[int, str], data) + + loc_item = _parse_loc_item(loc_item_data) + + loc.append(loc_item) + + msg = d.pop("msg") + + type_ = d.pop("type") + + validation_error = cls( + loc=loc, + msg=msg, + type_=type_, + ) + + validation_error.additional_properties = d + return validation_error + + @property + def additional_keys(self) -> list[str]: + return list(self.additional_properties.keys()) + + def __getitem__(self, key: str) -> Any: + return self.additional_properties[key] + + def __setitem__(self, key: str, value: Any) -> None: + self.additional_properties[key] = value + + def __delitem__(self, key: str) -> None: + del self.additional_properties[key] + + def __contains__(self, key: str) -> bool: + return key in self.additional_properties diff --git a/faim_client/types.py b/faim_client/types.py index 67a552b..1b96ca4 100644 --- a/faim_client/types.py +++ b/faim_client/types.py @@ -2,7 +2,7 @@ from collections.abc import Mapping, MutableMapping from http import HTTPStatus -from typing import IO, BinaryIO, Generic, Literal, TypeVar, Union +from typing import IO, BinaryIO, Generic, Literal, Optional, TypeVar, Union from attrs import define @@ -18,9 +18,9 @@ def __bool__(self) -> Literal[False]: FileContent = Union[IO[bytes], bytes, str] FileTypes = Union[ # (filename, file (or bytes), content_type) - tuple[str | None, FileContent, str | None], + tuple[Optional[str], FileContent, Optional[str]], # (filename, file (or bytes), content_type, headers) - tuple[str | None, FileContent, str | None, Mapping[str, str]], + tuple[Optional[str], FileContent, Optional[str], Mapping[str, str]], ] RequestFiles = list[tuple[str, FileTypes]] @@ -30,8 +30,8 @@ class File: """Contains information for file uploads""" payload: BinaryIO - file_name: str | None = None - mime_type: str | None = None + file_name: Optional[str] = None + mime_type: Optional[str] = None def to_tuple(self) -> FileTypes: """Return a tuple representation that httpx will accept for multipart/form-data""" @@ -48,7 +48,7 @@ class Response(Generic[T]): status_code: HTTPStatus content: bytes headers: MutableMapping[str, str] - parsed: T | None + parsed: Optional[T] __all__ = ["UNSET", "File", "FileTypes", "RequestFiles", "Response", "Unset"] diff --git a/faim_sdk/__init__.py b/faim_sdk/__init__.py index 062a6b2..4261e0c 100644 --- a/faim_sdk/__init__.py +++ b/faim_sdk/__init__.py @@ -4,25 +4,32 @@ FAIM inference platform for foundation AI models on structured data. """ +from faim_client.models.error_code import ErrorCode + from .client import ForecastClient from .exceptions import ( APIError, + AuthenticationError, ConfigurationError, FAIMError, + InsufficientFundsError, InternalServerError, ModelNotFoundError, NetworkError, PayloadTooLargeError, + RateLimitError, SerializationError, + ServiceUnavailableError, TimeoutError, ValidationError, ) from .models import ( + Chronos2ForecastRequest, FlowStateForecastRequest, ForecastRequest, ForecastResponse, OutputType, - ToToForecastRequest, + TiRexForecastRequest, ) __all__ = [ @@ -30,23 +37,30 @@ "ForecastClient", # Request models "ForecastRequest", - "ToToForecastRequest", "FlowStateForecastRequest", + "Chronos2ForecastRequest", + "TiRexForecastRequest", # Response model "ForecastResponse", # Type aliases "OutputType", + # Error codes (for programmatic error handling) + "ErrorCode", # Exceptions "FAIMError", "APIError", + "AuthenticationError", + "InsufficientFundsError", + "RateLimitError", "SerializationError", "ModelNotFoundError", "PayloadTooLargeError", "ValidationError", "InternalServerError", + "ServiceUnavailableError", "NetworkError", "TimeoutError", "ConfigurationError", ] -__version__ = "0.1.2" +__version__ = "0.2.0" diff --git a/faim_sdk/client.py b/faim_sdk/client.py index aaf82cb..9d8f13f 100644 --- a/faim_sdk/client.py +++ b/faim_sdk/client.py @@ -5,6 +5,7 @@ """ import io +import json import logging import httpx @@ -12,15 +13,21 @@ from faim_client import AuthenticatedClient, Client from faim_client.api.forecast import forecast_v1_ts_forecast_model_name_model_version_post from faim_client.models import ModelName +from faim_client.models.error_code import ErrorCode +from faim_client.models.error_response import ErrorResponse from faim_client.types import File from .exceptions import ( APIError, + AuthenticationError, + InsufficientFundsError, InternalServerError, ModelNotFoundError, NetworkError, PayloadTooLargeError, + RateLimitError, SerializationError, + ServiceUnavailableError, TimeoutError, ValidationError, ) @@ -30,6 +37,30 @@ logger = logging.getLogger(__name__) +def _parse_error_response(response) -> ErrorResponse | None: + """Parse ErrorResponse from HTTP response body. + + Args: + response: HTTP response object from generated client + + Returns: + Parsed ErrorResponse if available, None otherwise + """ + try: + # Try parsing from response.parsed first (generated client parsing) + if hasattr(response, "parsed") and isinstance(response.parsed, ErrorResponse): + return response.parsed + + # Fallback: try parsing JSON content directly + if hasattr(response, "content") and response.content: + error_dict = json.loads(response.content) + return ErrorResponse.from_dict(error_dict) + except Exception as e: + logger.warning(f"Failed to parse error response: {e}") + + return None + + class ForecastClient: """High-level client for FAIM time-series forecasting. @@ -40,17 +71,17 @@ class ForecastClient: - Support for both sync and async operations Example: - >>> from faim_sdk import ForecastClient, ToToForecastRequest + >>> from faim_sdk import ForecastClient, Chronos2ForecastRequest >>> from faim_client.models import ModelName >>> >>> client = ForecastClient(base_url="https://api.example.com") - >>> request = ToToForecastRequest( + >>> request = Chronos2ForecastRequest( ... x=data, ... horizon=10, ... quantiles=[0.1, 0.5, 0.9] ... ) - >>> response = client.forecast(ModelName.TOTO, request) - >>> print(response.predictions.shape) + >>> response = client.forecast(ModelName.CHRONOS2, request) + >>> print(response.point.shape) """ def __init__( @@ -108,19 +139,23 @@ def forecast(self, model: ModelName, request: ForecastRequest) -> ForecastRespon """Generate time-series forecast (synchronous). Args: - model: Model to use (ModelName.TOTO or ModelName.FLOWSTATE) + model: Model to use (ModelName.FLOWSTATE, ModelName.CHRONOS2, or ModelName.TIREX) request: Model-specific forecast request Returns: ForecastResponse with predictions and metadata Raises: - SerializationError: If request serialization or response deserialization fails + AuthenticationError: If authentication fails (401, 403) + InsufficientFundsError: If billing account balance is insufficient (402) ModelNotFoundError: If model or version doesn't exist (404) PayloadTooLargeError: If request exceeds size limit (413) ValidationError: If request parameters are invalid (422) + RateLimitError: If rate limit exceeded (429) InternalServerError: If backend encounters error (500) + ServiceUnavailableError: If service unavailable (503, 504) NetworkError: If network communication fails + SerializationError: If request serialization or response deserialization fails TimeoutError: If request exceeds timeout APIError: For other API errors @@ -187,46 +222,82 @@ def forecast(self, model: ModelName, request: ForecastRequest) -> ForecastRespon details={"model": str(model), "error_type": type(e).__name__}, ) from e - # Handle HTTP errors - if response.status_code == 404: - logger.error(f"Model not found: {model}/{request.model_version}") - raise ModelNotFoundError( - f"Model {model}/{request.model_version} not found", - status_code=404, - response=response.parsed if hasattr(response, "parsed") else None, - ) - - elif response.status_code == 413: - logger.error(f"Payload too large: {len(payload)} bytes") - raise PayloadTooLargeError( - f"Request payload too large ({len(payload)} bytes)", - status_code=413, - details={"payload_size": len(payload)}, - ) - - elif response.status_code == 422: - logger.error("Request validation failed") - raise ValidationError( - "Request parameters are invalid", - status_code=422, - response=response.parsed if hasattr(response, "parsed") else None, - ) - - elif response.status_code == 500: - logger.error("Internal server error") - raise InternalServerError( - "Backend encountered an internal error", - status_code=500, - response=response.parsed if hasattr(response, "parsed") else None, - ) - - elif response.status_code != 200: - logger.error(f"Unexpected status code: {response.status_code}") - raise APIError( - f"Unexpected status code: {response.status_code}", - status_code=response.status_code, - response=response.parsed if hasattr(response, "parsed") else None, - ) + # Handle non-200 responses with error contract + if response.status_code != 200: + error_response = _parse_error_response(response) + + # Build error message from ErrorResponse or fallback + if error_response: + message = error_response.message + if error_response.detail: + message = f"{message}: {error_response.detail}" + + logger.error( + f"API error: status={response.status_code}, " + f"code={error_response.error_code}, " + f"message={error_response.message}, " + f"request_id={error_response.request_id}" + ) + else: + message = f"Request failed with status {response.status_code}" + logger.error(f"API error: status={response.status_code}, no error_response") + + # Map HTTP status code to exception class + if response.status_code in (401, 403): + raise AuthenticationError( + message=message, + status_code=response.status_code, + error_response=error_response, + ) + elif response.status_code == 402: + raise InsufficientFundsError( + message=message, + status_code=response.status_code, + error_response=error_response, + ) + elif response.status_code == 404: + raise ModelNotFoundError( + message=message, + status_code=response.status_code, + error_response=error_response, + ) + elif response.status_code == 413: + raise PayloadTooLargeError( + message=message, + status_code=response.status_code, + error_response=error_response, + ) + elif response.status_code == 422: + raise ValidationError( + message=message, + status_code=response.status_code, + error_response=error_response, + ) + elif response.status_code == 429: + raise RateLimitError( + message=message, + status_code=response.status_code, + error_response=error_response, + ) + elif response.status_code == 500: + raise InternalServerError( + message=message, + status_code=response.status_code, + error_response=error_response, + ) + elif response.status_code in (503, 504): + raise ServiceUnavailableError( + message=message, + status_code=response.status_code, + error_response=error_response, + ) + else: + # Fallback for unmapped status codes + raise APIError( + message=message, + status_code=response.status_code, + error_response=error_response, + ) # Deserialize successful response try: @@ -250,7 +321,7 @@ async def forecast_async(self, model: ModelName, request: ForecastRequest) -> Fo """Generate time-series forecast (asynchronous). Args: - model: Model to use (ModelName.TOTO or ModelName.FLOWSTATE) + model: Model to use (ModelName.FLOWSTATE, ModelName.CHRONOS2, or ModelName.TIREX) request: Model-specific forecast request Returns: @@ -260,8 +331,8 @@ async def forecast_async(self, model: ModelName, request: ForecastRequest) -> Fo Same exceptions as forecast() Example: - >>> request = ToToForecastRequest(x=data, horizon=10) - >>> response = await client.forecast_async(ModelName.TOTO, request) + >>> request = Chronos2ForecastRequest(x=data, horizon=10) + >>> response = await client.forecast_async(ModelName.CHRONOS2, request) """ logger.debug(f"Starting async forecast: model={model}, version={request.model_version}") @@ -319,37 +390,82 @@ async def forecast_async(self, model: ModelName, request: ForecastRequest) -> Fo details={"model": str(model), "error_type": type(e).__name__}, ) from e - # Handle HTTP errors (same as sync) - if response.status_code == 404: - raise ModelNotFoundError( - f"Model {model}/{request.model_version} not found", - status_code=404, - response=response.parsed if hasattr(response, "parsed") else None, - ) - elif response.status_code == 413: - raise PayloadTooLargeError( - f"Request payload too large ({len(payload)} bytes)", - status_code=413, - details={"payload_size": len(payload)}, - ) - elif response.status_code == 422: - raise ValidationError( - "Request parameters are invalid", - status_code=422, - response=response.parsed if hasattr(response, "parsed") else None, - ) - elif response.status_code == 500: - raise InternalServerError( - "Backend encountered an internal error", - status_code=500, - response=response.parsed if hasattr(response, "parsed") else None, - ) - elif response.status_code != 200: - raise APIError( - f"Unexpected status code: {response.status_code}", - status_code=response.status_code, - response=response.parsed if hasattr(response, "parsed") else None, - ) + # Handle non-200 responses with error contract (same as sync) + if response.status_code != 200: + error_response = _parse_error_response(response) + + # Build error message from ErrorResponse or fallback + if error_response: + message = error_response.message + if error_response.detail: + message = f"{message}: {error_response.detail}" + + logger.error( + f"API error: status={response.status_code}, " + f"code={error_response.error_code}, " + f"message={error_response.message}, " + f"request_id={error_response.request_id}" + ) + else: + message = f"Request failed with status {response.status_code}" + logger.error(f"API error: status={response.status_code}, no error_response") + + # Map HTTP status code to exception class + if response.status_code in (401, 403): + raise AuthenticationError( + message=message, + status_code=response.status_code, + error_response=error_response, + ) + elif response.status_code == 402: + raise InsufficientFundsError( + message=message, + status_code=response.status_code, + error_response=error_response, + ) + elif response.status_code == 404: + raise ModelNotFoundError( + message=message, + status_code=response.status_code, + error_response=error_response, + ) + elif response.status_code == 413: + raise PayloadTooLargeError( + message=message, + status_code=response.status_code, + error_response=error_response, + ) + elif response.status_code == 422: + raise ValidationError( + message=message, + status_code=response.status_code, + error_response=error_response, + ) + elif response.status_code == 429: + raise RateLimitError( + message=message, + status_code=response.status_code, + error_response=error_response, + ) + elif response.status_code == 500: + raise InternalServerError( + message=message, + status_code=response.status_code, + error_response=error_response, + ) + elif response.status_code in (503, 504): + raise ServiceUnavailableError( + message=message, + status_code=response.status_code, + error_response=error_response, + ) + else: + # Fallback for unmapped status codes + raise APIError( + message=message, + status_code=response.status_code, + error_response=error_response, + ) # Deserialize response try: diff --git a/faim_sdk/exceptions.py b/faim_sdk/exceptions.py index ed805b0..9c0c769 100644 --- a/faim_sdk/exceptions.py +++ b/faim_sdk/exceptions.py @@ -1,10 +1,12 @@ """Exceptions for FAIM SDK. Provides a hierarchy of exceptions for precise error handling and debugging. +Integrates with the unified error contract via generated ErrorResponse and ErrorCode. """ from typing import Any +from faim_client.models.error_code import ErrorCode from faim_client.models.error_response import ErrorResponse @@ -47,14 +49,15 @@ class SerializationError(FAIMError): class APIError(FAIMError): """Base exception for API-related errors. - Captures HTTP status codes and server error responses. + Captures HTTP status codes and server error responses with error contract integration. + All API errors include an optional ErrorResponse with machine-readable error codes. """ def __init__( self, message: str, status_code: int | None = None, - response: ErrorResponse | None = None, + error_response: ErrorResponse | None = None, details: dict[str, Any] | None = None, ) -> None: """Initialize API error. @@ -62,19 +65,38 @@ def __init__( Args: message: Human-readable error message status_code: HTTP status code from response - response: Parsed error response from backend - details: Additional context + error_response: Parsed error response from backend (includes error_code, message, detail) + details: Additional context for debugging """ super().__init__(message, details) self.status_code = status_code - self.response = response + self.error_response = error_response + + @property + def error_code(self) -> ErrorCode | None: + """Get machine-readable error code from error response. + + Returns: + ErrorCode enum value if available, None otherwise + + Example: + try: + client.forecast(...) + except ValidationError as e: + if e.error_code == ErrorCode.INVALID_SHAPE: + # Handle shape error specifically + pass + """ + return self.error_response.error_code if self.error_response else None def __str__(self) -> str: parts = [self.message] if self.status_code: parts.append(f"status={self.status_code}") - if self.response: - parts.append(f"response={self.response}") + if self.error_response: + parts.append(f"error_code={self.error_response.error_code}") + if self.error_response.request_id: + parts.append(f"request_id={self.error_response.request_id}") if self.details: parts.append(f"details={self.details}") return " | ".join(parts) @@ -84,8 +106,13 @@ class ModelNotFoundError(APIError): """Raised when specified model or version doesn't exist (404). Check that: - - Model name is valid (e.g., 'flowstate', 'toto') + - Model name is valid (e.g., 'flowstate', 'chronos2', 'tirex') - Model version is deployed on backend + + Error codes: + - MODEL_NOT_FOUND + - PRICING_NOT_FOUND + - RESOURCE_NOT_FOUND """ pass @@ -107,10 +134,19 @@ class ValidationError(APIError): """Raised when backend rejects request as invalid (422). Common causes: - - Missing required parameters (e.g., horizon, x) + - Missing required parameters (e.g., horizon, x, output_type) - Invalid parameter values - Incompatible array shapes - Model-specific parameter errors + + Error codes: + - VALIDATION_ERROR + - INVALID_MODEL_INPUT + - INVALID_PARAMETER + - MISSING_REQUIRED_FIELD + - INVALID_SHAPE + - INVALID_DTYPE + - INVALID_VALUE_RANGE """ pass @@ -152,11 +188,73 @@ class TimeoutError(FAIMError): class AuthenticationError(APIError): - """Raised when authentication fails (401). + """Raised when authentication fails (401, 403). Check that: - - Token is valid and not expired - - Token has required permissions + - API key is valid and not expired + - API key has required permissions + + Error codes: + - AUTHENTICATION_REQUIRED + - AUTHENTICATION_FAILED + - INVALID_API_KEY + - AUTHORIZATION_FAILED + """ + + pass + + +class InsufficientFundsError(APIError): + """Raised when billing account balance is insufficient (402). + + This indicates the user's account doesn't have enough credits + to perform the requested inference. + + Actions: + - Add credits to billing account + - Check pricing for the model/version being used + + Error codes: + - INSUFFICIENT_FUNDS + - BILLING_TRANSACTION_FAILED + """ + + pass + + +class RateLimitError(APIError): + """Raised when rate limit is exceeded (429). + + The user has made too many requests in a short period. + + Actions: + - Implement exponential backoff retry logic + - Reduce request frequency + - Contact support for rate limit increases + + Error codes: + - RATE_LIMIT_EXCEEDED + """ + + pass + + +class ServiceUnavailableError(APIError): + """Raised when service is temporarily unavailable (503, 504). + + This typically indicates transient infrastructure issues that + may be resolved by retrying with exponential backoff. + + Common causes: + - Triton server connection failures + - GPU/CPU resources exhausted + - Out of memory conditions + + Error codes: + - TRITON_CONNECTION_ERROR + - RESOURCE_EXHAUSTED + - OUT_OF_MEMORY + - TIMEOUT_ERROR (504) """ pass diff --git a/faim_sdk/models.py b/faim_sdk/models.py index 47736ad..ac1158d 100644 --- a/faim_sdk/models.py +++ b/faim_sdk/models.py @@ -18,7 +18,7 @@ class ForecastRequest: """Base forecast request with common parameters. This is the base class for all model-specific forecast requests. - Use model-specific subclasses (ToToForecastRequest, FlowStateForecastRequest) + Use model-specific subclasses (FlowStateForecastRequest, Chronos2ForecastRequest, TiRexForecastRequest) for better type safety and IDE support. """ @@ -64,73 +64,62 @@ def to_arrays_and_metadata(self) -> tuple[dict[str, np.ndarray], dict[str, Any]] @dataclass -class ToToForecastRequest(ForecastRequest): - """Forecast request for ToTo model with probabilistic forecasting support. +class Chronos2ForecastRequest(ForecastRequest): + """Forecast request for Chronos2 model. - ToTo supports multi-series forecasting with padding masks and - probabilistic predictions via sampling or quantiles. + Amazon Chronos 2.0 - Large language model for time series forecasting. + Supports point and quantile predictions. """ output_type: OutputType = "point" """Output type to return. Options: 'point', 'quantiles', 'samples'. Default: 'point'.""" - padding_mask: np.ndarray | None = None - """Padding mask for variable-length sequences. Shape: same as x. - 1 for valid timesteps, 0 for padding.""" - - id_mask: np.ndarray | None = None - """Identifier mask for multi-series forecasting. Shape: (batch_size,). - Each unique ID represents a different time series.""" - - num_samples: int | None = None - """Number of forecast samples for probabilistic predictions. - If set, returns sample-based distribution.""" - quantiles: list[float] | None = None """Quantile levels for probabilistic forecasting. - Example: [0.1, 0.5, 0.9] for 10th, 50th (median), 90th percentiles.""" + Example: [0.1, 0.5, 0.9] for 10th, 50th (median), 90th percentiles. + Only used when output_type='quantiles'.""" def __post_init__(self) -> None: - """Validate ToTo-specific parameters.""" + """Validate Chronos2-specific parameters.""" super().__post_init__() - if self.padding_mask is not None: - if not isinstance(self.padding_mask, np.ndarray): - raise TypeError("padding_mask must be numpy.ndarray") - if self.padding_mask.shape != self.x.shape: - raise ValueError(f"padding_mask shape {self.padding_mask.shape} must match x shape {self.x.shape}") - - if self.id_mask is not None: - if not isinstance(self.id_mask, np.ndarray): - raise TypeError("id_mask must be numpy.ndarray") - - if self.num_samples is not None and self.num_samples <= 0: - raise ValueError(f"num_samples must be positive, got {self.num_samples}") - if self.quantiles is not None: - if not all(0 <= q <= 1 for q in self.quantiles): - raise ValueError(f"quantiles must be in [0, 1], got {self.quantiles}") + if not all(0.0 <= q <= 1.0 for q in self.quantiles): + raise ValueError(f"quantiles must be in [0.0, 1.0], got {self.quantiles}") def to_arrays_and_metadata(self) -> tuple[dict[str, np.ndarray], dict[str, Any]]: - """Convert ToTo request to Arrow format.""" + """Convert Chronos2 request to Arrow format.""" arrays, metadata = super().to_arrays_and_metadata() - # Add ToTo-specific arrays (large data) - if self.padding_mask is not None: - arrays["padding_mask"] = self.padding_mask - if self.id_mask is not None: - arrays["id_mask"] = self.id_mask - - # Add ToTo-specific metadata (small parameters) + # Add Chronos2-specific metadata (small parameters) metadata["output_type"] = self.output_type - if self.num_samples is not None: - metadata["num_samples"] = self.num_samples if self.quantiles is not None: metadata["quantiles"] = self.quantiles return arrays, metadata +@dataclass +class TiRexForecastRequest(ForecastRequest): + """Forecast request for TiRex model. + + TiRex - Transformer-based time series forecasting. + Supports point and quantile predictions. + """ + + output_type: OutputType = "point" + """Output type to return. Options: 'point', 'quantiles', 'samples'. Default: 'point'.""" + + def to_arrays_and_metadata(self) -> tuple[dict[str, np.ndarray], dict[str, Any]]: + """Convert TiRex request to Arrow format.""" + arrays, metadata = super().to_arrays_and_metadata() + + # Add TiRex-specific metadata + metadata["output_type"] = self.output_type + + return arrays, metadata + + @dataclass class FlowStateForecastRequest(ForecastRequest): """Forecast request for FlowState model with scaling and prediction type control. @@ -209,13 +198,13 @@ class ForecastResponse: # Backend outputs point: np.ndarray | None = None - """Point predictions from FlowState. Shape: (batch_size, horizon, features)""" + """Point predictions. Shape: (batch_size, horizon, features)""" quantiles: np.ndarray | None = None - """Quantile predictions from ToTo. Shape: (batch_size, horizon, num_quantiles)""" + """Quantile predictions. Shape: (batch_size, horizon, num_quantiles)""" samples: np.ndarray | None = None - """Sample predictions from ToTo. Shape: (batch_size, horizon, num_samples)""" + """Sample predictions. Shape: (batch_size, horizon, num_samples)""" @classmethod def from_arrays_and_metadata(cls, arrays: dict[str, np.ndarray], metadata: dict[str, Any]) -> "ForecastResponse": diff --git a/scripts/regenerate_client.sh b/scripts/regenerate_client.sh new file mode 100755 index 0000000..53cb33b --- /dev/null +++ b/scripts/regenerate_client.sh @@ -0,0 +1,162 @@ +#!/bin/bash +set -e # Exit on error + +# FAIM Client Regeneration Script +# This script regenerates the faim_client from openapi.json and cleans up unused API endpoints +# Usage: ./scripts/regenerate_client.sh + +echo "=========================================" +echo "FAIM Client Regeneration Script" +echo "=========================================" +echo "" + +# Check if openapi.json exists +if [ ! -f "openapi.json" ]; then + echo "❌ Error: openapi.json not found in current directory" + exit 1 +fi + +# Check if client.config.yaml exists +if [ ! -f "client.config.yaml" ]; then + echo "❌ Error: client.config.yaml not found in current directory" + exit 1 +fi + +echo "📝 Step 1: Generating client from OpenAPI spec..." +echo " Using: openapi-python-client" +echo "" + +# Run openapi-python-client +openapi-python-client generate \ + --path openapi.json \ + --config client.config.yaml \ + --overwrite \ + --meta none + +if [ $? -ne 0 ]; then + echo "❌ Client generation failed" + exit 1 +fi + +echo "✅ Client generated successfully" +echo "" + +echo "🧹 Step 2: Cleaning up unused API endpoints..." +echo "" + +# Track what we're removing +removed_count=0 + +# Remove user management API endpoints +if [ -d "faim_client/api/user" ]; then + echo " Removing: faim_client/api/user/ (session management - unused)" + rm -rf faim_client/api/user + removed_count=$((removed_count + 1)) +fi + +# Remove API keys management endpoints +if [ -d "faim_client/api/api_keys" ]; then + echo " Removing: faim_client/api/api_keys/ (API key management - unused)" + rm -rf faim_client/api/api_keys + removed_count=$((removed_count + 1)) +fi + +echo "" +echo "🧹 Step 3: Cleaning up unused model files..." +echo "" + +# Remove API key related models +# Note: http_validation_error.py and validation_error.py are kept as they may be used by FastAPI validation +models_to_remove=( + "api_key_info.py" + "create_api_key_request.py" + "create_api_key_response.py" + "get_all_api_keys_response.py" + "revoke_api_key_request.py" +) + +for model_file in "${models_to_remove[@]}"; do + model_path="faim_client/models/$model_file" + if [ -f "$model_path" ]; then + echo " Removing: $model_path" + rm "$model_path" + removed_count=$((removed_count + 1)) + fi +done + +echo "" +echo "✅ Cleanup complete ($removed_count items removed)" +echo "" + +echo "🔧 Step 4: Fixing faim_client/models/__init__.py..." +echo "" + +# Fix the __init__.py to remove imports of deleted models +cat > faim_client/models/__init__.py << 'EOF' +"""Contains all the data models used in inputs/outputs""" + +from .error_code import ErrorCode +from .error_response import ErrorResponse +from .http_validation_error import HTTPValidationError +from .model_name import ModelName +from .validation_error import ValidationError + +__all__ = ( + "ErrorCode", + "ErrorResponse", + "HTTPValidationError", + "ModelName", + "ValidationError", +) +EOF + +echo " ✅ Updated faim_client/models/__init__.py" +echo "" + +echo "📊 Step 5: Verification..." +echo "" + +# Verify key files exist +echo " Checking generated files..." +if [ -f "faim_client/models/model_name.py" ]; then + echo " ✅ ModelName enum generated" +else + echo " ❌ ModelName enum missing" +fi + +if [ -f "faim_client/models/error_code.py" ]; then + echo " ✅ ErrorCode enum generated" +else + echo " ❌ ErrorCode enum missing" +fi + +if [ -f "faim_client/models/error_response.py" ]; then + echo " ✅ ErrorResponse model generated" +else + echo " ❌ ErrorResponse model missing" +fi + +if [ -d "faim_client/api/forecast" ]; then + echo " ✅ Forecast API endpoint retained" +else + echo " ❌ Forecast API endpoint missing" +fi + +if [ -d "faim_client/api/health" ]; then + echo " ✅ Health API endpoint retained" +else + echo " ⚠️ Health API endpoint missing (optional)" +fi + +echo "" +echo "=========================================" +echo "✅ Regeneration Complete!" +echo "=========================================" +echo "" +echo "Generated client is ready at: faim_client/" +echo "" +echo "Next steps:" +echo " 1. Review changes in faim_client/" +echo " 2. Update faim_sdk/ if needed" +echo " 3. Run tests to verify compatibility" +echo "" \ No newline at end of file From 1046f0041ec7c847500e5ddec2344e52390549fd Mon Sep 17 00:00:00 2001 From: Andrei Chernov Date: Sun, 2 Nov 2025 16:47:23 +0100 Subject: [PATCH 02/10] added eval(partially) --- README.md | 334 +++++++++++++++++++++++++++++------------ faim_sdk/__init__.py | 70 +++++++++ faim_sdk/client.py | 76 +++++++++- faim_sdk/exceptions.py | 10 ++ faim_sdk/models.py | 61 +++++++- 5 files changed, 446 insertions(+), 105 deletions(-) diff --git a/README.md b/README.md index 6637fc0..9a20fec 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,20 @@ # FAIM SDK -Python SDK for FAIM time-series forecasting with foundation AI models. +[![PyPI version](https://badge.fury.io/py/faim-sdk.svg)](https://badge.fury.io/py/faim-sdk) +[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/) +[![License: Apache 2.0](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0) + +Production-ready Python SDK for FAIM (Foundation AI Models) - a high-performance time-series forecasting platform powered by foundation models. + +## Features + +- **🚀 Multiple Foundation Models**: FlowState, Amazon Chronos 2.0, TiRex +- **🔒 Type-Safe API**: Full type hints with Pydantic validation +- **⚡ High Performance**: Optimized Apache Arrow serialization with zero-copy operations +- **🎯 Probabilistic & Deterministic**: Point forecasts, quantiles, and samples +- **🔄 Async Support**: Built-in async/await support for concurrent requests +- **📊 Rich Error Handling**: Machine-readable error codes with detailed diagnostics +- **🧪 Battle-Tested**: Production-ready with comprehensive error handling ## Installation @@ -12,85 +26,100 @@ pip install faim-sdk ```python import numpy as np -from faim_sdk import ForecastClient, FlowStateForecastRequest +from faim_sdk import ForecastClient, Chronos2ForecastRequest from faim_client.models import ModelName -# Initialize client +# Initialize client with your API endpoint client = ForecastClient( - base_url="http://localhost:8003", - timeout=60.0 + base_url="https://api.faim.example.com", + api_key="your-api-key", # Optional: for authenticated endpoints + timeout=120.0 ) # Prepare your time-series data # Shape: (batch_size, sequence_length, features) -data = np.random.randn(1, 100, 1).astype(np.float32) +data = np.random.randn(32, 100, 1).astype(np.float32) -# Create forecast request -request = FlowStateForecastRequest( +# Create probabilistic forecast request +request = Chronos2ForecastRequest( x=data, - horizon=10, - model_version="1" + horizon=24, # Forecast 24 steps ahead + output_type="quantiles", + quantiles=[0.1, 0.5, 0.9] # 10th, 50th (median), 90th percentiles ) # Generate forecast -response = client.forecast(ModelName.FLOWSTATE, request) +response = client.forecast(ModelName.CHRONOS2, request) # Access predictions -print(response.point) # Shape: (batch_size, horizon, features) -print(response.metadata) # Model metadata +print(response.quantiles.shape) # (32, 24, 3) +print(response.metadata) # Model version, inference time, etc. ``` -## Models +## Available Models ### FlowState -Point forecasting model optimized for deterministic predictions. +Optimized for **deterministic point forecasts** with optional scaling and normalization. ```python from faim_sdk import FlowStateForecastRequest request = FlowStateForecastRequest( x=data, - horizon=10, - model_version="1", - output_type="point", # Options: "point", "quantiles", "samples" - scale_factor=1.0, # Optional normalization - prediction_type="mean" # Options: "mean", "median", "quantile" + horizon=24, + model_version="latest", + output_type="point", + scale_factor=1.0, # Optional: normalization factor + prediction_type="mean" # Options: "mean", "median" ) + +response = client.forecast(ModelName.FLOWSTATE, request) +print(response.point.shape) # (batch_size, 24, features) ``` -### ToTo +### Chronos 2.0 -Probabilistic forecasting model with quantile and sample-based predictions. +Amazon's **large language model for time series** - ideal for probabilistic forecasting with quantiles. ```python -from faim_sdk import ToToForecastRequest +from faim_sdk import Chronos2ForecastRequest -# Quantile predictions -request = ToToForecastRequest( +# Quantile-based probabilistic forecast +request = Chronos2ForecastRequest( x=data, - horizon=10, - model_version="1", + horizon=24, output_type="quantiles", - quantiles=[0.1, 0.5, 0.9] # 10th, 50th, 90th percentiles + quantiles=[0.05, 0.25, 0.5, 0.75, 0.95] # Full distribution ) -# Sample-based predictions -request = ToToForecastRequest( +response = client.forecast(ModelName.CHRONOS2, request) +print(response.quantiles.shape) # (batch_size, 24, 5) +``` + +### TiRex + +**Transformer-based forecasting** model for efficient and accurate predictions. + +```python +from faim_sdk import TiRexForecastRequest + +request = TiRexForecastRequest( x=data, - horizon=10, - model_version="1", - output_type="samples", - num_samples=100 + horizon=24, + output_type="point" ) + +response = client.forecast(ModelName.TIREX, request) +print(response.point.shape) # (batch_size, 24, features) ``` ## Response Format -All forecasts return a `ForecastResponse` object: +All forecasts return a `ForecastResponse` object with predictions and metadata: ```python -response = client.forecast(ModelName.TOTO, request) +response = client.forecast(ModelName.CHRONOS2, request) # Access predictions based on output_type if response.point is not None: @@ -98,53 +127,113 @@ if response.point is not None: if response.quantiles is not None: quantiles = response.quantiles # Shape: (batch_size, horizon, num_quantiles) + # Lower quantiles for uncertainty bounds + lower_bound = quantiles[:, :, 0] # 10th percentile + median = quantiles[:, :, 1] # 50th percentile (median) + upper_bound = quantiles[:, :, 2] # 90th percentile if response.samples is not None: samples = response.samples # Shape: (batch_size, horizon, num_samples) # Access metadata -print(response.metadata) # {'model_name': 'toto', 'model_version': '1'} +print(response.metadata) +# {'model_name': 'chronos2', 'model_version': '1.0', 'inference_time_ms': 123} ``` -## Async Usage +## Error Handling + +The SDK provides **machine-readable error codes** for robust error handling: ```python -async with ForecastClient(base_url="http://localhost:8003") as client: - response = await client.forecast_async(ModelName.FLOWSTATE, request) - print(response.point) +from faim_sdk import ( + ForecastClient, + ValidationError, + AuthenticationError, + RateLimitError, + ModelNotFoundError, + ErrorCode +) + +try: + response = client.forecast(ModelName.CHRONOS2, request) + +except AuthenticationError as e: + # Handle authentication failures (401, 403) + print(f"Authentication failed: {e.message}") + print(f"Request ID: {e.error_response.request_id}") + +except ValidationError as e: + # Handle invalid request parameters (422) + if e.error_code == ErrorCode.INVALID_SHAPE: + print(f"Shape error: {e.error_response.detail}") + # Fix shape and retry + elif e.error_code == ErrorCode.MISSING_REQUIRED_FIELD: + print(f"Missing field: {e.error_response.detail}") + +except RateLimitError as e: + # Handle rate limiting (429) + print("Rate limit exceeded - implementing exponential backoff") + retry_after = e.error_response.metadata.get('retry_after', 60) + time.sleep(retry_after) + +except ModelNotFoundError as e: + # Handle model/version not found (404) + print(f"Model not found: {e.message}") ``` -## Examples +### Exception Hierarchy -See the `examples/` directory for complete notebook examples: -- `flowstate_simple_example.ipynb` - Point forecasting with FlowState -- `toto_simple_example.ipynb` - Probabilistic forecasting with ToTo +``` +FAIMError (base) +├── APIError +│ ├── AuthenticationError (401, 403) +│ ├── InsufficientFundsError (402) +│ ├── ModelNotFoundError (404) +│ ├── PayloadTooLargeError (413) +│ ├── ValidationError (422) +│ ├── RateLimitError (429) +│ ├── InternalServerError (500) +│ └── ServiceUnavailableError (503, 504) +├── NetworkError +├── SerializationError +├── TimeoutError +└── ConfigurationError +``` -## Error Handling +## Async Support -The SDK provides specific exception types for different error scenarios: +The SDK supports async operations for concurrent requests: ```python -from faim_sdk import ( - ModelNotFoundError, - ValidationError, - TimeoutError, - NetworkError, - SerializationError -) +import asyncio +from faim_sdk import ForecastClient, Chronos2ForecastRequest +from faim_client.models import ModelName -try: - response = client.forecast(ModelName.FLOWSTATE, request) -except ModelNotFoundError: - print("Model or version not found") -except ValidationError: - print("Invalid request parameters") -except TimeoutError: - print("Request timed out") -except NetworkError: - print("Network communication failed") -except SerializationError: - print("Failed to serialize/deserialize data") +async def forecast_multiple_series(): + client = ForecastClient( + base_url="https://api.faim.example.com", + api_key="your-api-key" + ) + + # Create multiple requests + requests = [ + Chronos2ForecastRequest(x=data1, horizon=24), + Chronos2ForecastRequest(x=data2, horizon=24), + Chronos2ForecastRequest(x=data3, horizon=24), + ] + + # Execute concurrently + async with client: + tasks = [ + client.forecast_async(ModelName.CHRONOS2, req) + for req in requests + ] + responses = await asyncio.gather(*tasks) + + return responses + +# Run async forecasts +responses = asyncio.run(forecast_multiple_series()) ``` ## Configuration @@ -152,63 +241,122 @@ except SerializationError: ### Client Options ```python -# Without authentication +from faim_sdk import ForecastClient + +# Basic configuration client = ForecastClient( - base_url="https://api.example.com", - timeout=120.0, # Request timeout in seconds - verify_ssl=True, # SSL certificate verification - **httpx_kwargs # Additional httpx.Client arguments + base_url="https://api.faim.example.com", + timeout=120.0, # Request timeout in seconds (default: 120) + verify_ssl=True, # SSL certificate verification (default: True) ) # With API key authentication client = ForecastClient( - base_url="https://api.example.com", - api_key="your-secret-api-key", # API key for authentication + base_url="https://api.faim.example.com", + api_key="your-secret-api-key", + timeout=120.0 +) + +# Advanced configuration with custom httpx settings +import httpx + +client = ForecastClient( + base_url="https://api.faim.example.com", + api_key="your-api-key", timeout=120.0, - verify_ssl=True + limits=httpx.Limits(max_connections=10), # Connection pooling + headers={"X-Custom-Header": "value"} # Custom headers ) ``` ### Request Options ```python +# Compression options for large payloads +request = Chronos2ForecastRequest( + x=data, + horizon=24, + compression="zstd" # Options: "zstd", "lz4", None (default: "zstd") +) + +# Model version pinning request = FlowStateForecastRequest( x=data, - horizon=10, - model_version="1", - compression="zstd", # Options: "zstd", "lz4", None + horizon=24, + model_version="1.2.3" # Pin to specific version (default: "latest") ) ``` +## Context Managers + +Use context managers for automatic resource cleanup: + +```python +# Sync context manager +with ForecastClient(base_url="https://api.faim.example.com") as client: + response = client.forecast(ModelName.CHRONOS2, request) + print(response.quantiles) +# Client automatically closed + +# Async context manager +async with ForecastClient(base_url="https://api.faim.example.com") as client: + response = await client.forecast_async(ModelName.CHRONOS2, request) + print(response.quantiles) +# Client automatically closed +``` + +## Examples + +See the `examples/` directory for complete Jupyter notebook examples: + +- **`flowstate_simple_example.ipynb`** - Point forecasting with FlowState on AirPassengers dataset +- **`chronos2_probabilistic.ipynb`** - Probabilistic forecasting with quantiles (coming soon) +- **`batch_processing.ipynb`** - Efficient batch processing patterns (coming soon) + ## Requirements - Python >= 3.10 - numpy >= 1.20.0 - pyarrow >= 10.0.0 - httpx >= 0.23.0 +- pydantic >= 2.0.0 -## Development +## Performance Tips -### Regenerating the Low-Level Client +1. **Batch Processing**: Process multiple time series in a single request for optimal throughput + ```python + # Good: Single request with 32 series + data = np.random.randn(32, 100, 1) -The `faim_client` package is auto-generated from the OpenAPI specification. To regenerate after API changes: + # Less efficient: 32 separate requests + # for series in data: client.forecast(...) + ``` -```bash -# Get the latest OpenAPI spec from your server -curl http://your-server:8003/openapi.json > openapi.json +2. **Compression**: Use `compression="zstd"` for large payloads (default, recommended) -# Regenerate the client -openapi-python-client generate --path openapi.json --config client.config.yaml --meta none -``` +3. **Async for Concurrent Requests**: Use `forecast_async()` with `asyncio.gather()` for parallel processing -The `--meta none` flag prevents creating an extra outer directory. +4. **Connection Pooling**: Reuse client instances across requests instead of creating new ones -After regenerating, test that `faim_sdk` still works correctly: -```bash -poetry install -pytest tests/ -``` +## Support + +- **Documentation**: [docs.faim.example.com](https://docs.faim.example.com) +- **Issues**: [GitHub Issues](https://github.com/your-org/faim-sdk/issues) +- **Email**: support@faim.example.com ## License -Apache 2.0 \ No newline at end of file +Apache License 2.0 - See [LICENSE](LICENSE) file for details. + +## Citation + +If you use FAIM in your research, please cite: + +```bibtex +@software{faim_sdk, + title = {FAIM SDK: Foundation AI Models for Time Series Forecasting}, + author = {FAIM Team}, + year = {2024}, + url = {https://github.com/your-org/faim-sdk} +} +``` \ No newline at end of file diff --git a/faim_sdk/__init__.py b/faim_sdk/__init__.py index 4261e0c..2bcc25e 100644 --- a/faim_sdk/__init__.py +++ b/faim_sdk/__init__.py @@ -2,6 +2,76 @@ This SDK provides a high-level, type-safe interface for interacting with the FAIM inference platform for foundation AI models on structured data. + +Quick Start +----------- + +Install the SDK: + + pip install faim-sdk + +Basic usage: + + >>> from faim_sdk import ForecastClient, Chronos2ForecastRequest + >>> from faim_client.models import ModelName + >>> import numpy as np + >>> + >>> # Initialize client + >>> client = ForecastClient( + ... base_url="https://api.example.com", + ... api_key="your-api-key" + ... ) + >>> + >>> # Create forecast request + >>> data = np.random.rand(32, 100, 1) # (batch_size, seq_len, features) + >>> request = Chronos2ForecastRequest( + ... x=data, + ... horizon=10, + ... output_type="quantiles", + ... quantiles=[0.1, 0.5, 0.9] + ... ) + >>> + >>> # Generate forecast + >>> response = client.forecast(ModelName.CHRONOS2, request) + >>> print(response.quantiles.shape) # (32, 10, 3) + +Main Components +--------------- + +ForecastClient: + High-level client for making forecast requests with automatic + serialization, error handling, and observability. + +Request Models: + - FlowStateForecastRequest: For FlowState model with scaling options + - Chronos2ForecastRequest: For Amazon Chronos 2.0 LLM-based forecasting + - TiRexForecastRequest: For TiRex transformer-based forecasting + +ForecastResponse: + Contains prediction outputs (point, quantiles, samples) and metadata. + +Exceptions: + - AuthenticationError: API key issues (401, 403) + - ValidationError: Invalid request parameters (422) + - RateLimitError: Rate limit exceeded (429) + - ServiceUnavailableError: Temporary service issues (503, 504) + - And more... (see exceptions module for full hierarchy) + +Error Handling +-------------- + +The SDK uses machine-readable error codes for programmatic error handling: + + >>> from faim_sdk import ValidationError, ErrorCode + >>> + >>> try: + ... response = client.forecast(ModelName.CHRONOS2, request) + >>> except ValidationError as e: + ... if e.error_code == ErrorCode.INVALID_SHAPE: + ... print(f"Shape error: {e.error_response.detail}") + ... print(f"Request ID: {e.error_response.request_id}") + +For more information, see the individual module documentation. """ from faim_client.models.error_code import ErrorCode diff --git a/faim_sdk/client.py b/faim_sdk/client.py index 9d8f13f..d90e05c 100644 --- a/faim_sdk/client.py +++ b/faim_sdk/client.py @@ -486,29 +486,93 @@ async def forecast_async(self, model: ModelName, request: ForecastRequest) -> Fo ) from e def close(self) -> None: - """Close underlying HTTP client and release resources.""" + """Close underlying HTTP client and release resources. + + Should be called when the client is no longer needed to properly + release connection pool resources. Alternatively, use the client + as a context manager which handles cleanup automatically. + + Example: + >>> client = ForecastClient(base_url="https://api.example.com") + >>> try: + ... response = client.forecast(model, request) + ... finally: + ... client.close() + """ if hasattr(self._client, "_client") and self._client._client: self._client._client.close() logger.debug("ForecastClient closed") async def aclose(self) -> None: - """Close underlying async HTTP client and release resources.""" + """Close underlying async HTTP client and release resources. + + Async equivalent of close(). Should be called when the async client + is no longer needed. Alternatively, use the client as an async + context manager which handles cleanup automatically. + + Example: + >>> client = ForecastClient(base_url="https://api.example.com") + >>> try: + ... response = await client.forecast_async(model, request) + ... finally: + ... await client.aclose() + """ if hasattr(self._client, "_async_client") and self._client._async_client: await self._client._async_client.aclose() logger.debug("Async ForecastClient closed") def __enter__(self) -> "ForecastClient": - """Enter sync context manager.""" + """Enter sync context manager. + + Enables using the client with Python's 'with' statement for + automatic resource cleanup. + + Returns: + The client instance + + Example: + >>> with ForecastClient(base_url="https://api.example.com") as client: + ... response = client.forecast(ModelName.CHRONOS2, request) + ... # Client automatically closed on exit + """ return self def __exit__(self, *args) -> None: - """Exit sync context manager.""" + """Exit sync context manager and release resources. + + Automatically called when exiting a 'with' block. Ensures proper + cleanup of HTTP connections. + + Args: + *args: Exception information (exc_type, exc_value, traceback) if an + exception occurred within the with block + """ self.close() async def __aenter__(self) -> "ForecastClient": - """Enter async context manager.""" + """Enter async context manager. + + Enables using the client with Python's 'async with' statement for + automatic resource cleanup in async code. + + Returns: + The client instance + + Example: + >>> async with ForecastClient(base_url="https://api.example.com") as client: + ... response = await client.forecast_async(ModelName.CHRONOS2, request) + ... # Client automatically closed on exit + """ return self async def __aexit__(self, *args) -> None: - """Exit async context manager.""" + """Exit async context manager and release resources. + + Automatically called when exiting an 'async with' block. Ensures proper + cleanup of HTTP connections. + + Args: + *args: Exception information (exc_type, exc_value, traceback) if an + exception occurred within the async with block + """ await self.aclose() diff --git a/faim_sdk/exceptions.py b/faim_sdk/exceptions.py index 9c0c769..c4f9e83 100644 --- a/faim_sdk/exceptions.py +++ b/faim_sdk/exceptions.py @@ -29,6 +29,11 @@ def __init__(self, message: str, details: dict[str, Any] | None = None) -> None: self.details = details or {} def __str__(self) -> str: + """Return string representation of the error. + + Returns: + Error message with details if available + """ if self.details: return f"{self.message} (details: {self.details})" return self.message @@ -90,6 +95,11 @@ def error_code(self) -> ErrorCode | None: return self.error_response.error_code if self.error_response else None def __str__(self) -> str: + """Return detailed string representation of the API error. + + Returns: + Formatted string with message, status code, error code, request ID, and details + """ parts = [self.message] if self.status_code: parts.append(f"status={self.status_code}") diff --git a/faim_sdk/models.py b/faim_sdk/models.py index ac1158d..9630e4e 100644 --- a/faim_sdk/models.py +++ b/faim_sdk/models.py @@ -35,7 +35,15 @@ class ForecastRequest: """Arrow compression algorithm. Options: 'zstd', 'lz4', None. Default: 'zstd'""" def __post_init__(self) -> None: - """Validate common parameters.""" + """Validate common parameters. + + Automatically called after dataclass initialization to ensure + all parameters meet requirements. + + Raises: + TypeError: If x is not a numpy ndarray + ValueError: If x is empty or horizon is non-positive + """ if not isinstance(self.x, np.ndarray): raise TypeError(f"x must be numpy.ndarray, got {type(self.x).__name__}") @@ -80,7 +88,14 @@ class Chronos2ForecastRequest(ForecastRequest): Only used when output_type='quantiles'.""" def __post_init__(self) -> None: - """Validate Chronos2-specific parameters.""" + """Validate Chronos2-specific parameters. + + Automatically called after dataclass initialization to ensure + quantiles are valid probability values. + + Raises: + ValueError: If quantiles are not in the range [0.0, 1.0] + """ super().__post_init__() if self.quantiles is not None: @@ -88,7 +103,14 @@ def __post_init__(self) -> None: raise ValueError(f"quantiles must be in [0.0, 1.0], got {self.quantiles}") def to_arrays_and_metadata(self) -> tuple[dict[str, np.ndarray], dict[str, Any]]: - """Convert Chronos2 request to Arrow format.""" + """Convert Chronos2 request to Arrow format. + + Separates request into large arrays (sent as Arrow columns) and + small metadata parameters (sent in Arrow schema metadata). + + Returns: + Tuple of (arrays dict, metadata dict) ready for Arrow serialization + """ arrays, metadata = super().to_arrays_and_metadata() # Add Chronos2-specific metadata (small parameters) @@ -111,7 +133,14 @@ class TiRexForecastRequest(ForecastRequest): """Output type to return. Options: 'point', 'quantiles', 'samples'. Default: 'point'.""" def to_arrays_and_metadata(self) -> tuple[dict[str, np.ndarray], dict[str, Any]]: - """Convert TiRex request to Arrow format.""" + """Convert TiRex request to Arrow format. + + Separates request into large arrays (sent as Arrow columns) and + small metadata parameters (sent in Arrow schema metadata). + + Returns: + Tuple of (arrays dict, metadata dict) ready for Arrow serialization + """ arrays, metadata = super().to_arrays_and_metadata() # Add TiRex-specific metadata @@ -141,7 +170,15 @@ class FlowStateForecastRequest(ForecastRequest): 'quantile' (requires output_type='quantiles').""" def __post_init__(self) -> None: - """Validate FlowState-specific parameters.""" + """Validate FlowState-specific parameters. + + Automatically called after dataclass initialization to ensure + parameter validity and consistency between output_type and prediction_type. + + Raises: + ValueError: If scale_factor is non-positive, or if output_type and + prediction_type are incompatible + """ super().__post_init__() if self.scale_factor is not None and self.scale_factor <= 0: @@ -172,7 +209,14 @@ def __post_init__(self) -> None: ) def to_arrays_and_metadata(self) -> tuple[dict[str, np.ndarray], dict[str, Any]]: - """Convert FlowState request to Arrow format.""" + """Convert FlowState request to Arrow format. + + Separates request into large arrays (sent as Arrow columns) and + small metadata parameters (sent in Arrow schema metadata). + + Returns: + Tuple of (arrays dict, metadata dict) ready for Arrow serialization + """ arrays, metadata = super().to_arrays_and_metadata() # Add FlowState-specific metadata @@ -237,6 +281,11 @@ def from_arrays_and_metadata(cls, arrays: dict[str, np.ndarray], metadata: dict[ ) def __repr__(self) -> str: + """Return string representation of forecast response. + + Returns: + Human-readable string showing available outputs and their shapes + """ outputs = [] if self.point is not None: outputs.append(f"point.shape={self.point.shape}") From 4bf60e5e88db8a74d3cbca525a8c15b0f605f3af Mon Sep 17 00:00:00 2001 From: Andrei Chernov Date: Sun, 2 Nov 2025 21:53:41 +0100 Subject: [PATCH 03/10] updated --- README.md | 10 +- examples/flowstate_simple_example.ipynb | 162 +++++++++++++++--------- faim_sdk/__init__.py | 11 +- 3 files changed, 118 insertions(+), 65 deletions(-) diff --git a/README.md b/README.md index 9a20fec..4d7ca97 100644 --- a/README.md +++ b/README.md @@ -1,7 +1,7 @@ # FAIM SDK [![PyPI version](https://badge.fury.io/py/faim-sdk.svg)](https://badge.fury.io/py/faim-sdk) -[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/) +[![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/downloads/) [![License: Apache 2.0](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0) Production-ready Python SDK for FAIM (Foundation AI Models) - a high-performance time-series forecasting platform powered by foundation models. @@ -315,9 +315,9 @@ See the `examples/` directory for complete Jupyter notebook examples: ## Requirements -- Python >= 3.10 -- numpy >= 1.20.0 -- pyarrow >= 10.0.0 +- Python >= 3.11 +- numpy >= 1.26.0 +- pyarrow >= 11.0.0 - httpx >= 0.23.0 - pydantic >= 2.0.0 @@ -359,4 +359,4 @@ If you use FAIM in your research, please cite: year = {2024}, url = {https://github.com/your-org/faim-sdk} } -``` \ No newline at end of file +``` diff --git a/examples/flowstate_simple_example.ipynb b/examples/flowstate_simple_example.ipynb index a0fff6a..1382c86 100644 --- a/examples/flowstate_simple_example.ipynb +++ b/examples/flowstate_simple_example.ipynb @@ -16,8 +16,8 @@ "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2025-11-02T13:09:29.782458Z", - "start_time": "2025-11-02T13:09:29.780008Z" + "end_time": "2025-11-02T20:14:00.516676Z", + "start_time": "2025-11-02T20:14:00.512097Z" } }, "source": [ @@ -31,8 +31,8 @@ "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2025-11-02T13:09:30.664688Z", - "start_time": "2025-11-02T13:09:29.885721Z" + "end_time": "2025-11-02T20:14:02.793038Z", + "start_time": "2025-11-02T20:14:00.532314Z" } }, "source": [ @@ -59,8 +59,8 @@ "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2025-11-02T13:09:31.749271Z", - "start_time": "2025-11-02T13:09:30.681133Z" + "end_time": "2025-11-02T20:14:05.421657Z", + "start_time": "2025-11-02T20:14:02.930056Z" } }, "source": [ @@ -112,8 +112,8 @@ "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2025-11-02T13:09:31.764649Z", - "start_time": "2025-11-02T13:09:31.759429Z" + "end_time": "2025-11-02T20:14:05.451275Z", + "start_time": "2025-11-02T20:14:05.439088Z" } }, "source": [ @@ -195,8 +195,8 @@ "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2025-11-02T13:09:31.803405Z", - "start_time": "2025-11-02T13:09:31.796959Z" + "end_time": "2025-11-02T20:14:05.506011Z", + "start_time": "2025-11-02T20:14:05.499919Z" } }, "source": [ @@ -240,8 +240,8 @@ "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2025-11-02T13:09:31.971193Z", - "start_time": "2025-11-02T13:09:31.871029Z" + "end_time": "2025-11-02T20:14:05.758916Z", + "start_time": "2025-11-02T20:14:05.615480Z" } }, "source": [ @@ -278,7 +278,7 @@ "text/plain": [ "
" ], - "image/png": "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" + "image/png": "iVBORw0KGgoAAAANSUhEUgAABW0AAAGGCAYAAAAAW6PhAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnQeYXVW5/tf03msmmfRGS+gBpDcFQZqogFcUFPQqKKhcUa+KcMXK34ZcC4KoCIJcQFQUIhA6hBASSEhPJmV67/X8n2/t/e2zz5lTdll7nz0z7+95hhlmJmf22XWtd73f+6WFQqGQAAAAAAAAAAAAAAAAABAI0lO9AQAAAAAAAAAAAAAAAADCQLQFAAAAAAAAAAAAAACAAAHRFgAAAAAAAAAAAAAAAAIERFsAAAAAAAAAAAAAAAAIEBBtAQAAAAAAAAAAAAAAIEBAtAUAAAAAAAAAAAAAAIAAAdEWAAAAAAAAAAAAAAAAAgREWwAAAAAAAAAAAAAAAAgQEG0BAAAAAAAAAAAAAAAgQEC0BQAAAACYIXzrW98SaWlp4tlnn03pa/gBbR9tJ20vSMzu3bvlvvr4xz8eiF01MDAgZs+eLa655ppUbwqwyZYtW0RmZqb4xS9+gX0HAAAAuASiLQAAAADi0t/fL77zne+II488UhQWFoqcnBwxZ84ccdJJJ4mbb75Z7NixY8buvfnz58sPN9x3331SLKOP119/fcoKlV6LfiwUW/2YikLtiy++KC699FIpVmZnZ4uysjKxfPlycfnll4vf/e53Yibxgx/8QLS1tYmvf/3rEd9fv369+OpXvyre+973iqqqKnmsTz311LivQ+djsnPl1ltvnfTvtm7dKj70oQ+JyspKkZeXJ1auXCnuuusuEQqFYv6dnp4eceONN4p58+bJeyTdF7785S+Lvr4+W++b3t9///d/i+OOO05UV1fL11q4cKH4z//8T7F///64/87r7e3q6hLf+MY3xIoVK0RRUZH8O8ccc4z4+c9/LoaGhiJ+d9myZeKyyy4Tt9xyi+jt7bX1/gEAAAAQSWbU/wMAAAAASGjCfeKJJ4oNGzaIxYsXi49+9KOioqJCiimvvfaa+O53vysWLVokP4Az7r77bikckbjy29/+VgohXvK5z31OfOQjHxFz585N6WvYJZYwRwLXY489Jk455ZRJP6f/P/bYY8XmzZulwBR07r33XnHVVVdJh+K5554rlixZIs8Lci3+/e9/F2vWrBFXXnmlZ3+fhGLaVyUlJSLVkKD4wx/+UHz4wx+edI49+uij4vbbb5ei9tKlS+W9KBEXXnhh3IUV+hu0KEUCsJlNmzaJE044QQwODkohtK6uTvztb3+Twin97Gc/+1nE79Nr0DlI5+PZZ58tBcs333xTvv5zzz0nj11ubq6l9/7pT39avPrqq/LcpWuMBFX6fxJgH3roIfH8889LId/P7SXB9qijjhI7d+6Uz4Nrr71WDA8Pi3/84x/iuuuuE//3f/8nnnrqKZGeHvYC3XTTTeIPf/iD+OlPfyq+9rWvWXrvAAAAAIhBCAAAAAAgBt/+9rfJphX65Cc/GZqYmJj08507d4Y2b948Y/fdvHnz5IdTtm7dKvfvBz7wgdDSpUtDJSUloYGBAVfb9Mwzz8jX/OY3vxnyk127dsm/e+WVV/r2N++5556UvFfV9Pf3h4qKikLFxcWht99+e9LPR0ZGQv/6179CM4Wf//zn8rg+9dRTk35G++eNN96Q+6SxsVH+3imnnGL7b6xdu1b+28MOO2zSz04++WT5s7///e/G94aHh0MnnXSS/P5LL70U8fvf+MY35Pf/67/+K+L79P/0/e985zuWt+unP/1paNu2bZO+/93vfle+1rnnnuv79n7ve9+T3//CF74Q8X36G0cffbT82XPPPTdpu1asWCHvj+Pj45bfPwAAAAAigWgLAAAAgJicc845ckL+5ptvWt5DiUSUWCIniXz0b0gA/slPfhJatmxZKDs7OzR37tzQt771rUkTfvr/X//616FjjjkmVFZWFsrNzQ3Nnj07dN5550nBMpZ4+fzzz8ttKiwslMLoxRdfHFMYITZu3Bi69NJLQ1VVVXI75s+fH/r85z8famtrmyRQxvqwIyB+5Stfkf/m4YcfDt16663y6/vuuy/u7+/YsSP0qU99Sm4TbRttI70vEi8J+tvxtou22fw7vK92794dSktLC5122mkx/yaJYxUVFaE5c+YYxyL6NVg8jfVBv/O1r31Nfv3ggw/G/Bt33323bXHL/Hfj7fN4Ajafh11dXaFPf/rTodra2lB+fr4UuUgQJPbv3x+64oor5D6mc+yss86SInss6Ny9+uqrQ/X19fK40OvReU371gqvvvqq3M4LLrggZJdHH300dPrpp4dKS0tDOTk5oUMOOST0gx/8IDQ2NhZzX9Hnxx9/PHTCCSfI64Gvx0Sie09PjxT6Dj74YLkv6Bo6++yz5XUVzYEDB0LXX399aPHixcbvLl++PHTttdfK/W2Fo446KlReXp5U7HMj2n7mM5+R//bHP/5xxPe3bNkivx/renj22Wflzz7xiU8Y36PFrLq6Orkv+/r6In6f/p++v3DhwpBb6Hjm5eWFCgoKfN9eOnb0OrEWDr761a8a97BobrvtNvmzp59+2tF7BgAAAEAohExbAAAAAMSEohA4L9FrKE+RsiWPP/54WSJMUC4p5TuaoRzdT33qU6Kjo0NmfX7hC18Qp59+unjnnXfE008/Pel1X3nlFXHGGWfIsm8q5aWyYCrnpXJiKvc188ILL4hVq1bJn9O/4czHn/zkJ/L7XIpdWloqvvnNb8rXpA/6mj8S5WuaGR8flzmllFt63nnnif/4j/+Q5fAUlxAL2rYjjjhC/OY3v5Hl0bRtF198sSyJpu0j6G9zCT29T/N20TbHgt7fySefLMui9+3bN+nnVJrf3t4urrjiiojyZzOHH364+PznPy+/pixN89+l0nQ6XvRvadtj8etf/1rGAnziE58QfjEyMiLOOussmSNLZfgf+MAH5NdnnnmmePfdd+V5uH37dhkJQr9H5d/vf//75XEzQ6XrdFzoWFIJOe0Hynv+4x//KEvco8+xRNcZ/W706yeCrgUq/6cIBToXqBye8kzpWqLS+lhQiT39LuWl0u+fc845Cf8GXWe0L7797W/Lc5WuzUsuuUS88cYb4rTTTpNxBebmYe95z3tkOT5FptD1RpmyFGPw+9//XrS2tiZ9T52dnbJUn/ZdvPPNLXTN3H///TJ6gK47M9xcj2IDoqFogIKCAnmtMNu2bRMHDhyQ75t+Zob+n75Px3Xv3r2utpnuDVlZWfI68Xt7Dz30UONeEH0N0XVB5xydI9Hw91avXu3wXQMAAAAATlsAAAAAxOSxxx6TTikq3f7iF78Y+uc//xnhOFXptF2wYIF06TGtra3SPUh/m8pwGXLgkVOMSsqjaW9vn+SypI///d//jfg9+n/6PrlzGXL1LVq0SH7/ySefjPj9L3/5y/L7V111VdL3YxVyO9JrkovNXOZMrtdoF/DQ0JB0E6enp4f+8Y9/THqtvXv3Tnrf8dyn0S5Z4je/+Y38HpVBR3PJJZfIn5nL9mO9RrJ4BHJt03tjxy9Dr0v/7sILLwzZxY3Tlr5PjurR0dFJZeB03t1www0RkSDszPzLX/4S4UIm1zOdo+vWrYv4G+RCzcjIiDjH4kF/h9yl9PonnniidJKT4zvaLWuGXI/0++9973sjHJP0WuQejnY/8r6icyhW7EC843f55ZfL79M2mWlubpbOYnIiDw4ORpzT0WX0RG9vrzyPk/G3v/1Nvga5s5Ph1GlLbnb6dx/5yEcm/exLX/pSXOcoceihh8p9yOfNE088IX//c5/7XMzfp+/Tz1evXh1yA7nU+Zz1e3spsuW4446T3yc3Ov3N6667Tt4va2pq5HGPRXd3t/w3dF8DAAAAgDPgtAUAAABATMh9+KMf/Ug2yaLP1LCHmjpRUzJqRkWuLVWQo3bWrFnG/9PfueCCC2QzNHISmqEmRBkZGZNeo7y8fNL3yOVHTk8z9P/U6Ima9bD7j1yWO3bskM7D6MZE1DWdXpvceeQuUwE7aj/2sY8Z36OvuSGZGWq2RZ3jyfX5vve9b9JrzZkzx9W2fPCDH5SNh6hxkBlqQPTEE09IJ+0hhxzi6m+QQ5PeW7STmN230cfID6jxktm5SA2ZiLGxMXHbbbdJd2P0z9566y3je7Rvdu/eLZ2t5LaNdjnS+UvuRGqslQj6Ow8//LB0OZKjmvbFYYcdJoqLi6Xzl5qURTtwf/7zn8vPv/rVryIck/Ra1CCQPv/pT3+a9Ldom+g1rUDO8gcffFA62T/5yU9G/IycuvS+6fqJdriT8zKawsJC6WxNBru9a2pqhFfwORj9noju7m75OV5DNjomExMT8r5k9ffNv+cEcr1ef/31cr9SNYLf20t/99///rd08VMjNLpuyE1N5z5dF1S1EO+16L4Sy8EPAAAAAGtE1tgAAAAAAJigMnwSkZ588knx0ksvibVr18qS8DvvvFOKHyTqkLjrFiotjydGknjIUNn3L37xC1myS19TiTaV4cYSiggSwqLLrOn/6fskOpMIRyIWlWQTseINSHA6+uijxb/+9S8pIJOg5oampiYpGJP4bRY8Lr30UllSTqX2JM6wMP3aa6/FLYFWAQk4dAz//Oc/y/1BEQdcSk9d4qNLyJ1A0QKzZ88W99xzj4y9oPdGAjiVzdfX18cUo72ESv3nzp0b8T1eNCBBPz8/P+bPqLTcHL1B0DlB7ynWcSbBjOJF6PxJBMVIkGC7fv16KYLSdUYLCVRaTh/33Xef+Mc//mEIn/S3SayNFvgZuh4o5iEaih2wyuuvvy7FYjoHYr0/XrShv0MRHxSzQfuJRGM6j+h7FNNx0EEHRQjgiaAoDiJenIdbKPJizZo1YsGCBVKM9hs6vuZICT72FCMRb3+ce+65oqWlRZ4Dy5YtE35DwjyJ/fSZFiHo3klRGLSY9MUvflEuXlBcBgu+Zmixi2NlAAAAAGAfiLYAAAAASEhRUZEUFOmDXVhf/epXpXh69dVXSxcouV/dEGvCzy5Is8uQ8ltJcCHxj9yQ9EFurg996EPSDUwOXTPxHHv8fXaUsRsy3u+zaJfMNWkFEmXJzRkthtI+IHHkgQcekCI5CZ3mbSTR0ytoW0i0Jbcti7YkqJK4StnBbqHXIWfjLbfcIsVHEvQoO5hEKXJte5Vf6uR8S/Sz0dHRiLxXgvJrE9Hf3295u8jVTB/mzFJyWD/zzDPyervhhhuMv03nEO1PO3/XjoOV3x+Jx/SR7O+Q+E9iMjnT//rXvxoZqCTKf+UrX5EZusngxZehoSHhBSRyk+P7qquuiikkswM1njOWrn/6d3RPtPr75t8j0Tb6mJGwHUu0pWuDsrUpr/uuu+6S54Hf20vQOffyyy9LIX7FihXGNXLttdfK40S54uS8/drXvhYzPzh6AQQAAAAA1kE8AgAAAABsQRN6Ks+mJlbkotq4caPxMxIISEyKhZsSYbN49qUvfUkKGSQWU2QBNX4iFxo1y4qmubk55uvw91mcYKEu3u+Ta9L8e25gdyQ16qL9Zf4gwZYwxwiw65Der1eQ07WqqkqW1JM7lEqfyflJLuTa2lolf4NEWxJvqfEYRyOQWEsC2lSEzwUSKEkIjPdBopxTyPnNJfFUom7+29TALNHf3bVr16TXs+p4Nb8/clMm+jt0HjPkXqY4B3Jlknv9e9/7njyfPvvZz8aMa4iGzkGzYKwSbv5H52C8pnfksiZiRb/Qv6d9SotGLOIn+n3z9/n3SJyN3n/cTCyWYEtCKd1rSSBNxfYStMhCjlkWbM1QpQPBlQpm6LjTPZ+PKQAAAADsA9EWAAAAALYh8Se6+ziXnccSF0kENMccqKCurk5mKpIrlaIGqKycnF1myCFI4oEZ+n+KeqD3wK5SziSNJaCQk5DK1ckFaC5PJvEnOms0GZQJSeXyixYtki7lWB8kclDJMZVEm0vaKZ4hGRypYHe7SNShuAk6duTqJPcoCUqx3H1O/y7FXZB7mByYtP+p7J/yg6NjCqYKq1atkp/JheglFM8R62+TsKcyVzqaY445Rl4jTt4fifHkGL7pppsMsfbxxx9P+u84eiQ6x1oFdN5RvAUtUMRzrbPAHutao0UMuheYRXgSN+k+RPeZaGcz/T99n0RTchtbxSzYkoM1kUPZj+2lGBNy4MbK8+ZM8Fh5xXRu0r3WbZwMAAAAMJOBaAsAAACAmPzyl7+UuZaxoFzGzZs3Sxco5cuahR4SaJ977jnjezTZp2xct1C2Jol90ZDY0NfXJ7KysiaV2ZNAys5Ohv6fvk8CIrvAKKeRhFRylUU3VqIIBhJSSCA2x0BwXqOdUm520FIpMTlNY32QI5XK8Mk9TFDeLAmeFF3wz3/+c9JrmkVybsZGzYvswnENFItAHyTKX3TRRZb+LYn1JPAl+7vkGCQnNkVtkCicigZkqqAoCxKc77jjDpmTGg0dQxLOkkFuSHJTcrMoM5QdSpEg3NyMocZUBLmUOQc22hlO16cbyGFNsSN0zf3gBz+QxysayrembSTI/R7Lqc7foxiTZJDAR+cwva5q+NqjhZF40KIMZfPSwgXdC8z3MGqWGN3AjM55+n+6/0Q3CaP/p+/bOcfJYUzudhJs6bhTdEgi/NheujfSNRv9+3Tfo3uj2XFrho+hG6c5AAAAMNNBpi0AAAAAYkIiwKc//WnpYqWJOzm0SCClUlhyjJJASjmbZpcVibPk+qLmOSRyUp7hU089JcVdzoV1CrloaTuWLl0qG5eRYEYiA7lSSaSi2IRoxxc5OUngIpfdIYccIoUlKmen7FsWwwh6L1TWTb9P206iIsU/kMuQ3Lck6FKDJTPUyIgcuOecc46MaCBBlwQU+ogFudWouReJoZwPHAsqob799tulyMTvifJmySFIf4s+k0OYXo8yMkk04/Lk5cuXy+NEMQv070jsJaGGGpzF6xhvFtxJBKLICRIcScSN5aaO5walf0/iJf07cvTRPqWvaT8ytO30/3v27JGi4Pnnny+mKrR/H374YXlMSJii84FER9rf9P7oGqEIg1gNwcxQCTkdny9/+ctSmKVFEHJ1kxhPDetIlKXznX7HvB9JlCMhja5P3q/0u9Rsi/42CWrUBMwNdH2T65UcsyTkU9M/upZJnKdzn9yUjY2NxnVO74GvUXrvO3fulA5bEmwpIiEZtO9IDKdrcd++fUYzQob2JV+H7Kqn75kzYenfxhKOaV9Spm+yc47eM72HCy+8UHz4wx+W9y36t3TvIBHV3DyQoH1DTbkoCoKuwyOPPFKsW7dO3gfpmqDMV6tcfPHF8pqm65gE3FgN4Oj1zI3avN5euhfR4gOdT3SM6fVo39Pzgc5zOic+9rGPTdpO+l1y8FN+NQAAAAAcEgIAAAAAiMG7774b+v73vx8666yzQgsWLAjl5ubKj0WLFoWuvPLK0Nq1a2Put4ceeih02GGHhbKzs0O1tbWh6667LtTb2xuaN2+e/DBDr0PDkV27dk16nW9+85vyZ88884z8/5GRkdD3vve90Nlnnx2aM2eOfP2amprQySefHLr//vtDExMTxr+lf0P/ll7j+eefD51yyimhgoKCUHFxceiiiy4Kbdu2Lea2b9iwIfTBD34wVFlZGcrKypLb+/nPfz7U2to66XfpPX3qU58KzZo1K5SRkWH8vXj88pe/lL9D7zkZ73nPe+Tvvvjii8b3tm/fHrr66qvle6dtq66uDp166qmh++67L+LfvvLKK/L9FhUVydcw79/ofRrNbbfdZvybf/7znzF/J95rbNmyJXTuueeGSktLQ2lpaXH/zte//nX5s6985SshN9xzzz0J97n5HDAT6zxk6Pdp30VD+y/esdu3b588R5YsWRLKycmR59hBBx0U+uQnPxlavXp10vcxNDQU+stf/hK65pprQitXrpTnHp1PZWVloRNPPDF0xx13hAYHB2P+26eeeip0/vnnh6qqquQ5Qdfb8ccfH7r11ltDDQ0Nk/YVfY5Fovc3MDAg7wNHHXWUvIby8vLk/eDCCy+U597o6Kj8vU2bNsn9cMQRR4QqKirkvli4cKF8zXfeeSdklVdffVVuC13r8Y5poo9Y0GvRz2666SbL9z66D5SXl8v3QfezO++8M+IeY6arqyv0hS98IVRfXy+Pw9y5c0Nf/OIXQz09PSE70HmZ7P3Fuld6vb10bdNxpN+j36dzYMWKFfI8o/Mjmv7+/lBhYaE8RwAAAADgnDT6j1PBFwAAAAAgiJA7lkp2qUlSLLcaSB3kvCPnM0VUkEsUgGjIuU55qZs2bZoUeQKCD8W8UMwCxeTEqzwAAAAAQHIwCgIAAAAAAL5AIhwJtmeddRYEWxAXytClWAaK+QBTC8q//c53viOzuCHYAgAAAO5Api0AAAAAAPAUysklEY6bq5EDGoB4HHfccbIR4vj4OHbSFKOhoUFm3HJjQwAAAAA4B6ItAAAAAADwlF/96leyORY1y6IGa9HNkQCI5pprrsFOmYIsXLgQkTQAAACAIpBpCwAAAAAAAAAAAAAAAAECmbYAAAAAAAAAAAAAAAAQICDaAgAAAAAAAAAAAAAAQIBApq0QYmJiQhw4cEAUFRWJtLS0VB8TAAAAAAAAAAAAAADANCQUCone3l5RV1cn0tPj+2kh2gohBdv6+no/jw8AAAAAAAAAAAAAAGCGsnfvXjFnzpy4P4doK4R02PLOKi4uFtPdVdza2iqqqqoSqvkATGdwHQCA6wAAPA8AwLgIAMwPAMA8ORX09PRI8yjrkfGAaCuEEYlAgu1MEG2Hhobk+4RoC2YquA4AwHUAAJ4HAGBcBADmBwBgnpxKkkW0wmoJAAAAAAAAAAAAAAAAAQKiLQAAAAAAAAAAAAAAAAQIiLYAAAAAAAAAAAAAAAAQICDaAgAAAAAAAAAAAAAAQICAaAsAAAAAAAAAAAAAAAABAqItAAAAAAAAAAAAAAAABAiItgAAAAAAAAAAAAAAABAgINoCAAAAAAAAAAAAAABAgIBoCwAAAAAAAAAAAAAAAAECoi0AAAAAAAAAAAAAAAAECIi2AAAAAAAAAAAAAD6wenOzOO9nz4u393djfwMAEgLRFgAAAAAAAAAAAMAHHnlzv3h7f4/49hObsL8BAAmBaAsAAAAAAAAAAADgA31DY/Lza7s6xMs72rHPAQBxgWgLAAAAAAAAAAAA4AN9w5poS/xk9VbscwBAXCDaAgAAAAAAAAAAAPjotCVe2dkhXt0Jty0AIDYQbQEAAAAAAAAAAAB8dNqumFMiP/9k9TbsdwBATCDaAgAAAAAAAAAAAPhA79Co/Pzl9y4TWRlp4qUd7eL13R3Y9wCASUC0BQAAAAAAAAAAAPCYUChkOG2X1RSJDx5VL7/+Kdy2AIAYQLQFAAAAAAAAAAAA8JiBkXExEdK+LszNFP956iKRmZ4mnt/WJt7e3439DwCIAKItAAAAAAAAAAAAgMewyzY9TYi8rAxRX54vTlhcKb/3zgGItgCASCDaAgAAAAAAAAAAAHhM75Am2hbmZIq0tDT5dV1Jrvzc1D2M/Q8AiACiLQAAAAAAAAAAAIBPTtui3CzjezXFmmjb3DuE/Q8AiACiLQAAAAAAAAAAAIDH9OlO26LczMmibTdEWwBAJBBtAQAAAAAAAAAAADymb3jUiEdgakty5Gc4bQEA0UC0BQAAAAAAAAAAAPAr0zaG0xaZtgCAaCDaAgAAAAAAAAAAAPjYiCxatG3vHxaj4xM4BgAAA4i2AAAAAAAAAAAAAL41IguLtuX52SIrI02EQkK09g7jGAAADCDaAgAAAAAAAAAAAPgk2pqdtunpaaK6SI9I6EEzMgBAGIi2AAAAAAAAAAAAAL7FI2RFfL+mWGtG1gLRFgAQFNF2zZo14vzzzxd1dXUiLS1NPProoxE/p+/F+vjBD35g/M78+fMn/fy73/1uCt4NAAAAAAAAAAAAgPV4hMhmZHDaAgACItr29/eLlStXijvvvDPmzxsbGyM+fvvb30pR9pJLLon4vW9/+9sRv3fdddf59A4AAAAAAAAAAAAAktM3NCo/F8YRbZuRaQsAMBF5p/CZc845R37Eo7a2NuL/H3vsMXHaaaeJhQsXRny/qKho0u8CAAAAAAAAAAAABM5pa8q0jRBt4bQFAARFtLVDc3Oz+Nvf/iZ+97vfTfoZxSHceuutYu7cueLyyy8XN9xwg8jMjP/WhoeH5QfT09MjP09MTMiP6Qy9v1AoNO3fJwCJwHUAAK4DAPA8AADjIgD8nh9wpm1+dkbE36opyjYakWGuDlIF5sn+YfU6nzKiLYm15Ki9+OKLI75//fXXiyOPPFKUl5eLl156Sdx8880yIuGOO+6I+1q33367uOWWWyZ9v7W1VQwNDU37E6O7u1s+kNLT0YcOzExwHQCA6wAAPA8AwLgIAL/nB139mnlsdKBXtLSERZvsiUH5eX9Hv2hpacGBASkB82T/6O3tnV6iLeXZXnHFFSI3VysbYG688Ubj6xUrVojs7Gxx7bXXSmE2J0frwBgNCbvmf0dO2/r6elFVVSWKi4vFdL8IKReY3itEWzBTwXUAAK4DAPA8AADjIgD8nh8MjoXk57mzqkR1daHx/eVp+UKIbaJ9YExUV1fjwICUgHmyf0Rrm1NatH3++efFli1bxIMPPpj0d1etWiXGxsbE7t27xbJly2L+Dom5sQRdujnPBCGTHkYz5b0CEA9cBwDgOgAAzwMAMC4CwK/5Abl4OdO2OC874u/UluYbmbeDoxOiICrzFgC/wDzZH6zeZ6aEanf33XeLo446SqxcuTLp765fv16+eaxOAQAAAAAAAAAAIAgMjU6I8QnNaVuYGynKFuZkyg/OtQUAACKlyzd9fX1i+/btxv/v2rVLiq6UT0tNxTi64KGHHhI/+tGPJv37l19+Wbz66qvitNNOk3m39P/UhOyjH/2oKCsr8/W9AAAAAAAAAAAAAMSid3hUfk5LE6IgO2PSz6uLc0Rf65ho7hkSi6rC0QkAgJlLSkXbtWvXSsGV4ZzZK6+8Utx7773y6wceeECWEVx22WWT/j1FHNDPv/Wtb4nh4WGxYMECKdqa82oBAAAAAAAAAAAAUknfkBaNQI5aKkGPprY4V+xs7ZeiLQAApFy0PfXUU6Ugm4hrrrlGfsTiyCOPFK+88opHWwcAAAAAAAAAAADgHs6zLYqTV0uiLdHcM4zdDQCYOpm2AAAAAAAAAAAAAFPeaRuVZ8tU66JtUzectgAADYi2AAAAAAAAAAAAAB7SY4pHiEVtcY783NIL0RYAoAHRFgAAAAAAAAAAAMCHeITC3KyYP6+B0xYAEAVEWwAAAAAAAAAAAAAP6RsaTZhpW1OCTFsAQCQQbQEAAAAAAAAAAAD8aEQWJ9OWnbYUjzAxkbhhOwBgZgDRFgAAAAAAAAAAAMBDejkeIY7TtrpIy7QdHQ+JzoERHAsAAERbAAAAAAAAAAAAAC/p40ZkcZy2WRnporIwW37d1INmZAAAiLYAAAAAAAAAAAAA/jQii+O0NUckNEO0BQBAtAUAAAAAAAAAAADwlt6hxJm2kaLtMA4HAADxCAAAAAAAAAAAAAC+xCPkZCUVbZu6EY8AAIBoCwAAAAAAAAAAAOBPI7KETlutGVlLL0RbAABEWwAAAAAAAAAAAABP6RseTZppWwunLQDARLr5fwAAAAAAAAAAAACAN/EIxci0BQBYBKItAAAAAAAAAAAAgEeEQiHRZykegRuRIR4BAADRFgAAAAAAAAAAAMAzhscmxOh4KHk8Qokm2rb3j4iRsQkcEQBmOHDaAgAAAAAAAAAAAHgEu2yJguz4om1ZfpbIztBkGjQjAwBAtAUAAAAAAAAAAADwiF49z5ZctunpaXF/Ly0tTVQV5civW3uHcTwAmOFAtAUAAAAAAAAAAADwuAlZomgEpkjPvGWhF0xtKJ/4tic2id1t/aneFDAFgWgLAAAAAAAAAAAA4BG9w6NJm5BFi7bmSAUwdXlo7V7xmxd2iTuf2Z7qTQFTEIi2AAAAAAAAAAAAAB47bVmQTURRbpb83DukCb1gatM9qB3HzU09qd4UMAWBaAsAAAAAAAAAAADgEeyaRTyCdzy1qVk8t7VVDI+NiyDRP6Jtz9bmPjE2PpHqzQFTjOTLPAAAAECKCYVCsjEDAAAAAAAAU1W0teK0ZWEXmbbWebOhU3zqvrXy6/zsDHHSkkpxxvIa8YHD60RuVoZIJQP6sR8ZmxC72/vF4uqilG4PmFrAaQsAACDwgu1lv35FfPQ3r8qvAQAAAAAAmEqwAGvNacvxCMi0tUpj95Dx9cDIuPjnO83ipr9sELf8dZMIitOWeLepN6XbAqYeEG0BAAAEms6BUfHKzg7xwvY2+TUAAAAAAABTMx5BE2QTwW5cZNpah4Ra4uSlVeKJ604UHz1urvz/tbs7RKoZGAmL7+82QrQF9oBoCwAAINCYBzqtvcMp3RYAAAAAAADswgJsoaVGZJkRQi9IzqA+XyjIzhCHzi4R15++RP7/jtY+MTSa2ozb/mGz0xbNyMAUEm3XrFkjzj//fFFXVyezCh999NGIn3/84x+X3zd/vO9974v4nY6ODnHFFVeI4uJiUVpaKq6++mrR19fn8zsBAADgFYOmkiKItgAAAAAAYKrRp0cdFFmKR0CmrVOnbV62ll9bVZQjKguzxUQo9ZEEEU5bxCOAqSTa9vf3i5UrV4o777wz7u+QSNvY2Gh8/OlPf4r4OQm277zzjnjqqafEE088IYXga665xoetBwAA4OcgjGjtC+dVAQAAAAAAEIvNjT3i9B89Kx5bvz9Y8QhWnLZ6hALiEezPF6gJGUGGv4NmFcuvNx3oCYzTdl/noOjRXdcAWCH5HcNDzjnnHPmRiJycHFFbWxvzZ5s3bxZPPvmkeP3118XRRx8tv/ezn/1MnHvuueKHP/yhdPACAACYRqIt4hEAAAAAAEASnt/WKna29osHX98rLjh8dsr3FzcVYxdtIljY7UU8gmUG9QiEvCxNtCUOrisWz29rE5sau0UQnLZpadRgWYitTb3i6PnlKd0mMHVIqWhrhWeffVZUV1eLsrIycfrpp4vbbrtNVFRUyJ+9/PLLMhKBBVvizDPPFOnp6eLVV18VF110UczXHB4elh9MT4+28jIxMSE/pjP0/qj7+nR/nwAkAtfB1KJ/OLwa3dIzjPuXInAdAIDrAAA8D8B0pV8XPLc09VoaO3o9LmKnLWWuJvsbhbpblIRezNvtHe/crPD+Pai2yHDapnI/9usGlCVVhWJrS590gR85t1QEEcwP/MPqORlo0ZaiES6++GKxYMECsWPHDvHVr35VOnNJrM3IyBBNTU1S0DWTmZkpysvL5c/icfvtt4tbbrll0vdbW1vF0NDQtD8xuru75QOJxG0AZiK4DqYWTW3hrq9727pFS0tLSrdnuoDrAABcBwDgeQCmK21dWo5pe/+I2Lxrv6go0CIHUjUu6u7XTGOjA72ipSWU8HdH9N/tGRzBuNcinT1aX6OJkUFjn9XmjBmibWNTs8hITxN+MzYeEiNjuohcnStF2zd3tYizFuSKIIL5gX/09vZOfdH2Ix/5iPH1YYcdJlasWCEWLVok3bdnnHGG49e9+eabxY033hjhtK2vrxdVVVWyodl0hi5Cyneh9wrRFsxUcB1MLbL2jhhf946mTVqsA87AdQAArgMA8DwA05VQRniRv2M8RxxUXZnScdHgmCbU1tdWiepqzQEaj6xCGvu+LYbHQqKsolJkZcBslYyJ9H3yc1VZiTFXqKgMidyszWJodEIMZhSIhVWFwm96BsMVgycsmyUee7tN7OkeC+x8BvMD/8jNzZ36om00CxcuFJWVlWL79u1StKWs22jH1djYmOjo6Iibg8s5ufQRDd2cZ4KQSQ+jmfJeAYgHroOpAw20mLa+Ydy7FILrAABcBwDgeQCm+/hxa0u/OGlpdUrHRZxpW5yfnfT1i/Oyja8HRiZEWcGUkm1SwpDuZi3IyTT2L31aXlss1u/tEpub+sTiGv8NekO6WJ+ZniZW1muRCJRpS+cafQQRzA/8wep9Zkqpdvv27RPt7e1i1qxZ8v+PP/540dXVJd544w3jd/7973/L1YFVq1alcEsBAACoAo3IAAAAAACAHfr15k/Eliath02qGB4bFyPjmqhYmJNcgCVnLTfUYrEXWJsv5GdH7l9qRkZsauxJ6XmYn50hFlYWiqyMNNlgbn/XYEq2B0w9Uira9vX1ifXr18sPYteuXfLrhoYG+bMvf/nL4pVXXhG7d+8Wq1evFhdccIFYvHixeO973yt//6CDDpK5t5/61KfEa6+9Jl588UXxuc99TsYq1NXVpfKtAQAAUMSgadDdOTBq5EIBAAAAAACQbNGfmpGlkj6T8GpFtJW/l6v9Xq+pIS+Iz6Ah2mpiN3OILtq+cyA1ou3A8LjhAM7OTBeL9IiGdxtTe06CqUNKRdu1a9eKI444Qn4QlDNLX3/jG9+QjcY2bNggPvCBD4ilS5eKq6++Whx11FHi+eefj4g2+OMf/yiWL18u4xLOPfdcceKJJ4pf/epXKXxXAAAAvBp0E+16cwYAAAAAAACSjR+3NveJiYnEzb+8pG9YE20LsjMsN8MqYtEWTltLDOgmj7wo0fbgWbrT9kDqnbbE8lotz3hLc1i07ewfEWu2tsomeABEk9JwlFNPPTXhifnPf/4z6WuUl5eL+++/X/GWAQAACAoDo5GibWvvsJhVkpey7QEAAAAAAFNHtB0cHRd7OwfEvIqClGwLC6/snrVCUW5WxL8Fzpy2lGlLOjn1xWjpHRLVRdaaP6kWk8lpK7eHROT1B8RmPa6hvW9YXPSLl0RDx4D4w9WrxIlLEjfMAzOPKZVpCwAAYOYOwpiWHjhtAQAAAABAcrGMja3vpjAigZ22VqMRiCL9d/sQj2DL5MFZwAw5bxdUFqTMbds/HCkmL9OdtnQ+Do2Oi2t+/4YUbAlaWAAgGoi2AAAApsSgm2ntg2gLAAAAAACSi2XLaotTnmvLmbaFunvWCohHcOasjo5HIA6uK0lZMzLDaas3SDtIPx93tfWLLzywXryxp9P43X5d3AfADERbAAAAU2IQlpOZbsQjAAAAAAAAkKyR7RFzS1Mv2upiHLtnrQDR1jrjEyGjUXG+Lo4GpRmZ4bTVj31NcY4ozc+S2/zkO00iKyNNHDpb2z5EYYBYQLQFAAAwJUTbueX58jNEWwAAAAAAEA/qm8Pl8kfOLZOf321KTSMqondo1HY8QmEOMm2dVOVFZ9qam5FtPpBKp622XWlpaWJZjRaRQHz34hXiPYu0HFs4bUEsINoCAACYEqLtvAqItgAAAAAAIDFDoxOC+52z03Z3+4DMEE0FvcNOGpFlRgi+IHn/i7S0cGWemYN00XZXe7/vwmi/0SAtfOxPXlolP9941lJxyVFzjCZl/VGRcAAQ1u8aAAAAQArL2+aWa00EkGkLAAAAAADiYRa/FlQUiJK8LNE9OCp2tPaJQ/R8Uz/pd9KIzBBtIeQlY1AX4/OzMqSTNZqqohxRXZQjWnqHZQOwo+Zp7ms/GNCPfUFO2AH8n6cuEpcePUdUF+VGnBd9epQCAGbgtAUAABBo4LQFAAAAAAB2nZd5WRkiPT1cjp6qXFvOW43lAo0HnLZOmpDFF8U513bTgW6RaqctCcss2EaItnBVgxhAtAUAADAlBt5zTfEIlFUGAAAAAABAPKctuxuX1QZDtM3KsCPaZkU0MQPJRdtYebbMslpNtN3W0peaTFuT0zYaIx4BTlsQA4i2AAAApkQjiXl6IzIqgeJVawAAAP7fl3+2ept4bP1+7HoAQMCdl5GiLZXGp4KRcc1skO3IaQvR1qrBI5FoO7ssT35u6h4SfsJCLLm+48FZxxDoQSwg2gIAAAgsI+MTYnxCG+hWFOYYnVfJbQsASK1o97cNjTgEM5C9HYPiR09tFV//v7dTvSkAABCTAV0oK9BL0pcHxGlrR7TlknmIttbdrLkJhNFZxVocQVPPUEoEZXbTxqJQd+FCtAWxgGgLAAAgsPBAh1fPqZEAAdEWgNSxqbFHinbffByi3UykR8/co27omGACAIIcj8BO2yV6pi0Jdt0D2j3MT0bHnccj9CLn1HojsgRO29oSTbRt9Ntpq5+LibYtHI8AVzWYDERbAAAAgS9vy8pIkwNdiLYApJ6tzZpTqb1/RIzpE1Ew8+7LRIvPjiUAALDlbtSdtiV5WaJOF+226M+woDtti00l8+jl4D7TlkXbtr5h43j4uW2JnbaIRwDxgWgLAAAg+JlkerlTWLSFUABAqtiuN/GgfoDdg/47lkAwHE0Eqh4AAFPBaWvOtV2ztdV3EZTivojsjDTL/4ZzTiklDL0crGYYxxdGy/OzRXZGuhy7tPg4j2D3bCJBmUXb4bEJw5UNAAPRFgAAwBRoLKANZqoKddG2D5m2AKRatCU6U1BmClLLoC6GEC3IFwcABNppGxbKjltYIT///Jnt4j/ufi3iWeY1LMTZcdqSYSEjXRN5+9CMzNJzKT9Bpm16epqoKcnxvRmZ4bRNICibXbiISADRQLQFAAAQ+MYCvDqNeAQAUs+O1n7j686BkZRuC0it0xaiLQAgiPTrjcjyTWLYVScuENefsUQKpy9sbxPn/GSN+O4/3vXF2UgOSiI7I76oGE1aWpoo0t22yLW16rRNvH9nFef5mmtLjm4j01ZvNhYLioDL0QV9ZMWDaCDaAgAACCwDo5GDMIi2AKQWmtzubjOJtv0QbWdypi3iEQAAQWRgdLLzkoSxG89aKp664WRxxvJqMToeEv/73A7x2PoDPjYisx6PYC6b74HT1nUjMnOurV9O26HRCRnHQBQkcNoSyLUF8YBoCwAAYArEI0SJtohHACAl7GkfEGMUsKcDp+3MvS8TfuYCAgCAVQZiOG2ZeRUF4u6PHyPef9gsozFVEBuREUW5WfIz3Jf25gvxmKWLtn45bdlla+7PkSwiAfEIwLVou3PnTrv/BAAAAFDSWKCqUBtswd0FQGqIzgBEpu3MFm1xLwYABBGjJD2BiFdZmB3RKMoX0TbDrmiLeARVjcginLY9g8LXxYPsDJmpa81pG37GAuBItF28eLE47bTTxB/+8AcxNITVdQAAAN5n2hZEOW3b+kbEhMnt5yePrd8vP4ZMuY4AzBR2tEaJtohHmNGZthBtAQBTpRFZPGdjrw/RA04akRFFPm7jdBBtg+q05YbKlkRbHGvgVrRdt26dWLFihbjxxhtFbW2tuPbaa8Vrr71m92UAAAAA240FKnRXxPhEKCVl2Y3dg+LzD6yXH8ffvlp85++bxZ72cL4nANOdHbrTlicXiEeY2Zm2aEQGAAgi/Racl4W6i9VXp63teAQIeVYY1DOMk0UQ1Jbk+Zppa5hPEjQhY/h3EI8AXIu2hx9+uPjJT34iDhw4IH7729+KxsZGceKJJ4pDDz1U3HHHHaK1tdXuSwIAAACWVs6piUR5QXbKcm3b+0YiysJ/tWanOOUHz4of/nOL79sCQCrYrjttj5xXJj939I/iQMzgeISO/hFDjAAAgKAwGFWplerGTyPjIWMc6yTTtncIz1o7Jo9kTltacBzT3c9e0m/EI1hw2iK/GKhuRJaZmSkuvvhi8dBDD4nvfe97Yvv27eJLX/qSqK+vFx/72MekmAsAAACoGHSbBztVhXozsl7/RVsuT1tQWSDuvvJocdKSSvn/f3h1jwhxe1gApil0jrPT9tj5mmjblQLHOwhOPALR3u//vRgAACyJZTEakaVEtB0bd+S0ZTdwD0rmlTQiqyzMERnpabJij6LW/I55S0Sh7rRF0zmgTLRdu3at+M///E8xa9Ys6bAlwXbHjh3iqaeeki7cCy64wOlLAwAAAJEr56Zyp+piTbRt6fFfKOCBVHFeljjjoBpx95XHyKYSXQOjoqFjAEcNTGuaeoZkyWlmepo4vF532kK0ndHxCKm6FwMAgJXFpXwLmbb+OG3dNSKDkKcm05YE2xq9PwZFnvm1eJDMAUwU6AYVxCOAaJL7tKMggfaee+4RW7ZsEeeee66477775Of0dO0GtGDBAnHvvfeK+fPn231pAAAAIOnKueG0TUE8Qt/waERjCHJMHFxXLNbv7ZIf8yoKfN8mAPxiu+6ynVuRbzQFpAULMLOIbsKIZmQAgKDBwlciEY+dtn6IZKN6PIL9TFvEI9gzeSSXt2pLcsWB7iFfcm0H9OdlgYV4BD8XEcA0d9redddd4vLLLxd79uwRjz76qDjvvPMMwZaprq4Wd999t8rtBAAAMAOJtXLOYlEqhALu6MoDfWLlnBL5ecO+bt+3B4BUiLaLqwpFWUGWEY8wMYFokJkEl3ump2n/j2ZkAIDgjh8txCN4HD1Apfj04chpq28jx3OBxIuJyZy2xCy9GVmjH6ItLx5YaEQGVzVQJtpS/MF//dd/yViE6JyzhoYG+XV2dra48sork77WmjVrxPnnny/q6upEWlqaFIGZ0dFR+XcOO+wwUVBQIH+HsnIpesEMOXrp35o/vvvd79p9WwAAAAIIr1Cbu/+mUrTt1QdfnDFGrKwvlZ/f2tvl+/YAkBLRtrpQlOZpDQFpHtqDBikzisFRrcy3rlSb+Lb0+tOFGwAArEC6hJUsUb+cjaOmhldZtp22cF/aOd5WRFty2hLNPd4/uyhSiiiw4bRFPAJwLdouWrRItLW1Tfp+R0eHjEawQ39/v1i5cqW48847J/1sYGBArFu3Tvz3f/+3/PzII4/ISIYPfOADk37329/+tmx8xh/XXXedzXcFAAAg2I3Iguu0XTFHE23fPtDtSydaAFLFjtawaEslnuwA6uhHM7KZeF+eV5EvPyMeAQAQJIbHJuSCYrIsURZESVjzspksbQ9jP9OW4xHgtHV7vJlZumgbNKct4hGAskzbeDe0vr4+kZurXQBWOeecc+RHLEpKSqSr18zPf/5zceyxx0pH79y5c43vFxUVidraWlt/GwAAwBTKqApMpu1YxECfWFhZIMUrcuFube6TGbcATEe2t/TLz4uqCuXn0oIsed53Itd2Rjb4mVteIF4U7YhHAAAEtlliongEFskoumBodELkZOqZL4oZMYm2WRn2/gabBHpR0ZK0/0V04+JkTls/Mm3tOG15IRyZtsCxaHvjjTfKzxQ/8I1vfEPk52ur68T4+Lh49dVXxeGHHy68pLu7W/790lLN1cRQHMKtt94qhVzK273hhhtEZqZtPRoAAEBQG5GZBmGVutO2vS8YTtv09DRx2JwS8dKOdrFhXxdEWzAt6R4YFW36NbeoWhNty/Ozxd6OQdEJp+2MFETYaYtMWwBAkODy8tysdJHB4dsxoLFlWhqZ0jShLCdTc7V6FY9ALlvSMuzAJgE4bZNHqdH+zbTgZDactj2DwmvsxDaE4xEim30CYFnZfPPNNw2n7caNG2VuLUNfU8zBl770Jc/26NDQkMy4veyyy0RxcdjFdP3114sjjzxSlJeXi5deekncfPPNMiLhjjvuiPtaw8PD8oPp6emRnycmJuTHdIbeHx3D6f4+AUgEroOpAw92aODN960ivcSoZ2hMLhraHQC7gZ0OlJFmvo+u0EXb9Xu7xIeOniOmArgOgB22NvcYk518/XoszdcmuO39w4EdV7zZ0Cm+/PBG8dVzl4vTl1dP+jmuA+cNX+rLtEzb1t6hwB5/YA1cB2A60T88aoiyye5NNJ7rGx4XPYMjoiwvw5N58tCoNpbNzkyz/dqF+piXIgCGRsZkNBGIpF8fm1NVnpX9W62bP5q7h8TY2Lg0X3i9gJBvYdtobEXQAkIqn6l4HviH1eNsWbR95pln5OdPfOIT4ic/+UmEcOo11JTsQx/6kLyJ3nXXXTEdwMSKFSukgHzttdeK22+/XeTkaBdkNPSzW265ZdL3W1tbpTg83U8McizTvkxPx00fzExwHUwdeLAz2NstWlq0xbZhvQkOlbPt3tckCizkRKmis09blR8fHhAtLS3G9+cVaZ/X7W6L+H6QwXUA7PDmDq2fQX1JlnGO56Vr1+K+lg7R0hJezA8Sj7y+T+xs6xd/eX2XOLR88s9xHdhjbDwkRse1qLQiMWRk2jY3N/u6gAbUgusATCf2NWlRPhR3kGxMlpeVLkXbvU2tIm8s15N5cnO7NnakZAS7Y8QxDmsVQuza1yjK9MVSEGZ/s368M6zt37TxkKCn1ch4SGxtOCDKPdynXfq8YWywP+m2Dfdr85zewdGUziXwPPCP3t5eS79nO0PgnnvuEX7Cgu2ePXvEv//976Ri8apVq8TY2JjYvXu3WLZsWczfITeuWewlp219fb2oqqryVYxO1UVIg2p6rxBtwUwF18HUYUjPAZtTWyWq9U7lNJjOzkiTg63solLj+34wPLFdfq6rLhfV1WHX3sk5RUI8sVPsaB8SRaUVlhohpBpcB8AOrcMd8vPBs8Pnfm05CbkdYiQtJ+J6CBK9Ywe0z6NpMbcR14E9eky5iisXzxZCbJYibnZRmSjLD6ZwD5KD6wBMJ3J72+XnotzspM+m4rxs0do3KrLzi0R1dZkn8+TWsW5tu7IzHT0ryaVJsTS5NOatKFC2XdOFXX3a8S60cLzNUWu04DiWVSiqq0s827bRkDZvmFVVlnTbMvKHjblPRWVVwmgPL8HzwD+s9gSzJNpefPHF4t5775WCJn2diEceeUSoFmy3bdsmnb4VFRVJ/8369evlTTbRRUEO3FguXPp3M0HIpIfRTHmvUxUSpeBY8RZcB8GHMsDY0VWYmxVxz6JBNuVr9g6N+3ovY+dvcdT21JXmiyp9APhuc684al4MS18AwXUArLKjVW9CVlNknPsVBdpYqntwNLBjCs5bbesbibuNuA6sMzym3ZNpMkn34ZK8LHn82/tHRUWhvYbEIFjgOgDThUG9Iis/JzPps4nGl8TAyIT8XS+uA31zZLSBk9elXFsSbfv1bQSRDOnPpfycDMv7h6KeZJVI74hY4eE+5Qz4gqh5QyyK8sILn4NjE3KukSrwPPAHq+erJdG2pKTEEJBIuFUlJvX19Ynt27XVB2LXrl1SdKV82lmzZokPfvCDYt26deKJJ56QuYVNTU3y9+jnFIPw8ssvywZop512migqKpL/T03IPvrRj4qysjIl2wiA33zpobfE2t0d4onrT4podgTATCNR99/ivEwp2pJY4Ce9umhbqDeGYOi5uHJOqXh6c7NYv7d7yoi2AFhle0uf/Ly4SmtCRpQWaBOMjgA3Imvp0URbmpwBdfdl6tBN9z3KBqT7MO3npTV6TgwAAKQQO82fODOWckS9YlSvGsuy0CQrFjQfbBbDEZUOYPJzKT/L+ry5tjhXbBDdoqnb22ZkhmgbNY+JRU5musjKSJOGFWp8nErRFgSLTLuRCOS4VcXatWul4MpwZMGVV14pvvWtb4nHH39c/v/hhx8e8e/IdXvqqadKt+wDDzwgf5caiy1YsECKtuboAwCmGv96p0k2WNqwt0ucsLgy1ZsDQMoH3ZnpaZMaL5C7i/B7AEuDKKIoZ/JAauWcEinabtjX5es2AeA1I2MTYm/ngPx6UXW4NLNcL4fvGgjuRLK5R8td7RgYke59p5NmoDHIoq0uhlQX54htLX2ipXd694QAAExBEc+CUMYGGS9F25FxTbTNdvj8KdLFOx6DgkgG9eaYdqLJyGlLNHZ7++zq1+cyVvpv0EJoQU6mHFNxZR8AhG0b32233SauuOIKKZC6hYRXKgOPR6KfEUceeaR45ZVXXG8HAEFhYiJkOPl2tw+IExaneosACICjK8YgjEVbP522Y+MTxsAw2mlLrKwvlZ/f2gvRFkwvaDLLQzKORCC4IQoJokHd7n79PkLbT47gmmKU8LthUO+CTk5boqpQOx/gZAYABAUWvKwIZSSSeS7a6k7baAOCnXgEoheibUwGbTirmdoSrR9Gk8ei7cCw9QUEoiBbE229PB/B1MP2neOhhx4SixcvFieccIL4xS9+IdratG7CAAA1q3E8Md7TruUHAjDTHV2xBmFcMtTjo2jbrw+84k0EVswpMRZcugIqYgHgxvVOpXvmxhhlejxCUM93dtkyEBbdMziiZ0UaTtvciOxgAAAI8vgxmiJdtPXS2UhVHu6ctizaBreqJagmj1Q6bem4s8vaqqDMxzqVou3mxh7xt03tSQ2UwD9s3zneeustsWHDBumS/eEPfyjq6urE+9//fnH//feLgQGtdA4A4AyKRWB2Q7QFM5xE5W1GPIKPom3v8KjhlMjJnDz4Ks3PFvMq8uXXG/ZpnYIBmA4MxSk9LNPjEToHRgM5uG+OmoxBtFUn4OfqTlvKtMW+BQAECa6wsOJuZKetly7WYbdOWz2SC+7LZPMFO05bTbRtilrc9as3R7LzMZXxCDf/39vi1n/tFv9+tyVl2wAicXTnOOSQQ8R3vvMdsXPnTpkvO3/+fPGFL3xB1NbWOnk5AICOeQV1TzsWQcDMhsUBLsNNdTwCD5bZlRELakZGINcWTM8mH5HXYqkejzA+EYpYdAwKzVE5qxBt3cMRMTw5rtJFW2TaAgCmYrk8x11567TVFjWdZqojHsFipm2M+UJyp+2gZ4vOPI+h5mJWBftwXEdY8PUb1iCefKc5ZdsAInHdjaGgoEDk5eWJ7OxsMToKyz4AbugZjHTaBtG5BEAg4hHyMv0XbXVRKlaebXREwsb9cNqC6V96SG5Lvj47+4MXkdDcE1my39qHEn5ljciyokVb7FsAwNRz2vrSiMyl05bHnUFcHA2UycOim5XgfPuh0QnP5hIcq2bVZUsU6vFrqXLaUmUV7w9y2lI/D5B6HN05du3aJf7nf/5HOm6PPvpo8eabb4pbbrlFNDU1qd9CAGYQ5lJveohgEgRmMlYakfk5gOUmgTzAj8W8igL5uSlKLAJgunZmDkckBFG0jXTatnhYBjlTz4XqIm3iCxczACBoIp4lp60vou24y0xbxCOojkegRedyPZffq1xbPg8LbGyXH+djIlpM8xeKvnpjT2dKtgNEYvvOcdxxx8lGZA8//LD4xCc+Ifbs2SNWr14trr76alFSojmMAADuMjOZ3W1oRgZmLgNRZbgpj0cYSi7asuusDa4zMB1d71mTz/2ygqzAirY8+ZivZ03DaatwMS3KaUt5kJx9DAAAU0XEC5ejex+P4DjTFo3IlDWeM1Oru22bPBJtDadtgnlDKs5HO7FS/9qEiIQgYPvOccYZZ4iNGzdKd+2XvvQlMXv2bG+2DIAZHo9AINcWzGTCmWSTBzvFuSnMtE0Qj8ACBrnOEG8CptuEKDeR07Z/NLBO20Nma6YCuEHdw8IsT46LczNFji5EmB06AACQKgZ0sYwFsERwnwIvy9FH9BJzx05bH5qlTafFRPu5tsFz2qYqHoHHTXyq/mtTE+YzAcD2nYNiEQ4++GBvtgaAGY65ERnn2gIwU0kUj1DM8QgBc9pWFmYbA3Q/BWUAfHG9Z02xeATdMXJoHURb9fdl7T6YlpYWXqzqQ/wEACD1DIxyxqkNp+2Q95m2WZlp7uIRINomcdpad7QSZXo8QtfgSMqzlSfFI6ToWHMvgOPmlcgF2b0dg2JLc29KtgWEsXQG3XjjjeLWW2+VTcfo60TccccdVl4SABADzuekm+Tw2ASctmBGEy7JDkY8gpFpm8Bpm5OZIUrzs0TXwKh09ZXqghYA07UTN2fCBU20Jac7Tz4OnV0sP8Np602X7uqiHLGvcxBOWwBmqOHk4l+8JI5ZUC6+c9FhIlBOWyuNyHJ9yLQ1nLb2nKAM4hGsPZfsxiN47Wod0F+3QG8uNhXiETj7v740R+Tm5IjV77aIf73TLJbXauMoEGDRlqIQRkdHja8BAN46bQ+aVSzW7+0Su5BpC2YwiTLJ2GlLixtUrksNBfxz2mp/Ox5VhTmGaLukpsjz7QLAawZHJuLGI9AiBdERsHgEugbZ3XSI7rQl1wtNzqyUzALr2YHcjAzNUwGYeWzY1y22tfTJj3MPnSVOXFI5pTJtzY2fvIq1cuu0ZWEZ8QiJYwisOKtjieFeuVrdOG379ffkN026aFtVmCUOX1CmibabmsT1ZyxJyfYADUtn0DPPPBPzawCAN5m2K+aUSNF2T3u/HEBQ+SEAM70MNzrfiy4LGl/3DI36I9rqjQITZdoSVCpMkxcIGGC6lZrGcr2z07YrYE5bjkYoy8+S20iTd7qntPUNQ7RVnG9szvIGAMwsOvrD9/7b/rZJ/O36k0RGemrnLSx42RFtJ0KU2a2Jq6oZ1Z22OU4zbVlcHBkTExMhkZ7i/TtdGpHxsedKuiA4bVMfj6CNnSoLssUZy6sFnWpv7+8RB7oGRV1pXkq2CTjItL3qqqtEb+/kXIv+/n75MwCAc0h8Ig6eVSwFKVqha+sL1kQYAL8YZKEoxiCMBqzcjMyvXFsuVUqUaculwgQEDDBdGEqQL80RIOaJexDgaIQavTs0hEXv8o35ntcS1XUaADD9MUfjvNvUK/6ybl9Kt4fMLnYyTmmMyd4Yr0rS2WmbrTdttAuPd8mokCoH5lR4LtltRFYYQKdt6uMRtLFTZUGWqCjMEUfNK5P//9Sm5pRsD9Cwfef43e9+JwYHByd9n75333332X05AECMTNvKwhxRV6KtZpHbFoCZSKJGZERxXqavubZ9ekZaMtE23JQHrjMw/a/Fcl20pTiCIMFuEUO0LcRiisp8Y/O5UF2MfQvATIUX7KgCivjhP7cY5eqpgPJjx8g2S2KZBYcjVTMW6qKaZ6Kt7rTNcui0pV4nmbq7NlVi3lSeL1iJxvBmu3SnrY3tCufsau8pVWMnikcgzj64Vn6miASQOizfOXp6ekR3d7dcvSKnLf0/f3R2doq///3vorq62tutBWCa06uLT1QGM78yX369u31ABBEqhT3h9tXipoffSvWmgGk+CCuIs0LNzcg4VsRr+nQnfKJGZGbRlsP8AZiO7spJmbYBi0fg669GFxSN6xIl/GoakcXItKVmZACAmQUv2F22aq6oL8+T99hfrdmZ8iZk8Z5ZqXA3unXakrDM91weGwON8YmQsX/tOFojYic8Ou4svObbyNH3ozFePOhvsju4okAb2511cI38/OrOjsDFYM0kLN85SktLRXl5ubxpLF26VJSVlRkflZWVMhrhs5/9rLdbC8AMcdpSk6V5FQWBdtpS5u6B7iHxl3X7jQZqAHixQh0vo4pFW/+ctmMRbpJ4wGkLZlI8AmfadvaPeNbExQmIR/DY0WQSQw6bozV6oyxvxMIAMDOdtlTV8F/vWy6//uVzOw3HXqoWGUkgzbTobGWhjBpVetqIzKHTlijQBUmzKA3CcwUnmba8T72KR0g2j4m5Tbo7nGIw/B5T8TVbmJNhuIPnVxbI2EZyrz/+1gFftweEsXznoAZkq1evlifPww8/LP79738bHy+88IJoaGgQX/va16y+HAAgQaYtibbzK4LttOWsXVrhpNU3AHyPR8j1WbTVB3XJnLbsOoN4AWZCU8AyPR6BBvRBKtvkyUc14hE8EfDNk1CKdDp0drH8+vltrWr/IABgSmTaUtPH9x82Sxw5t1Q68n/+7+0p2R6j+ZMtocxbdyM3InPqtDVHPaQyeiKIcH4x5RJTjIQdeDzvWSMyB5m2HI9Aeq3frmpj3KTPY5hLj54jP/957V5ftweEsXwGnXLKKfLzrl27xNy5c9HNHgDFDI2OGyuxVK4RdKctdeBmXtjeJs7UyycA8KsbbDgewR/Rlgd1PLiPB8qwwbQtiY9RakqLKrlZ6bLrdmf/qCjSF1NSTbMeg1CjxyLAAe9tw5eTl1TJDtPPbW0VFx+pTfAAADPHaVtWkC31gWtPWSSu/f0bYu2ezpRsjxOhrChCtM3yLNPWrqhohsfCiEeIc7yzqKGc3lHOIkU5Wb44be0sINCzleKLKZaZzsdkcw4vmpBxrBRzweGzxXf+vlk+4zcd6BEH12mLtMA/bN85yFlLTttoHnroIdmkDADgjF79gUHPGwrEn6+Ltrva+gNVcsq09UaKtgB4N/BOfTwCXYOW4xH0hkeU8zY8hjI2MP0XUNhta+4inmqau6MakXGDQGTaKjkXoisgTllaJT8/v61NTOhNgAAAMyfTlptSLqrS5i/7OgZSMn+hsnKnJeleiXejYyHX8QgsQvP7A8krgaw6bWlhmipHg5BpS8Kz185vqxVK5hgszrZ96A24bVOB7TvH7bffLjNso6EmZN/5zndUbRcAMw7OhaWyiPT0NDG3PN8Qc4PWlZto11fWie0tfaJJnyADoF4ciD3YoRgRc6yI14NCnnski0egxkxZGdpqf7seIwLAVGZgdCxhVAmLtkFpRkaTr1a9GgSirdr9OqxXBEU7bY+cVybHL+S6e+dAj8K/CgCYEk5b/Tkwp0yfvwyP+RZfZWeRMRaFuuOSmzCpZpjjEVxl2sJpm6gSyG6erVms90ogdeK0NUckeJWxnLQXgL7IbebSo+vl50ff3A9DSgqwfeeg7NoFCxZM+v68efPkzwAALpuQ6aWlNDmu1Ve6dgcwIsEcj0DAbQtUMjY+YZSTxev+y6KtH5MCHsxRyVKsEvHoVXJ228LVB6YDgyOxhTqmTO8yHJTOwu39w1JgpOu1sjA7IqONnl1wgjqPcWKiS4/JQXb8ogr59XNbWxwfOwDA1IEEUhbN+DmQm5VhVDbs7Rj0fZv6HeWIeuu0NRqRucq05UZkcNq6FemZnMwMI2fYC9HWybloFm29Oh/j0dzLTtvJoi1FIJEu0TkwKlZvxjPeb2zfOchRu2HDhknff+utt0RFhTZYAwDYh3M5Kc+Wmac3I9sTwGZkLEYdNlvrGv0iIhKmHV/5ywbxkV+9nJKmB5ybmMjd52c8AseX0EDKSmYWcm3BdGIwSbmp4bTtD0ZVCOeyUYMs7h5eURhumNaVAvfXdMCcpRgrm5EjEtZsRWQSADMBjsSh6iIWmoj6sjz5eW/nQOoakZlclMngCqp+rxuRuYlH0BdNvXIDJ+Ivb+wTX37oLXHnM9vF3zc2inebegwhOtXwHIUWC5xQ5KFA6uRc1H4/NfEILXo8Qk1UIzIiIz1NXHLUbPk1GpL5j+3wj8suu0xcf/31oqioSJx88snye88995z4/Oc/Lz7ykY94sY0AzAhYFGL3IEG5tq/u6gio01YbqF14xGyxcX+3dNpSdpXdEHgQTMil9uDavTIS4Pcv75GNJVKxck5OuXiNG4r1QXbPoPeDGiPP1mKTJeRngukC3dcTNSIzi7ZBcdpyLhtHI7ATlHLZqJSXFh3pa+DMaSsbpdDNOY5ou66hU8bWcOUQAGB6i7b0DDCP/+vL88W6hi6xt2NgSmScskjGDWdVwwInuzqdwNvot5GCxuNfeWSDGB0PTRqDn7+yTnzwqDni8PrSlM3/3MQjsGBPkX99w2oXc6mihw0oTp22fucXczyC5rSd/LcvPape3PnMDrFma6uMRawtmSzuAm+wfee49dZbxapVq8QZZ5wh8vLy5MfZZ58tTj/9dPE///M/3mwlADMAzuVkIYqYVxlMpy0Jeh392o397INrZOdwmgRvbe5L9aYBRZB7lTNcf7lmp++5Subuv/EGgn46bXkF3uwkSUSVvkqNeAQw1aEMU+7PETfTVhdAOdsw1Ri5bFElfhxb0qKXAAKnYkjs84CEmgWVBdLN/NL2duxeAKY5nXp1BS/cMfV6rm1KnLYOckTZbRlop22KMm037OuSgi31a7j4yNlSoKWqUIr1++OrDeKiX7wkzrjjOfGPjY0iiE2Lk8HjejZPqWJoLNwLw77T1tu4jngL9LzgzfGM0cyvLBDHLiiXY8K/rNvn27YBB6Jtdna2ePDBB8WWLVvEH//4R/HII4+IHTt2iN/+9rciJ2dy/gUAwF4jMrMzhZy2RNCctrSyzpP4WSW54tgFWjTK89taU7thQBnmLvAkxNz38p6UDLrjiQNm0ZajRbyEV+CTNSGbHI8AcQhMbdj1nthpy5m2wYgdiNcBGQ54dyRzXEdEJGA8AKYgj791QFz/pzcj8ptBfLj5JOfZMvXlWjxCQwoybZMtLqWiHF2p03bY33Pzzb1d8vPxCyvEHR86XDz62feIt75xtvjjJ1eJi4+YLZ8HO1v7xW1/2yxSgRNndcz8WMXHvl8/TuQ7yc2024hMu576fDzWVLXIjUarYzQiYy49ao78/PAb+6TQC/zB8Z1jyZIl4tJLLxXnnXeeKCsrE3fddZc4+uij1W4dADMILvGOjkcIotOWm5DRRJ3yAk9aXCn/H7m204foMudfrdnha7aSlcYCfK1QORu5v/3KtLUCxCEw3YQ6cghxPmw05QFz2vJiSXQuG65LNYtpie7LJy/VxgNUPokJHZhq/OKZ7VK4fX4bcpmt0Knf86PjZthpuy+F8QgFthqRsdN23NtGZBnOIwR4sczvkvl1ezrl5yPmlhrfo3ic9yyuFHd8+HDxxPUnGg1AU5q57zDT1qumX8bzMk6cUOJt0o+1j/MubkJGjuqcBPvyvYfWys+72vpTkq88U3G+3COEeOaZZ8R//Md/iFmzZhmxCXZYs2aNOP/880VdXZ0sf3300Ucjfk6DvW984xvy9SmG4cwzzxTbtm2L+J2Ojg5xxRVXiOLiYlFaWiquvvpq0deHEm0wdZ22sRqR0USYfx4E2vU8W2ryQtCDm6D83aAE0wM1JW8HzyoWCysLZLfQ37202/+V86zkTlvC6+uDBWurTltepW7VFzgAmKpYcS3xs4AdrqmGstaI2pKoeAS+LvVGmsDZYlqic+G4hRVS4N/XOSh2tgWrSgiAZHDc0oEu/x2iUz3TNjoqhaD7AGV7Bq1Syy+3JTMyrsJp6388Amkx7LQ9cm5ZzN/h5+rQ6ERKHOpOnNVmeFzvldM236LZI9WNyJoTNCGLjhLhmA8/4umAhu07x/79+2V27eLFi6XT9v7775fRCPT9O++809Zr9ff3i5UrV8b9d9///vfFT3/6U/G///u/4tVXXxUFBQXive99rxgaCk8KSLB95513xFNPPSWeeOIJKQRfc801dt8WACmHsoGi4xHops0DiSBNMtlpyxP15bVForIwWz4432zQVmTB9BiIU8f1689YIr/+1Zqdvi0eWMmoosZC/HOvBw68As+5Z8mAOASmY/OpeFDOGdHQMWBk96WScDONKKet/szCYop38QiUQ37MgjLDbQvAVIKf9Qe6IdracdpGi7YUnUbd5kmsbPF5/sLuPzuZtl6KZCR8qhBtuZmVn43ISHSn+Wdmepo4dHZJzN+hcTEd61SJeKoybVUfeyfZyl4LydabkMWHjJZc6dgdkEismYDlO8df/vIXce6554ply5aJ9evXix/96EfiwIEDIj09XRx22GGOOgaec8454rbbbhMXXXRRzBvcj3/8Y/H1r39dXHDBBWLFihXivvvuk3+THbmbN28WTz75pPjNb34jXb4nnnii+NnPfiYeeOAB+XsATCU4l9PstGXRjGjT3a1BgAXkSn11lco+TlikuW1f2I6SsukAZ1PSQJy6wy6qKpCDsXtf9MdtOzjKZbiJRVJe5OB4Ec+dtlZFW6Ph0TBKhMGUxsqEaFZxrmxISQ2oUtEtPBrEI6TW0XTSEi3X9tWdHR5tCQDqIUdony60NHYFo2og6HTwWDEqHoGidOpKc1PSjGxAH6/ZcTh6KZJRfBdHf061RmTrdCPOIXXFIjfOYh1pQFz5lopceytxapaOveJ4BF48SDaPiblNHjfGS+i0jdOEzExJnrZ9cNr6h+U7x4c//GFxxBFHiMbGRvHQQw9JIZWaknnFrl27RFNTk4xEYEpKSqQ4+/LLL8v/p88UiWDO0qXfJyGZnLkATCU4M9OcaWt2s7K7NQiwgEzuWuaERRURD3gwtekaZPdEllxBZ7ft3S/u8qXUzerKOQ8UvR44UG6uk0ZkFBfCLnoApiJWSk1p4W5BZaH8mhqSpBJy+vIzqibKMWLElgSocmUquq6T3Zfn6aXRcDSDqQQJtiyuIR7BbqZt5NzFnGvr90KeE+elWSRTncXNLltVTls/hbw3G7RohCPiRCMwpYZo67/ByKgAcdiIrMgrpy0vHjgQkwuy/XfathiibWKnrZ9zLxDG8tlNWbEUY/Dss8/KHFsScakBmVeQYEvU1NREfJ/+n39Gn6urqyN+npmZKcrLy43ficXw8LD8YHp6euTniYkJ+TGdofdHD6Pp/j6nIt162TmVUZiPT4W+et3aOxSY40bbwtvG2zSnTOsU29wdnO2MB66D5HBDIXow0/4655Aa8cX0NLmK3tg9IGaVaMfbK3hQSkJRovOpWF/t7RoY9vS86x2MfX3GIzsjTRTnZkrBtqV7UBTpWWRBAtcBsDPxIJdNonN/YWW+2NzYI7a39IrTl2tOy1TQrJc1U8OXktzMqOdpliHa8vdxHdi/L1Mn7ETnArtwSNAJ+ngAaOA6EKLHJDhRPALOXetRWiTaRe8vnhc0tPf7ui+5UVdeVrrlv5ufpYmp5EkgEVDl9g6Z4gyoD5nT16b3w6K0X/uTjTiH15ckuednGeeD39fNgIPjbYbjCyj+TeW2W53HxNwmfc5A7l+/9meTLtpSpWCy50GRXuXo9dxrJjBhcf9ZFm1/+ctfyriCP//5zzLD9gtf+ILMl52KAuDtt98ubrnllknfb21tjcjLnY7Qseru7pbHjRzJIDh06103xwd7RUtL+JoqyNBWEBuaO0VLi7dCmVUOdPTKz9kTw6KlpUV+nTEyaJRX8PeCCq6D5DR3asc403SMa4uzxb6uYbF++wGRUV/k6TFq69QW09LGRhKeTznp2rWyr6VDtLR4J4x29GpOkdDIoOXzuyxPE2237m0WRSL1JePR4DoAVmhu1yZtmaHxhOd+bb4Wk/XO3jbR0qK5blPBu42a07ciP0u0tUVlquqTqK7BUbHvQJN0PeE6sH9fFuOJ78uhIW080NEffn6AYIPrQIg9beEcWzIgNDY1G1mdIDZtvdo+Cw31iZaWSIdqWbY2PtvW2OnrfaBXF5KH+2k+Ze3f0LyYjjS9g8a2TpGbma5sntyuN/al1+9oa3UUKUkM9WkaRf/QqC/7c2hsQrxzoFt+PTc/8fM/L0M71nub20VLpb/XTFefdg6ODPY52i8T+vy1vWdA6X5t6dBcyukTY7Zfd3RAm4N1D/g3p97f3ic/54a0v5lIL8pJ07SJ/a1doqUluTMXxKe3VzvWybDlI8/LyxNXXnml/Ni2bZu45557xNq1a8V73vMe8f73v1988IMfFBdffLFQQW1trfzc3NwsZs2aZXyf/v/www83fif6RB4bGxMdHR3Gv4/FzTffLG688cYIp219fb2oqqoSxcXFYroPyuhhQe8Vom2w6BvRHnhz66pFtd7UhaivogdmmxgIZU5ylqeK3tFt8vOCukpjm3KKaFCySfQOj4uSsgqRk6BRSarBdZCcwfFd8nN9dblxjBdVF0nRtieU7f25mKVlIZaXFCb8W9UlVFXRLUJZeZ5u02hop/xcV1Vm+e/MKt0l9nQOidFMb7fNKbgOgBUyd2kTxZLCxOfxofPGhHi1UTT2TaT0fB9t1SqtZpXmT9qOqlBIZGVsEKPjIZGWXyKqS/NwHdggPVu/Lxcnvi+LXDpnNslFq8pKGm9C+Ao6eB4I0TAYjvcaJ/Uur1hUe1xVNNXpHtLEm0VzakS1HovCLJ9Di2QHRNtgyNdnwsjEO/Lz7Bqao8RunhWvGRmVo2fmavc3VfPk0U5NFKRFwugKYjuMZWuvMzjmzzN27Z5OQckOFIW3cvGchGJzTVmjELt7xERmru/P/3GxQ36urQzPV+xQ10rz791iNJSudNszc7UF5NKiyWORZMwZpirbbYLadfi1PzuGtOtmaX2NqK4uTqgX1ZTRgniHmMjICeT8ZiqRm5s8Q5hwFv4hhFiyZIn4zne+IxuJ/e1vfxN33323uOyyyyJiB9ywYMECKbyuXr3aEGlJXKWs2s985jPy/48//njR1dUl3njjDXHUUUfJ7/373/+WAw/Kvo1HTk6O/IiGTsqZIGTSRThT3utUgTJCuZynND874thU6YHg7X0jgTlmtC1EdVGusU203TQgoQzPtv5RUV8+Od8qSOA6SEyn3kygvDDHOMbzKmgxoU00dAx6fi4OjU4Yg+hEf6skX29ENjTm6Tb1DWsTk6K8yOszEdy5vi1A1240uA5AMobHJoxctkTn8eJqzX2/q60/pec7u5ooVzrWdlDp34HuIfl79eXaAimuA3v3ZWrwk+gYlxfmGqXGfSPjcnwAgs9Mvw64cRDT1DMiZpeFTRRgcgMovidUmOYDzFw5ZhRiX6f3Y8ZYmbYFOVm2/m6hLtoOjk4ovQ7GTE3I3LxmUa52H6VFR3osu8nHtcL6vZpT9Mi5ZSIjI7ERh+/x3YPejsUTZdommy/Eozgv2xjnq9z24VFrY6dY0FyDIxb82J+kQ3DWf21JnvybiZ4HfLy9nnvNBNIt7r90FX/o/PPPF48++qjYu3evrX/b19cn1q9fLz+4+Rh93dDQIE8UimAgUfjxxx8XGzduFB/72MdEXV2duPDCC+XvH3TQQeJ973uf+NSnPiVee+018eKLL4rPfe5z4iMf+Yj8PQCmCtTkiHPvi6IaHVXqmbZBaURGpRIs2lbqTV0IuSKnN01D85GpD3eA5eYCYdFWiD3t/YHpUl6s5yr1eByGz80AuFmFnWZkuB7AVCZ8LSY+9xdUafeH9v4R0Z2CDtIMN8YoiyMUGtclmpE5PxeSVNKQmMD3Sl4ABGCqNARm0IzMWp4tiZGcC2qmvlxzKTd2D8oGkX5nnHIuqFW40Wy/XvmoCjKzEG5FVvN4mARzv5qQHTkveQ+jUl1kpOghv3HSeM4MP6tUN/1iMTkn0/52GY3xRsaVN8aLdy3TYoB5jJQINCLzH6XSuF17NEUrHHHEEfKDoMgC+vob3/iG/P+bbrpJXHfddeKaa64RxxxzjBR5n3zyyQgb8R//+EexfPlyccYZZ4hzzz1XnHjiieJXv/qVyrcFgOdQ+DmRk5k+6ebOwih3w041PYNjRidUbpLGYDI8/QbjZuFjfoVW+ran3ft8Vh6Q5icRB/waOPBgLnpRJRHG9dATjAUXAFx1Zk5yLdIkg7sO72jTstFS2c28VHfhRzPVnlN+TNisMjRqfXLM+5+bWgIwVcbiDImNID58bdO1Hqt0nowcudQcKuSfAE4CKYtP+UkWGqMhp2Ysx7WKbSKyMtzJLiT6kkBOcHWml88dbkJ2RH2p5ft9l6mZn/+Lic4KyPm4R1//bmEXejLzSext0v7N+ETIeB0vadbnKRSFYeU8LfZp7gUUxCOo4NRTT004GKUHwLe//W35EY/y8nJx//33e7SFAPgnhJpvgmYqdfdqe0CctuwaJPGKuombqdYnwy1TZDIM4k/MuSS6VO+2TswzibayaYPDZgp2nBLJBt2+ibZDDpy2cJ6DaYCxgGJh4rGwslAO/ne29suSylTATp94JflTRbSlmIkbHlwvqwj+dv1JjiZ+3nXpTr4t5QXZsiw6FZN4ANw855kDXdO7ObWqxX261mNBY8Q5Zflie0ufaOgYMKq1vMTsQLXrvCzySrTVjS4q4gzoOTAyOGHci72isXtIPssz09PEijl2RFv/RbxBY77g7BnJZgwyZ6ic21hd8I5FgWnuQ9vl9fO/uXfIiD20Apy2/oMQCgACQI++uhfLxUerXjyI8KMcJhkc08Bi8lScDANrA3EarPEglqDBN41laABBJdCBiEfQRVvKVfKK4bFxY9DN5XNWqNZdh7gewFTGEOqsiLZ6RMKO1tQ5bVkkjOe05WdXUCKHYvHY+v3ivJ8+LzMFd7b1i02NWgfvVGNMQi05bbWxC+IRwFSLR2A3I+IRrDlt40XREPVlWkTC3g5/nLbsQKVjaNfZyu7GgYDGIxAcQ8FjZK9gl+1Bs4ot3e9ZxPNbtCWRdcBGBUgs2IxBjnCVrlauTCG3uV2oeScfa8q19ZqWHk205Wopq8fb62g6EAaiLQABGihyPmf0w4RiE4IyyQyLtpMHabxC16qv2IGpSafeyCe65I2c1XV6J2WvIxIGLQ7C/Bg4mN03BTbK7XgRA85zMJWhpixW3SILqwrl550pFW0503bqibY0ybv5kY3i8w+slwu1fPvd1eZ9JI0VeOHYyrnA+5/jKgAIOhyDxItP5DYEye+18Zy2RH25VqG1t9Ofe5jVBf9YFOZkeeK05Txft/EI3ASS6Neb43rFuj1anu0Rc5O7bCMbkfkr4lFVIBdtO3Wj0jyDn7W9w6PKRVsnTltzbIPqrN1E8Qg1egPlZMBp6z+27x4LFy4U7e3tk77f1dUlfwYAsA8LTrGctiSa8SQzCA2NjCZkcNpOW8JOtckD8bn6ANzrZmRWB95+DBx4wEQDu4z0NNvxCORG8bMJBwCpKj1cpIsdFI+Q6kqBEr0xylQSbb/2f2+LP71GzXiFuP70xeLDR9fL7+9uS93+dNrwhd13fDwAmCpVb8tqi+RnZNpaz7SNR32ZLtp2DPjbhMyRaKu7WHWxLYhOW773eh2PsH6v5rS1GnPETYv9jsMxV6A6FUdpnm00I1NYtcfmk+goQauwJsD3JS9p1p221Q5E2yDl7k9nbN89du/eLcbHJ9/MhoeHxf79+1VtFwAzCg4/j5Vpa3a1tgUgdiBRPAIybacHnQmcavMrtQH4bq+dtoY4kNjZWpynD2o8HDj0OsizZdGCIibMix0ATDXslMQv0p225MSnBhqpgBdwykx53DGfpwG8Jl/f3SE//+jSleLGs5eJxdWFRr5tEDAmobZEW5RPgqkBP+uX1hQZ9wh2ywH7mbZEfbkej9A5GHynba7HmbYZacpEW9XbGM95Ob/SWg4xC/e0XSxS+wEL7BSHkenCyVzkgauV5zFORVs/Iwj4ePM83uq2jU2EPI/qABqWZ6CPP/648fU///lPUVJSYvw/ibirV68W8+fPt/pyAAATnMdZHCcvM+wMSv0kE5m2M2cgHttpqw3gGjx32lpz90UPHLicSCU8iLOTZ8uZVHTtNvUMyVzb2hJrK9gABIlwZ+bkE4+60jzpJqJJ275OfxrPmKGFGy7ZLY3ntNUnJUFYBI2GXUrc+GW+vv8CI9racdrqojniEcBUgV12c8ry5P2OFimauocsC1czDUuZtnp11j6/nbYOxoL8b1Rn2nKllZpM28yICphU9FqJRVEuxanRM1hbOOV4MK/h/eC2UZcc33erddoO6eK1UwewnxEEXMlrVbSlMQCZUmjuRdvnxdwLRGJ5D1944YWGhfzKK6+M+FlWVpYUbH/0ox9ZfTkAQCynbYxMW7No2x6Acs7WXm2QVhEj09bciGxiIiRFKzCF4xFiOL/nV/jktLWYBUU/z8pIE6Pj3g0ceBBnbspmFbomSLRtkTnP4cVOAKYKVl3vBMWHLKgoEFuae2VEgt+iLS2w0CTCSiOy3uEx6aJT4X5SATmTaZvMk7UFetzE7vZ+pV2tXWeNZyU/FxCPAKYanGdJY/FZpbnyHkbNyCDaJskPj1PVYBZtqXktNVTyWtyxE+ESDY/xVLtYKXfV3OAu6Jm2NH9js4JV0Zae/XTd0Di8e3DEN9HWzfE2w5V0/AxWwZAL17ffoi0vYls9bjQWoe2j65q2jxbsgbdYvntMTEzIj7lz54qWlhbj/+mDohG2bNkizjvvPG+3FoBpSs/gWOJ4hCIu5xwOtNOWv0eT5i50lJz68QgxSt5YhPEy05bECe7gmqysiAYOvNjhVe6TU6etedWaFjIAmNrxCNaGjNzEZ0cKmpGxiEDdmuPdO6iihSfPQbouafGWE154skZ5kLT2SRPTVDc0pPtyOB4h3bJo63c3cQDcxiOQUDVbFyEOoBmZK6ctjc/4frbPh4iEgWHri4zxnbYBbkSW5X2mLUUO8LMonpkoFrxQ6uc932iO6dppmxW4TFu/RFt6tvNYyI7YjmZk/mL77rFr1y5RWVnpzdYAMENJVoYSxHiEKl1INkOlP5yDqjkLwVTEKC+O4VSbqzttSdj1aiDBrgQWXywPHDwaKPLKu91M22j3OQBTOx4h05ZouzMFJf0c7ZJIRNCaewZnITT6vkuOIS6jpc9z9EY+qY5IMHfptiKI8POjA43IwBTBqKohp60eZ9TY5U8W63TNtI3ItfUhIqHfRuPMaHiM1684HkFpIzJuluZhjihXf1L5e46NbQ43Ixv1PdPWaQSBl5m2nIdtZR4TixKfFj4popFzl2MZsuJR7KMTGDgQbYnnnntOnH/++WLx4sXy4wMf+IB4/vnnsT8BcLm6nywegTNnUgk3VIp3Y68u0ga6EKmmfjxCLOGDBrV87Bs8ikgwN/6wskLNAwfOhvZqIleYY91xEC3aNmMRA0xR7Jb4LazUmmftaEmd05YXcuJh5NoGYCGU4YlPdCzNAj1Pc3eKRVuzSGBlgsxCDj1P0F0aTAWMpqO5mUa574FuiLZunLZcMUDs7RwIdLk8i7aqBVFDtFXgtC3QF8y8FG3DixeZtiJ5DJHRRxFvSFE8QoEuhittROZSUPbLycrzdTredlzBcNr6i+27xx/+8Adx5plnivz8fHH99dfLj7y8PHHGGWeI+++/35utBGCGO20rAuIKojwqfgjFE23hLJz6hN1qsYWPcK6tNyICRyPQKr+VcjKvV3v79Jw7q9leZrj5GDUzAWCqQWIbO1msToqC7rSNrF5J/UIowxPd4jiibaqdtvzsJ7cY5Rcmg48B5Y173ekcABWLxew2o2d9XYku2nbh2R2vLJ2romJFacXKtd3b4UM8guG0tT9e4wgs1fcrlY3I2GlL8zGvYAOE3UiwsNPWv8VQFq+dRhAwbMrwwmkb9Exbo4LWhsvWvH09cNr6gu072v/8z/+I73//++KGG24wvkfC7R133CFuvfVWcfnll6veRgBmjtM2jjuIb6Sp7nbNN3ZaNYzXTIAzPFOdvwdUxCPEHohTRMLaPZ2iwaNSN7ur014PbMJOW/uTAHbr7MfED0xBSMSgBlm2nLZVhYZ7g8osqdTYd7dqnAUnxohHCNBzKt628yJZykVb7tJt8b5M5wuV1pKw09k/4uj+CYBfmMWawuxM2YiMaITTNiYce0Lu0YIkz4b6Mm0c5NWYUZXTNpxpG+B4hCz/4hGKbFaXsdHDz3J5ozmm60xbPR5BUcXe2PiEXLAkcjOdbVupT6IoO225AskqcNr6i+27x86dO2U0QjQUkUB5twAA+/ANOVmmrcydMeV9pkq0ZedvLOC0nfokc6vNr/C2XJdXp3Msi7aZng5sjExbB05bdutg4gemIkOmyaudRRR+ZlH3dT/p7E+84BRkp223ft+NjnZYoIvgXlU2WGVQPxfsTI45IoGfKQAEPhohJ1Okp6eF4xGw4BoTWoghygqykpbQz9Gdtvv8iEfQG5HFM5ZYyTXVGnHpAd4KGFbZiMwQlsc8X8CwW13G8Qh+3u+NRmQBy7QdMs3VHTttubGbT6KtnSZkBERbf7F996ivrxerV6+e9P2nn35a/gwAYA8aGCTLtKUbI5WKE+39qZtktvYmzrM13/ThtJ2aTEyEjFXyePEI83Tn1x6PMm3DHVetPaL4ugmm0zbXcC97OcgGwAsGRrVzNivDWlTJ5IgEf3NtuwZHLDptg5xpGyk4L+BFsvYBeX9OFXz/sjM5ZvGcGlcCEGTMOZ7mBVcScTjCDNjPs43ItO0Y8Dzf2m6cjxkWeuk2y+NQFYyOhZQ5bQv02AcvI2d4TmpXtE1FIzKjMs9BHIYZNmXwe3e9XabjY6eZ21SMR0AjMn+wfYZ/8YtflHEI69evFyeccIL83osvvijuvfde8ZOf/MSLbQRgWkOlg+YcrVjQqj+5W5t7hkVb74iYpQ8m/YZv7FZE21Y0XlLCn15rkNlVnzxpofADmpywLsCrvNHM00WEPR3eOm3txiN45bTlbsROMm2pNJxW8MmtS46dxdWaaw6AqcCgw7y4RVUF4rVdHb47bXmyGG/BadJzKkBO23AsTdakhR8SzanKhpoizdEFEL8JT47tOG2zIlx5AAQVLgnnxVk6z+k+QgsOB7oGRXGtfzEvUwGr+eHEHD0egYRG2p/swPeCAd0p6US0pX9DpmHSlUnEL8xVs50j4+PqnLb6+/LSBGDEI9iMNuJnl58i3oAipy1f99zDQtU8hswndpq5xZvb0IItaQFeAKft1MD23eMzn/mMeOCBB8TGjRvFF77wBfnx9ttviwcffFBce+213mwlANMYFproXlyQYKUwCOWc7borqaoo/kCmukhzFsJpq+ah//VH3xa3/W2z8VD1SziggWFOnBwmzlikRQQvBo7hwY5N0XYoeE5bAtl4YKriNB9wYaW2OOG/aDsS060axOdpNDzRjc62z8xIF3P18uLdbd6XF6ssQw07bSHaOuGtvV3in+80Ofq3wFnzJfPiLBskGhGRMAleiLEiwNJYjvtdkNvWn2eW/fEaiWsF+r/rG1HvtHXquIwp2uoxEH64zu2Ktn46bYdUZ9qqikewaT5JNLchI02fhyK9U6et102gQSSO7h4XXXSReOGFF0R7e7v8oK8vuOACJy8FwIwnPFDMSriKVlGYemeQPadtcCbDU5XG7iGjCRA5PYLinqCJOA8mvGgsMTQ6YWuwwwMHrwaKRqatQ9E2nI3nzzEEQH2TD3vnPjUrJPb6kGFohsvwk8Uj8MJjkBqRcW5drG1fUKlVN+zyOW7CrdOWHc+IR7APOauu/t3r4trfvyHWNXQ6eAXgLMcza1K8ETncQSQdXNWgu+mTUV/uzzOBjQRORbwixQ2pCK6mpKZtbgk3Sxv3fF5qd8xboi+WckyRr7E92YoybVXFIygQbWmxg4X+bg+FcNYVKhMYsmKBeAR/cXz3WLt2rfj9738vP9544w21WwXADILdgclWNI1u1wEQbSsSrKxXF+cYuUC80hhEJjzO1VKBWeQjATeVJbp+5tqGG5FZe0TVFGsTq32dg946bR3EI5jdOmhoAqYaTuMRuBzWq2syaS6sxUZkNDkdHgvGc4onZdGNyMzNH3el0GnrpAy1nJ22iEewDeVBc+byQ2v32n8B4CwewfScx4KrBaethXgEgqsF9nZ4+0zod+G0JQp08Y9iyVTBDaQp5sYtLEZzbJe3mbbO4hH8zbS1Z/Lwz2k74WjslAph1IhHKNTmUlbxOpoOuBRt9+3bJ0466SRx7LHHis9//vPy45hjjhEnnnii/BkAwB7JmpAxXLbAEQUpddom6DBJq5W8MhhEt+3Y+ISMHDj7rrfEhn3dYqqItk0+OT2s5pQZubYedDQPNyKzNtjhnNimniFj4uWJAyfHWaZdXYnu1oHTFsyQeATOXaVmNSonv9bvX1lJJxs8gU7lM9VKIzJigd7YbbcH91u7Ar6dcwHxCM5Zt6fL+PqJtxojGtsAL8fiiEewc69NtkDG1OsLeV47bZ3cp8yU6aaUZoV9OQynbZzIMTuwGE3PZq+aunGuq9NGZHQt0VzLDwZdOqsZdhUra0Rmcx6TKtGWKjp4DGTbaWvKMPa6wSBwINp+8pOfFKOjo2Lz5s2io6NDftDXExMT8mcAAHvwClVyp23qM/jY9ZEoHoEyoTgioSVgzcjIUfW5+98U97+2V+ZVUaOcIGN2Zjb1DAeqvHi+p05beyvnNKjhc26H4gxNiqdg4aogx9ngi906frmlAVCF01w2uiZZ/PDLbUuTD57YxGuiaH5OVRTwMzUYoi2XlMZy2i4wnLb9UyseocB/59V0wRyJQBE9yLZNXTzCfiy4xhVtrTYVm2M4bb0VbdmB6nS8trSmSH5+t7E3mE5b/X3R2JTFYO+ctnbjEbImRSz4VgHiOh4hy2gOPqpgvw4q2i6vm7tRLNOYHsPHYyK7x3t0PGSMD0CARNvnnntO3HXXXWLZsmXG9+jrn/3sZ2LNmjWqtw+AmbO6H2OiZoZXwFIq2urO2USiLcENB4LktCW31yd/t1Y8aWrqEfTmKKlw2nZZdNpyqZuX8QjUddUqi6s0t+32FrWZj+ZGa5wl5rQRGXLxwFTDzYSo3qdJujlqiM0eyRqRBeWZGjvaIUY8gp5pS/vSLwdT/HgE6/dBfo6Q4xrY480GzWl76Oxi+fnhN1DN6Es8guk5jwXX+HT0c6atVadtvi+LeG4akREHz9JE281N6kRbFgGzVTQiMy2getWMLLyAYW8fUtNMzobluYTXqMiOjRb5VVQHceySnXlMImHUq4VPHv9QdZLd85OiRDL0XjxoRuY9ts+k+vp66bSNZnx8XNTV1anaLgBmDNYzbXVXUG9qJj8kpHFDpmQdJoPWjIweJh+9+1Xx/LY2WUJz8pLKKeH+MYt8frk0rZYXs4jghfPLibuPIxLUi7battC4xGnn39mmRmQoIQJTCTdNXcK5tv6Itnw/p4mElclHEKpXzPc8rjCI5RKuLc6V9x9yxPidEzzpvpydblu09WsCP53GhVtbNNHo1gsOlZ9f3NEGx6en+3yyUDVLjzZq6h6STn7gPNO2vlx7HuzvHPRsX9KCFrtanZbLHzRLWyTZ3NijbLt4m5yOIaOFUX4dr3Jt2UxU6CASjJ9f3FjTa1Q5Wmm/ssCqIiLB2C6XYjIburwSRVstmrHiVSyhGZl/2L57/OAHPxDXXXedbETG0NeUbfvDH/5Q9fYBMGNW95Nl2oZLOVMzweSJIg0WivMSC8zVRdpAtyUgou3dL+ySrhV6uPzxk6vE6cur5fc7ppLTtscv0ZbLixMPxJfoIimVDarOkQ07bVMv2vKKe0F2phygOKFWn/iRKBP0hQIAVMQj+OmscpqxGBZtRwITk0SLQ4UxHGLp6WligYcLZfYEfPtOW36uAGts2NstXeMkdB0xt0wcv7BC/v8jcNt6BjccNccjUJNTuiapDL2tPxjj2SBAi8/h+22W5Yasmelpcl+qzIs1M2Aq0XbqtF1aUyjS9OeCqog3jjHIynAv2poFaTYVqIbH9HadthHl/D7d89lp6zbT1ixSq2hGNlUybY0mZAl61VjaPjzjPcf23ePjH/+4WL9+vVi1apXIycmRH/T1unXrxFVXXSXKy8uNDwBAcnoGJzc/SFTKSUJjKsoj1+7W8l9X1pcmFa+C5rTd0qStmH/+jCVyAsQu0iALaDQojsi07R7yxaXJD95kTlsSRsj9RWxtVldG5nSww6LtjlZvnLacI+aEnMwMUVmoXb/IxgMzJR5hjk+NZxh29lgVEcLVK6l/TvG20wSIBNpYzE9xrq2TLt2caUv3dF4AANbzbI+oL5OfP3jUHPn54XX7UK3hYzwCiWwkNhINHkRBTVXoeqbsTzuZtlRGzXETXu1LjgsgcdhpFAGJvfVl2rNhs6JcW3baqohHiG5GFqRMW3M0EWe0ew3vA7fiqPn9qhBtuXLG7Xbx/vRKtGUjmFPR1msnMAhj+2r88Y9/bPefAAAsxCMky7SlEiTSSkm3I9eK0xusU7hp16oFyRdkONM2KE7bvR2a02ue3jyLM7iCnGlLgrI52J0GyPQ9q/lh7uMRkv+dZbVF0gFMA9uj5qlbqHMy2GHRdk97v8ySIqE0CPloDE1WyLlBMReHzi5Rsm0ABDkvjjNt/XLaWs3jZnghJQhOW15AjNWELDqSZnd7ikRb3WlrR8AnAYwEFIp1oGcLC2DAmmh75NxS+fmcw2rFNx57W2bIv767UxxrYRwGHPaXiBKqFlUXysVWquI5ej72u9k5T4217DgcyTne0DEg9nYOilUenKAcF+DWdbmkMl80dA7LiIRTllYFzmnL+asDCsTFWAIzC/LcnMtRPIJPppghRWN084INu+6DkLVbole2dnskgruJRyAQj+Afts/wK6+80pstAUDM9IFiVtK8HRJu2/tH5MqY36Ltq4ZoW5H0d4PmtGWnF4sIU8Fpy45MEhZIqKfjToKf16It7xMrbrXls4rEc1tbxRaFDRsinbbWB7i0UEANECh3eXfbgBSUgzQJoGy8Dfu6RaNPDeUAUAHnsjnLtPW3EZkhfFp02vJzKgiZtuxSSRRLszDF8QhOylCpKoeqMmgfd/aPQrS1AFXUcBMyqgzS9nmmeP+KWeLPa/eJh9/YC9HWA9hdVxgt2lYViDVbW5VX8UxlOM6FBBs7sVFaZE67Z8+EQUUC3pKqPLF6W6eyXFuVjciIPP399XvgtDXHnUVfC1bwc35F98oBReKoWbTl/i1qMuBdirb5HscjuHTaQrT1D9t3D4pB2Lhxo/H/jz32mLjwwgvFV7/6VTEyknq3AgBTdfBjpQwlVY1TqJEMiYjkmDlynub8sJZp608OayLoQcfCOJfrcuYhObOC2hiKG4+RQ5MzUZt6vBf87Dhtl+vCqGrRdtjBIIwmDuSIUZ1ry5OAAgVOWwLxCGBqxiPYP//5fksNfvwoneu0GO0SxEZk7BK24rRNXaatszLUcj0iIciVLUFiZ1u/vF6ofwA3RSI+eFS9/Py3DY1GZ3LgRUl4VpzopdRcd4lEoavufV3c8td3Ams2iYaNE15F5nAPAjdxVsSSKm07Nx3oURuPoMppa2Tajnm2eEF/gyItHMcj+HC/Hx0PiXG9qZ1bcdQsUqtw2hq9OVwK9X5l2jp32mZGaBnAO2yfSddee63YunWr/Hrnzp3iwx/+sMjPzxcPPfSQuOmmm5Rv4Pz58+VkPPrjs5/9rPz5qaeeOulnn/70p5VvBwCeO2ySxCOYc239nmRyNAKVdVtZwQ47mEZS3nGXV/QrCrKNbedJ/ch4yJOVapVNyOpK8kwdjL097jQR5Im5pXiEGr3LblOPUvHbaYC/F83IeBLgdkBIx5FoNOUUAxB03JT4FeRkGnmHtPDnNd3cGEefNE6lRmQ8DihNKNrmG8+GVIh2Tl3XvEgK0dYa7LJdMackwpl3zPwyOU6kMcu2Zrg+VULjVBarog0Ui6q8aXLqlue3tYl/v9si7n1pt/JmsJbNJhbmLbEW8vbpkWWqYddlgVunbWWesYCiIot7KmXasiDvxGVrrtLjnHY/nkmqnLZUrUf0DY8q27Zct05bQwQPeCMyiLaeY/vuQYLt4YcfLr8mofaUU04R999/v7j33nvFX/7yF+Ub+Prrr4vGxkbj46mnnpLfv/TSS43f+dSnPhXxO9///veVbwcAnjcgseAOqijgxikjgc2zJSoKtfxdWgGlxmmphMWCOfoKPz/cszO0FeTO/tRP2BOJtrNKc8NOW49L63lQQIvrVpzfi6oLpPuaBnnsDFaB0wB/Q7RVWMbIg2LOEHMKHUfzcQVguscjEPU8Sfch15adttYbkXHDlFExNh4K/OJtVWGOLN+kdVC/IidUCPi8SMrHB1hsQqZHIzBkSjlYd96+c6Abu1EhfSbHorkRmVm0JXdokJrpPb2pWX6m9fKN+7tT04vDprDntdOWG5G5XWSvKsySC2g0h1GxQEKOUKVOW308yqYCL45ttOPcKvwM8yMegZ9JbhrPxXTa6udRMDJtvRVFedGaxhdOgGjrH7bPcHJTTUxoE+qnn35anHvuufLr+vp60dbWpnwDq6qqRG1trfHxxBNPiEWLFkmxmCGnr/l3iovD5UQABBm6nrqNiWZ2YMs5DdF2oTXRNkvP3w1Cri03IWPxgCc/JfrDOai5tlxGP5viEYo1wU+lMBoLdkLRuRivg7kZava1sKpAeUTCkINMW2KxB44YlY3I/DiGAKjEqes9Fbm2vABq5VnK1QRc/tmRYpeI4bRNIDjTc4vdtjtTUKrNAr5dQYTd1kFdIA0a6/ZENiEzc0hdsdKybRDpLiRRLfpeR4s7JE6SOJqqJoCxnMGr39VEW4Ly8lPhtLUbjzBXF22pga0X1QIcF8DxAU6he+1Bs7T4LxW5tuqdthyPoH4fcjRA9OKFVYz4OR+eqXy8VbhsVTciG1Is2tI9iqMgVCGNVf3DEZW8TrcPTlvvsX1FHn300eK2224TZ555pnjuuefEXXfdJb+/a9cuUVNTI7yEMnP/8Ic/iBtvvDEi+PyPf/yj/D4Jtueff7747//+bynkxmN4eFh+MD092g2ZxGgWpKcr9P7MwjtILfTA4a6ixTkZSY9LRWGWIYT6dQxbeoZkiRBdckfWl1r+u1RqQc2zmrsHxbIaTUxLBSwWUFkWbzt9phye1v5R0dE/JCYm1DStUgk7MmuLcwzhhJpYeXncO/XFAHoIW/07S2uKxNbmPrGpsVucsrRSqTiQk5Fm6/0u1HPIdrb2idGxcUd5XNH062VSeVnprvZ9rV56RJMVVdvmFjwPgPVJkb1rkZldpi047esY8PyZxaIg3dut/i0SFOl52tE/mtJxEW87iUOJtmN+eYF4e3+P2NXW5/v2skBAWat2/jZP6mhyiLFnYqhEf2uztgC6ck7JpP11sC4kvX2gR/m+nMnPgx59wZoqjGK9f6riWdfQJbY394qlekVPKnmzoTMi1uWtvV2+HjdzLw47f7csL1OKWDSmpWfCAj2nW3mcVVby+VSy64B6Nry8s0NsOtAtJiZmO94mei2e51GBn4rjxEIgvV/Vx93psWWKczOMTFuvz8kBU3yZir/FYjjFjbh9PZ63ZWc6GzsxRaYqv+6BYcuL0lZoIy0hpFVXlkXN+6w+DzhSgkTbmfjsUIHV/WZbtP3xj38srrjiCvHoo4+Kr33ta2Lx4sXy+w8//LA44YQThJfQ3+zq6hIf//jHje9dfvnlYt68eaKurk5s2LBB/Nd//ZfYsmWLeOSRR+K+zu233y5uueWWSd9vbW0VQ0ND0/7E6O7ulhdierqaFT/gnGY95iArI030dbWL/iRdWHMmNFHtQEevaGlp8WXXP721w8h4GurtFEMWDZUl2dp72XGgTSwvTV3p6Y5mLR+uNHPM2Gd0HRRkatu0p7FdLCsJXjOyfR2aoyMvNCRCE9rDf39Hv6fHfXeT5vChtQGrf6e+UDvOb+1uEy0HqRG/B3ShdLCvR7S0WHcS5EyEZOzF8NiE2LBjn5hd4qzcx0xbl37Cjw272vehiZCgyjha2d68a7+odriqrRI8D0Ayege1Z9RQPz1z7N8nSzK063d7c5fnz6yOPm2hKzTUJ6z+qbLcdNHaK0RDS5doqcpL2biotVu736eNDibcT9W6H2Hz3nbR0uKfeERjxkFdwB/o6RQtE9Ydh1kT2jnU5OO4Zaqydm+PnETXFmWLtKEe0TIU6fKrzdWOweYD3aKpuVmkJxkz2mEmPw8amrTqnLzMtJjnaF1hhlhH45xdzeLoGjWuPjc8/sZ++bm6MEu09I2KN/d0+HptNXVo52XGxIjtvzurOEvsbB8Xb+9qFAUTaitjWzo0x3H6xKjj/cHXwewC7Xn3VkO7q307qgu2RE9nuwgNuqvakoxpc8H2bvX31MY2bR6QLcYdvfbEoPYc7ux3N2a2wn69qo60ViV/a1Tb9vaePtev19Ov6UkjA+5fi0wjg6MTYse+JlGvR62pYFurZmoqzcsU7W2tjp4HoWFtLNDeO4Tnu0N6e60JK7bvHCtWrBAbN26c9P0f/OAHIiPD2wfZ3XffLc455xwp0DLXXHON8fVhhx0mZs2aJc444wyxY8cOGaMQi5tvvlm6dc1OW4p3oCiG6R6tQBchuZTpvc60QVkQaR/XBj60cmbFqb5APkv3iN5RIaqrq73fQCp7f0W7kZ+wuNrW35xd0SREQ48YTsv2bVtj0dK/RX4+aC5tf5VxHZQX7iIpQkxk5aV0++IN8tr6NeHy0AV1+sr3NtHaP+bptob26IH0JfmW/86RtG730gGxp3tU2bZRgzhiVnWlqK62JwQvqCqUUQ2d4zniCBXbk6kNtqpKi12/v9riPBl7MZJVIKqrI/MKUwGeByAZery0qKuuENXVJbZ32MHzSFRqEK0DE57fZ3uGtY1dOLtaVOtRKcmoLd0jtrYOipH0HLl9qRoXDY5vl5/n1lYk3E+HzB0V4tVG0dTv/f40Q6XMHPtbP6vGUuNUpr6aRNt9YnAiPXDP2qCxa5M2eTt6fuzzoLxiQuRkvisGRifEQEahWKjQqTiTnweZmk4lSgu0+0A0h8ztE09sahdNA/6NvRPxcoM2rv3c6UvEN/+6STT1joiM/BJR4TCX0i5j6Vo0Q225/XHR/KoGsbN9SPROqJ8bpGdrJo3y4kLHr83XwbG0L59qENvbh+Q1Ya7wtQM3uCPqamtc5+0SVWUkVjaKUIYH86ssbV5aUVLg6LXT8mgesUn0Do+Lykq6l3hXVZbbrd2nCnPV7IdZlTTX2itGRabr1xsXW+Xn2spyY+7pFNIIBruHRGY+XW+TY3Oc8m6XNr+vLp48D7b6PJg3RiLyVtE/6u+YZDqRm2tNiM90E1VAKwfRlt65c+cKL9izZ4/M0E3koCVWrVolP2/fvj2uaJuTkyM/oqGTciYMVOginCnvNeh067k5FHhv5XhUF+UZmbZ+Hb/Xd2uj2eMWVdj6m9V6Dmtr30jKzjVaIeQGOHMrCiO2g1YWuTlK0K6F1u4h6bYhB3ZVUa4o0HPDaPBHnaOdNghIBmdQleXnWN4nB+mNUXa09AmK7VKR2TWk538V5Fi7LqLLGEm0pUiPMxUcVyPTNifT9XlSV5orRdvGbv+u32TgeQCsNeKzfy0S9eWaqLS/c1Cea04nvskYG58wcinLCqzfvyr12JKOgbGUjovCmbaJt50WpYjd7QO+bmvvsOaWpcNXnGct85wp1xuoUn58UO57QYXK3Ikj5pXF3FfZ6eli+axi+XubG3vFYpuLmsmYqc+D/pEJoxFRrPe+RN/PNK5I9b5paB+QkVQUsXTB4XPE717eI3a09ou3D/SK05aHezd4CQuRJbL/gb39MVc+E1rFvq4h5ftyQD+OBXGOo53rYElNUbjRbs+wkc9uF5PRVuRm03a5fwYW6CXp9HxWvQ+5CRflFTt57VI9w5wyoOm6stJk2+1cgWINVOwHnlvR+e329Xjb8uQxd/datEhK/TB6h9Qe73bdHERxhrFe18rzgI93z+CYp2O86YzVY2r7yG/dulWcdNJJIi8vT8YSLFiwQH7Mnz9ffvaKe+65Ryr473//+xP+3vr16+VnctwCEHTCTcisPdToxkpQlhU1IvAjZ+9dvcHUMfOtNSGL7sxtzt3yG/rblCtEzxASzMxw11vKXQoaB7q0sppZJVSumybD8Slfimju8S7ChZuycbdvK1CjNMo0GpsIiZ1tfUqEdqeNyLxoRhYWrdyXtIWbkWkLCQAEHb4WnTbioyxxngR52fTR3ATDjguUOyZ3DAS/ERnBzkrKxua8YT/gY0f71m4edxk3Igto088gsaddK1elPM14cDOyd9CMTBmUYUnEWxBfpOfY7milLOnUxmk9vVlzuR4zv0wKYivnaM679brg7wck0BA8LnXyTPCiOeXgqJpGZNxol0wABC2QOMXIs01PU9bLgJ/HXjQi69UFeafmENpvnA3bpccrBa05Zjxo0UZZIzKF21bsUbOvVr2PCY+DnMDjLTrPh7g0C3iC7RnxJz7xCakIP/HEE+KNN94Q69atkx9vvvmm/OwF5OYl0fbKK68UmZnhBwRFINx6661yO3bv3i0ef/xx8bGPfUycfPLJMsYBgKDDzsaSvGzLQig98ykXs03v+Oglr+/W8mxp4GK37KqiMPUdo/d1aoPC2uJcOZAwY3baBg0W9cxC86wS7eumbu+OOx8rnmRbgVZVl+kTTHK4uoUe/DwnynUw2OFBtjrRVhu88SDUDSTCm0V5AIIMxbSM6jXxTjsgUyd2Xmzkqgcvn6UkImRSeLRFKg3R1j8BNBoSgXgylkxwpjJJFnZ3t6kXPZI+Gxw0QeFFwFSOBaYK4WqXbAuirZbfCdzDLv14ImR9WZ6sfCJR4kCKF11ZtD3zIC1SbcUcLbZmwz4fRVtd5CY3pl3qyzXH6l59fK6Sft0lSu5GFRysV5JtcrFAMqI7Lun8UQWL0l4s3PG1wAKmE6h6lPByodbc7CsvS83xLsoJO23VbZv7uYOxPxWLttSIjOAxmhPIVMSLEapFZeBStCUn6y9/+UuZLXv44YeLlStXRnx4AcUiNDQ0iKuuuiri+9nZ2fJnZ599tli+fLn44he/KC655BLx17/+1ZPtAEA1XTadtjQZ5UlmS4/3ou1ruzTR9tgF9ly25pLI9hRO1PbqIgGv7Jsp0QcknQF02lIJvdmZSdTocRNeujQ7bZ6PDIu2btwIjHmlNjdKaLcr2pJr1y0UR+HGaWiGRfgD+vEFQCU7W/vEBT9/Qfz+lT1KXs/s4nHjFiHBw6tJOsMVE3ZFxUq9IWAqnbZ9I2PGQpUVl/D8Cs1tu7vdejOwVD0bzMeEHFzmpjwgEnpeWam+MgtJKp5xIOys407oscbefN1RFEGqoPPjVX1cftbBumhbrzltN+zTmgb5AQt77AC0Q70eM+CF09aojFLkvOT4r82NLkRb/Z6XbWMxMRn8PGaR2hvXufMxL8VmeCEyxjvegXTa6nMZWrh2C48LtP4mHjhtXYi2ZNzhylWItt5i+w5y8MEHi7a2NuEnJMrSg2jp0qUR36fmYc8995xob28XQ0NDYtu2beL73//+tG8mBqYPXDrCq2hWYPHOyzJ55jXdabvKiWirP7Q7fHAEx4MHhTxINFOiO229Xgl2Aot6FD0w2Wk7FDjhgzL2iC1Nzge20eXYtHDrxJmwoLJA/tueoTFjQOIG7piuYhJQpzttKZsKANWZrjc8uF68ta9b3P9qg5LX5GuRXBRuXEKcBciVD0FYAGV4ETSVFRcs1FEcjJUJHkck7GrzTzxy+mxgYYergoP4vA0KJECwwJPoPF5eWyz3Jy2IN/uweD8TSBaP4EUVjxOe3doiK+2WVBeKebqITCI+Za/S+cAL/l7D4pEzp22ecc9V4Wg0w87TPNWibZN7p62Kfg8Mx3Wxm1MlLFiyEOfOaTviT3yTAmGUXaO8kOpmAYT+LR8blaKt8ngE3WnL46CgbR+IxPYd5Hvf+5646aabxLPPPivF0p6enogPAIB3mbZETXGOkWnnJTQw5My0o+bZ73RfrscjdPSPpMwNwiLBHL0cy0xJboaxfUHOtGVqWfDzMtOWcxVtuieWK4xHGDKVFDkJtKcBEpffqZhchcvtFMQjwGkLPOIXz+6Qgq1KN77RhM/htRg9Sd/b4UeVgE2nrT5ZaU9hPILVaARmfipEW4uZu7Eg0Z/fWxArW4IC72MSdxKV1NKzaJGe3Y6IBH/iEQje55Rrmyqe3twiP5+pu2x5zMPVTuS29Roaz/e4cGOSMM73EdVu27DTVk25/EGzioysaacC86gHTluO6+pXLHpHxCPoUQFO4ONrFvG8mAeqFun5fKZNdZMXPKwL9aq2zRBFFS96UlNzt05bAqKtP9i+g5x55pnilVdeEWeccYZsDFZWViY/SktL5WcAgIPmHjYmmmGn7bDnK+kk3BLVRZFNvOw4bSkTUfVqulU4Q5HLc6dOI7L4mbbNHro0WcBmwd0qPGE40D3kelChYnWam5HtUCDa8qBQSSMyXXgnRwyL0wC4ZeO+bvHT1dsinisqsu5UNfnwx2lrv2rFLNp2D45Jt3IqMFzCFrPtWbTd7aNoy2Kr1W2Mhh26yLW1dg4nWyRBMzJvmi8lyvFcVK3HI6TIaUvj6Ge3tETk2TIr9GZkb/mQa0tl35x17iQewcuIBJU9CAjq5VGh93jY4zCOxhOnrZeNyBTEI7Bo29mvvRZFNh1x61Piz6/vFSoZHJlQKtrmZKZL1zrhZt5qHt/nKjjuvD9VN3Zjp61b0darRmkgEttX5DPPPGP3nwAAPIhHaPHYacuTNCoXcTLYoIcouUVIhCMx0GknUjfwgJBFg1jxCJRZSoMqlQMqL+IRqJmal6X1JNDzMa/Q84itQiVytK1UmreluddRBrLKHCgqY1z9bosSp63hNlQwKKSBF18TdBwpygEAN9Dk4MY/rxdjEyHx/sNmiTVbW6UAQW59Lud124nb7YTImKB72YhMFz656ZVVygu05p60PknPqdpSNQ4tL522HI/gZ6ZtV7+z/cvI5pZt/YFs/BkU7ER8HFJXIh5dfwBOWz/jEaqKUuq0veeFXdIFOb8iXxyu59gyK+eUiD+9JsSGvd2+7Su6bzqNjaLqi437u5U/E7gyKl/BIrv5GUEL7U4NCRx5kuWF01Yv43dTCeNkASMZpaZ4vNue2CR+88Iuo4neh46pV7SlpjGKongE2o9k0KBnMl1rNcXuzCcUK2WnMaqfoig5wPl5jHiEqYHtK/KUU07xZksAmIF0BTgewU3jEfNgh4Q8GvBw/pZfkAjJ+V5cnmumKCfDmKyTw6VaF0VTDQ2IKY+VmGUWbTnT1qPjToItVy85mZiT21aKtk09LkVbdto6H+iwE83thICcd1zmpKIRGQ0IKSJhZ2u/aOwahGgLXPOjf20R21r6pFPi1gsPFZf96hW5cEILP25FW6PJh8sJETeCJKet6glm9AKonaoVLt0nFyg9o9r6SLSdvMDnNeFttxePQNtLZcpOciUdO21115ld+JmCeAQr48Hk+xhOW7Wwqy6Ru3BhVfi6ozGj3SgWN9Df+9WanfLrG85aanRrZ1bqIi4JoRMTIZEe9XOVhKMRkjvC48ERVqqdtiyWqXLaRrocRwPjtGVRmsbsNEZVkZtK0Llj5VpIBhuR/vTaXkO09qIxNVcDqTzeZFQicdSN05a3S9VxCccPqKtabe/TjgU5i+1WKEUDp60/2L4i16xZk/DnJ598spvtAWBGwatmdkoO/YpHcNN4hKko1ETbDv3h4CfUqI1KuOiBZM6GZdLTtAcVdQ0ngToooi07aekhzaH45ngEcoORsKlqMBD9AKcBqpOVYcq1/fe7LWKzy1xbHnS7cfdV6SXPnNfklAFTiZOqQSE5kkm0pSgJANzw2Pr9hoPle5ccJhfJaFGARdugxCPQNtHcnlz0JHi4LcVLtMjoZMGpsihHTiYpL/xQkcKYJIsTJ3oukDOG7m8UkcCl0V7i1MnMsMAF0VZN5dXBdcVGBBQ5AK0K/iBJpm0ChyY58GgcRmO0Ha394qh5/om2//vcTumApHHW+SvqJv2cGpPRQjcJTTvb+sTias0V7AUsHBXr1Wpuqi9UR+ZwxqtKEa9En585baLIoq1Kp615IZXes6r5AI152bzhZjGQhW4SbEmsvvzYueLel3a7HpPHW1hWOR9isZobsqWqYtAMjw24AaDKaASap7td5PFi+8BkbN9BTj311Ekfp512mvEBAPDaaetXPIIapy3RkYLcWM6zrSvNm+RKmFzCE5xcW3YHs0hrfihS3hLR4oFg396vP8AdOqk419ZtJMEwO20znQ92SIQxD0rcilZ0/vC+d8u8Cm2y8vquDiWvB2Ym/3ynSdz457fkBOsT75kvTl9eY9zvCBWLAqpcSzmZGUa8i1e5tk6aejKLdQfdTQ9vEC9saxN+wxMdO26XBZX5vjYjY0HR6SIujwWQaZtgH9s4h2nswvFJmxrRBFpdI7LE+95oRuZjri2N9e99SVuc+/J7l8UUWGih/dC6Evn1Wx5HJHA8ghtRL+y0HVRaXceVUQWKGpGpyBPl/F+VTlsak7JwqzLXlo9tpssxLx9fWuS7/5OrxMeOnxdhDgmys5pdo27mrYb5RJFoy3NVlT1YVDUhI9CIzB9sX5GdnZ0RHy0tLeLJJ58UxxxzjPjXv/7lzVYCMA0htyTf2EsciLbkDBoeGw+007Y8haIol13FikZg2DUUpGZkjV1Dk/JsjdJ6XchV1R3eDB8ju3m2DDerc7uSrqIRWaXeSI0GiG461hqujawMZSXdH1g5W35+/K0DRpkhAHZ4bmuruO7+N+Uk9ZIj54j/fv/Bxs/4vqHUaZvlfgIcjkgY9LZ838Hz6uZzlotl1flyofJjv31V/OLZ7Z50ulbltCU4D9sv0dbtIm61PjFs8rhCaFo0IrN4DocjErzPMZ3usKsuWY4nR874mWv7s39vl869I+eWitOXV8f9PXbcb/C4GRnHd7kSbfXnwV49MkcF5uabqhpTmRfTnGfaas9RVQv/DAuVakXbcDSCmzHv8QsrxL2fOEY8+YWTxdHzy2VDN4Kc4Cqb8HoRjzBHH0O5WWAeUiza8tiAerBQFq3SJmT6sXEDRFt/sH0HKSkpifiorKwUZ511lvje974nbrrpJm+2EoBpHI1AK6aJSrJiCY3ZepmNWyehlUmw03LICKdtKkRb/YE7J0FGYbhkMzjiGYst7Jgz42WuLa+AU6mMW6HUDSrKijhUn0qzelxkQBlNyHLUDQiPmV8mJ34kTj/25n5lrwtmBq/sbBfX3LdWntvUeIxiEczOK17YUSHaGpm2CiZE4WZkA966FB1ks9G99pcfWiYuOXK2zDj//pNbxGfvXydFcV9jkmw8aznXluIRvIZEFbuCYqJcY6Cm8oqakRGbDsBp6wYSWDh3M1mO5yLdle+XaNvQPiD+9FqD/PrL712eUEhbWa+dDxv2d/tSGeAm83R2WZ6MzKFnjKr5gReVURFOW4fzhNGxkPJ4BPO4lJqR+e04Twadp6cuqzZMRsW5mbIpl+pcWxUmj2jmKHCBq+jNYYb2H6MqgqBVN9i4bUJGQLT1B2V3kJqaGrFlyxZVLwfAtMfsrrGzokm/W603I/My1zbsrHHhtFUk5DmBH7iJnLY8GAtSzl4i0ZazeTn3ViU8kGKh3S7870iAcLMSrGKwQwM4XgjhgYkb0apAYakdXb9XrJorv/7jqw2+OvrA1IYmpdf+/g1ZAkqOq//34cMn5U/zfUPFPcIoPVQwIaJJuiox2YvKkNzMdPH9Sw4Tt114qJxc/n1jk1izrVX4gZMmagv0xp672r0XQTV3T8jVIu4cI8PSm+PvVhj79Zqd4v5XG8Q/NjaKl3e0y0x8vzHGXBZ7HAS9GRldk9TMM+iwUEUUJnnWczyC2xgoq/xk9TYxNhESJy2pFMcvqrDkvudqLa/gCiEuI3camVOjV2c1KGpGRvcp1ZVR5vuy03iEYf0aYLONKgr0c3VgWH08grmfhgroeHAVX7vCXNuw01bd9tYrWGBULSbTOI/nNLzI6xY2fXGcnBsg2vqD7bN8w4YNEf9PE87Gxkbx3e9+Vxx++OEqtw0Az2jqHhIv72wT5x42Sw4eUoHhXHEw8KHVS5r8eDmxCE+CnQ/MOB81FaIoO7o4WymR0BikeATOtK0rndwYjVet6fxVTYfLTFsS98nwR+Y0yi102thNVRYUDUSocQfFNXBJo13YwaCy1I64+Ig54ntPvivebeoV6xo6xVHzypW+PpieUHYlDdjJ1f6LK46MmZHH8Qh0H6HxmZvJq6pGZObyeC+qQ6jRC0/Y3WSw07766HHzxMZ93eLBtXuleHfasvjlyKob+9iKR9Adf7ta+1wf52RwDi2db07vy+y0pePvRSNNN+f4lfe8NilmgjId/3XDyWKhLtL5QTc3IrN4DnOOPG07dX1320xGJVSif8GdL4pPnLBAfOP8cHxLEOEu8SRUJduHPJYgoZHuOypzSqOh6/pfm5rk19efsSTp77NjjvoTeHk+9CqIR2BDBVWN7e0cFEfMLXO9XUaclcLKKPMczXUjMsXnCj+XvXHaqhVtuYqPjrdKE4/q7NjIvOWBQIydGFokoTlNlyLRlh27bub4DI9dgjSXno7YvoOQMHvEEUfIz/z1ueeeK0ZGRsRvfvMbb7YSAMXc+sQmccODb4kbHlwvBzepgG+8Trr+clMXL0Xbzn79hu5QxJP/Vl+hVlkOY5X9uqOHHT6JnbbBiEegQTq7DmI7bb0TbcPxCM5WXakkjY83dYhPdddVjmtwk7HLA68Chav4fM1zB+g/vqKVPgKQjM16wyEqi453fdDCDul3NFF0e99VGY/AzS5aPBBt2QFF79utkECcsFhztL20w5+mZN0OFnDnlRcY+ZJeP7+6TZM7p+IwTeoK9PPIK7e1E374ry1S9KTnxZkH1Yij55XJbSV347Nb/HFaO41HoLgk0uWotF91V3YVMS5URPLIm/t8ixlx6y60IlTRfYyc+PSW3FTxWIGuaxbRDputRR8kgqOtyBWvyo3nVTxCRGSOIqdtuCmV2vEaX49O9+mox05bHqeqXMBwG4+QaFFB5b1K5RglWrSlhW+n964hXah301DZazer4ZhXcKw5uo/mfl722pnp2L6D7Nq1S+zcuVN+po89e/aIgYEB8dJLL4nly5d7s5UAKGbDfi2on0ogv/3EppSUKBvdrh04bf2JR3DfiIwHkezi9AsaJHGzLi51iQW/t6B0tKaSOyprpsHdwbO00sdYD8bGnuDFI0Qe75GUZ0GxSNTmQiTyyrlBXK5HJDyxsTEw5x+YGqLtQTHuDQw5v7ixhNsyWZXxCFV6KawXTlt+ltKkRoW7jJqocNm5H84RYwHXxliAJqm8iOd1MzIVYwESe4MWkfD67g7x2xd3ya9/8MGV4jdXHi0e/swJ4pqTF8rvrd3TEeh4BMrI5OqbfQESws3HmITojTEyVh9bv18cdetT4g2f97Fbd6GMJ9PvZV5HaOxp7zdMGlYWsalqkO8hXor4RiMyF/EI5uxQVTnXxnhNcWUU3/fcOm1Vu7LzPXHaqhHkE80P3Jg6/HC00vVGCzO0+OH0Gh/yYLv42laVacv9Ptxex1yhyed3c3ewFhCnE7bvIPPmzYv4qK+vF7m5zspgAUgF1GHUHDB+70u7xa/W7PR9O9gd5CQzlgfq3sYjsLvGRaatnmHU4XOmLTl5aIGUmhGweBcLFsyDkmn79OYW+ZmyywpiZEqxw7pJF6RVwjlTThuRyX/LmVUuRHpVXVd5VV9Fpq3qSQBxeH2pFOZpQP+XdfuUvz6YzqKtVhYdD3bpc9SKUwYVxoNUm5y2qhdJeZHIyQJoLCjahcqgaTNf2emtqETX/4DDaAfOsPRetLUvKiduRpZ6gZEm+19+6C15jC89ao44bXk4BuOY+VpczWu7On1b0Ke/YzceISIOJQD71Iz5GK/ZOtmxfNezO+RC8SPr9gdGtLWa41nDpgkPKp7McNXV3Ir41WLxKoy8bFLMwp65OZIT2FDhpuGTL5VRXPrtMNM27LRVG1fBcwS1mbbexSMY8R2KFhQoL5sbCKpYWDZXDfIYymneshcN0tw6vr102tJiVh03wfVgfgpsirYvv/yyeOKJJyK+d99994kFCxaI6upqcc0114jhYajrIPhwAwFaGfr6+w+SX9/+j3fFoz53cjc3IgtkPILRLdr5DZ1dm5Q3yGKcH/AgkCaJico5OcvH6Qq6alZvbpafzzyoOmEzHxI+VJZEmYUPFl5T1XiO31eOItG2rXdEgWirfgArG5Idp7ltqQEOGpKBRFCMD2UgE7Fc+GY4D9ttGboX8QgkUrJTSxXcdI0rEVRwgt7052WPIxLMEzC7JanzddF2t8eirdsmb5NFW++bpyXj+/98V+xuH5Bjqa+fF5m5umJOiax2Ibci/Y4fDEQ0e7O+n3lM4HaBRjXmY/x8VEM/WmTge9nbMVy4fhN2F1qPpfDHaavtw3kJ+jLEu896Gd0Qjkdwm2mrxyOoctp64G40z4EousvJPMYrp62XmbaqG5GZ+2WoistjYdSLY+42ukOV+SR2bqzaTNviPDXHOtwoO1jPoumE5TvIt7/9bfHOO+8Y/79x40Zx9dVXizPPPFN85StfEX/961/F7bff7tV2AqCMbc2aaLukplB88qSF4pMnLpD//+WH35JdhP2CSyKdiKLheARvBo0knFGHcreZtrQSTw09/Haz7rPQhMzscg6C05ZEU2pKRZx+UE3cQQ8JzWT+2dGqrnsxrVjz+egmHqHSGJS5cNrq550qp62bMkFy5ROcxaiaCw6fLV97Z1u/eG1X6stEQXAhxwcJOzTxY4dlPOoUDZ5VNvkgxwk7s1p7hzy53yfKL3cakfDyznbhh2hL+4YcPnZYUKE7bfUyau/z7d06bYMRj0CxCFRhRdx+yWGTFs7pXCXhln/XD/j5S9e3nWigIDptaQHSfIzXNXQZri7iH283Gl9vbuo1nIipwq67kOMRmjyMJzOLtnNtiLZGhVGvH/EILp22+vuixUUVucdcGVKgOM6KBEy+NzsRzHguRXEmKuFxqUoDR/haUJ9py/0yVEV38PiEfDlUVamS8ILCoEunbXqAM23VNBRk2J18wGUsF4iP5bNp/fr14owzzjD+/4EHHhCrVq0Sv/71r8WNN94ofvrTn4o///nPVl8OgJSxtUVb4V9ao5WYfvXcg8Shs4uly+HNvZpoFvRM23A8gjcDMxYxKdfHjWBFbkIWfVV2DE0Gl7Twamk8WKCkh2Cqm2U8826LjHSgvEqeiMXan0v083abfh6rKn8lIZgGP246iRpxGEoybVPfiKxfLzvL88Bpy5MBFuj9EgfA1OTdJi0aYVlNkchMMvlTNXgeVBwP4lUzMhaI2MmpguN00XZrc5+nAki4JN7+YpkRj9DqT6atk20MmtOWBMXb/rZZPu8+dPQccdqy2FUtxyzQIhJe92kxjXPNaTxop9kbO22D1NyNxhPs0qdjTmOrl7aHFz/+sbEpwoXIRopUEW6+lGlr/N3isdO2oaPfdjyCkeXv4XjbcOi5FHvM2aFNCval4bTNUjteo+ux1EVEghGPoDzTNlO507Zv2PtMW1VzQSPPNivDcYPMeNSX68+qADltixWKtmTU4fueikxblRVeID6W7yCdnZ2ipibs/nruuefEOeecY/z/McccI/bu3Wv15cA0gQYtU61TYNhpq4lf1LhkWU2x7w4QFZm2dNPlG69XkzS3D0MuiXEj5DkVbeclGezyyiWJparC3Z2y+t3E0QjMkupCQ0zwIhMymSDkdaMBY7CT7W6AW6lg8jI46q3TllipO7re2pf6MlEQXDY1aos0y2sT59maB8+uM22Na1HNBI4daq2eibbqnLa02MgxFF66bXkC5iQmaWGVJtrubOvzdNGRt9HNgl5QSvmf29oq3trbJR1QX35v/ObJx+q5tmv3+LOQH97H9saDhtM2QBNlFuUp+/UMPSuYIxKo3Jgak5Fxke9lqY5IsB+PoFe6Ka4YiBuPoDvqg+K0ZTem24xrcq/y+eu0DN0MLxSodtoSJS6i1LyKR+D3OVUybblBqptKvJiNUj0YnxvxCA4XGClKQ3Vsg8pMW7NuoOpYczwCRFvvsHwHIcF21y6ty+rIyIhYt26dOO6444yf9/b2iqws9XZ6EFyos+nx3/23+M8/rBNTia3NvRHiV6ocIEamrYOJEDn0OHPIi9X+cBMy99d0eQpEWx4AJotHoEEU78dURiTQoG7NVi078Yw40QgMO8RVulN4EMXlS27drW4aDRhO28wMJQNEynZzmhcbdtp6J9qumFMqP2+EaAssNSFLnGdrdtq6jkcwOVmUOm0VV4iE4xHUOW39yrXlZ62TmCQSc6gslCaIThum+Ou0zTcqhFKx2E/PgZ+s3ia/vmLVvIRNSo+cVyYrTyh/tcVjcc7NeJDP+SDFI/C20PE+eWmV/HrNtla5/598W3PZrlpQIU5aUim/JhE3lbCAYbkRGccjeNiIjO69XJHgJNNWVQl6rLEqi2UqxB6jDF2FaKsfRy/Ga4bT1oFoG25EpjrTVm9E5kk8grdOW8rodwu/b5XNviafl4Mp7c0RMx5BQaZtz+CYIXiriu1gswD3GADqsXykzj33XJld+/zzz4ubb75Z5Ofni5NOOsn4+YYNG8SiRYs82EQQVMgZRu6ODQFoJGCV/uExw5XD4peKG7SryZrD1WrOtVVRVuTVJI0oS4Fou4e77loY7PJkmTtkp4JXd7XLiQMNuFfM1pyX8eDFBpXxCFyu5CbPVlU8gqquq+w4oUlGr0M3upFp60FTBuaQumLpOqLr2OtySzCzRFua9LPLx10jPjUTj2oPmuTQ5I9dhspF28WaaPvSDu+dtk5KFMmpxuOYLXp8hhd0uhyrMLQIzOdSKnLvnt/WJt5s6JJC97WnLEw6QaYoEmLtbu/dtsaYy+Y+5mudnnGqsg7dwmNsclFSzAiVwNPYmpq6cZ7tOYfVikP1sU6qRdseu5m2RjyCd25WdvjRNtlZ0OHFaq9EW3Ylq2pWxQs5TrNDY8UjFHgQZ8VzIY6zscOIR/EIXAGmNh7Bu0xbnl+MTYQiMq6dMqR4fGKmXh9LkJveyQKjyn4AXmTa8v5XlWcbGcsVnAXE6YblO8itt94qMjMzxSmnnCJzbOkjOzs8wf/tb38rzj77bK+2EwQQXk0ngSbVeaBW4eZN5Ag0C1T1KXDa8o3XqTBKeVBeDRw7FTpt/Y5HoP3Kgngyp625HJE7ZKeC1Ztb5OfTl1XLuI5EcKwHOaucdLKNBR8bPlapzKzisiK3oi25LXhS4bRUULVoFQsShBfrQvwGuG1BnAE2CyFcsp8Iuo5pgkgGczfNKnnRQpVzKey0VSfYkTBNmYgkYPIzURXHzC+Xr0tlyl6NDdwu3i7TS8zfbVK3iBcNPxvdNCUlKGopVbm2Zpft5avmGlEdyY6/X3njTuMRKNeSx2lBcduane/0fDtqXpn8/z+v3SubkpGD+b2H1IrDdNGWFqQoYzFVbNGvnVkl1u4ftfrvkVBORhBvoxHybUWU8T3Wq3gEdmLS2MpNlFZ0dqgKpy03IssPmNN2xKNGZPmeOG1HlQny0eRkZhgLIyoyl/l9qxRGGdIH6DyiMZST+2rgRVtjsVjdceb7Jy2CeRHbCGyItpWVlWLNmjUy25Y+LrroooifP/TQQ+Kb3/wm9ukMYn+X9pAlwTaVpeV24BzQJdWRuYBzdHGPHDt+CNBULsM3NaeTtXAzMg/iEXQRz+4EIhYsjrf7JNry4I+ECysDj1Q7bWky+fRmLc/2jCR5trzgQJM0Gkxsb1ETkcBxBiy6OoVFX5rMOC1/DTcicz/ANZqROZzAsHODB8decdhsLSJhKlUtAP94V8+zrSvJtVQ+TZN8+l03rgdysNpt0GO1OkSl05YFIpowqBARzJDbiIWllz1y27rJtCU4F5TPES+bZKlYxGVnnZ/9A9gt/caeTrmY8elTrFUFGs3IfBBtWRh3EpMRhKzgRBnTJy3RIhLufl6L2Dtqbpkcv86vKJBjtOGxCbFdN1T4Dd0faRxFa+XHL9TiGpJB28wuRy/G3xw/R8wrt55na64wovG2ihL0eA49Vc8EIztUgWjr5XjNyLR1IJiNjIc8iUdgcVrlwoFd17ldjPNTwRggnLmvXrSlMVQ419b+fXVY4TyGKc3TDUYO3N5+OG1pvMTnTWNAnkXTDdtnU0lJicjImHyBlJeXRzhvwfTHvPrkZei9SrbpebZLa8J5tgQ5dDLTtS6mfuSXmVfKigMZj+DOBRzbaevPOcKDP6sdd1lU5olpKhYSaJJDk8kT9Yy3ZIMJXnRQFZHAgjrHGziFBgB0HblxVg8pHIjxANHpqj47N7xsREas0JuRbdzX5enfAdM/GmFSqZrDXFsqueQ5v6qBfVWh+uqQsECkNhphcq6tt6KtE7GOWF6rnRNb9LGNamgRmyfyKsYDqXDaSpft07rL9ti5xoJ3Mo6ZrzlENx3o8dw51Omix8HsgJWlRl+Tp+i5tlwmfs5hs+Rnqio6uK44pZnu3CBtZX2prX0fNk14M65tsDmOZXjh3SszDWdhqnomGNF0Cu4Hgx42IjMEM0dO23FPG5GxeOkWMlqwK7gox5seRUbfCwXzrUGPTRXsAneSF++l05aqEd1mwhvXscvIo2jquBkZcm09Qe0dBMwozKv6XuUnedaEzJRnS1AJJE9y/ci15Qd/cW6m/NtBi0cwyiEVOGu4pLKzfzRwebZmN3Gq3OKr39Vctu9ZVGF58LFEX3RQ1YxMVTwCTcIMZ7VDodSIR3DZiCxStB121Ygs38NMW+IwFm33dztumgamL05E23AnX2eLeizU0URTVaMPL5227OpTzQmLtIW0l3e2e3Jt8nOnxGU8wu72fmMS69UCs9tM20jR1j+B8dVdHeK13R3S6WbVZcvXEG0vLV6s2+Ntrm04JsP+M3h2abhSLNXQNRLdGJAiXcxji/cdWmt8zU72t1NUZcINYNkNbFe09crkYcQj2GhCxiX4PG5XUYIer3xeVVm1kR3aM+w67ouzXb0ol+dFNUeZth7HI/A41S19+jOfKPTIaVtR4IHT1oPjHVEV4kK0zVVo+CAXKyeluG1GFnbaqj3O3IwsKAuI0w2ItsDFwGzqOW3D8QiRTlvV2UrJ4Ae/G+eKl/EIPJFUG4/gzzliOBQsDnZTGY9A19HfN2qNOc44qMbyv+Pzl89nt7DA6jYeQUUchsqSp8oiPR7B4QCRMz29zLTlSS05lGmShRVqoEK0ne1y8NzrwaCem+SQQOXWKeKX05byOKmREnVE9kJoDC+YOatyoAxLEsRIT+ZFaS/GAkWKMiwNgdFH0ZbdlOetnGXkkVrlWJ9ybXlMWOYmHiEAmbZ0bXOZOhshaDGXq4jI0crOYLNom4pmZORGfWG7JtqestRaNAJTw5VuHjnKnDptzYvVXszLwvEIWUqzQ1UsOoSdtl40InOeaUsVnAQ1QFRJgS7a9g2PKllQ5GoCqixzaiZKBs8xlGbaejQ+d+MCV2k+Yeg+yuMEyvJXk2mr1mk7S7+3Ix7BGyDaAkfQg8scfj4VnLaU+8ODAu64bGaOPpnwwwFiuCpcOFlrfIlHUNGILMfXRmQsultpQpbqRmTr93aJt/f3SDfbuXrJoBX4/N2uLB5Bu37NzflSkVlFWc+cKR0Ep60fjcgIcjLyMUVEAjBD1wOXvh80a/Jzy6tOvqrLYPl5QgKoShdYdH6mamhCuKiq0LNmX7xgVu5iwWy5fl5wQyVPslYL1JwHqXDa8t+KNe5LxtE+ibYq4hH2BcDdxGNsWkwwO/Q/fsJ82VTrc6ctjvj9Q2drC1GbGnt8b2i8YV+XdJKTg23lHC1XPgjxCLQf2K08r8Jepq25GZkX87LwcyFTfXaoS8OM4bT1ohGZMU8ITiMyqlwhbZUEQhUCvdFkziOXLVHhckzup9OWXeBOqm+HPBKUudkXLSK7gSupVI7vzM+i/Q4rvMAUFm2/9a1vyRu6+WP58uXGz4eGhsRnP/tZUVFRIQoLC8Ull1wimpu1UmPgLdErolPBactNm0jIidUF2XDa+pC1xg9+pyWREeVZPcPKyzZVdYs2C4EU4O/HoJwdCvNsO239F21///Ie+fn8FXW2BNPFejwCRUG4LSkzu2JZ5HQDvw8nIr05mytHSSMydpzY3xbqZk0NUogCjxuRmXNtN6Qo2w8Ek11t/XJSRg0t7EzgDceDw8E9OzGKFDoxaAzHbtsWRYuN0aXYXsAO5y1NmuNZJSqiaZbVFHsmKnOskYqqG/Nxau4dUua2TgY7UM0OT6scu0DLtX2zocsQX4IXjxAcp2286/GIuWXiuS+fJs46OLKiaEFloVwUpXvcDp+bkXE0wnsWVdp2kRuirQfxCLTQRu5MivPgGLSgOW1VOvTCcy935++AHhNQ4MF4jaNhnJg7yIzgRaYtLYrwmGCbgqbEql3UCTNtFSzacs8Jr0wV7HJ3ogl4JShzpYhbs1bYaZvpkaic+mfRdCTQoi1xyCGHiMbGRuPjhRdeMH52ww03iL/+9a/ioYceEs8995w4cOCAuPjii1O6vTOFaJfEVBBtt8ZpQjapFMKHeATuQOomHoFX06m5g5PVXyuuDxWZtiyKkq7stZuVhDaeuNhtRKZ6HyaDnKhPbNCiET52/Dxb/5aED9qvtE/dTnRon/F7V+G0dVP+xAI05TapKCVz4zgZMAnIXpVfmVmhO30g2oJY0QjLaottlSxyPILTktPeYW8yz6p0EULFmIG6o/P781K05dzYzYpFUYpf4ckdO5CcsFzfvnc9EJVVjFXM0DOGJrL07Gr0yY3j5hwhlzVFQ9AC3p72fg+2TotJMuIRCpzHI9BzTsUirp/Od7qnHZKiZmQcm3Gy3ijNkWjrQTwCGw/mlOc5KlP30mnb64FDz012qF+VUUY8ginj2yq8+K9atCUW61Fp3GRbRaYtOc+9wsi0VRCXZ+TGeua01c5Lmh9xXJRVkX6MKwYVmE9iiaJNLkXRcKat4ngEvZeCWycwmKKibWZmpqitrTU+Kiu13KHu7m5x9913izvuuEOcfvrp4qijjhL33HOPeOmll8Qrr7yS6s2e9vAgmMcTXgTeq4ZXIuOVyPlZttfNJYcuVqtzMjMMkU1lRILWLVrdRI1KgthR7HVEAj0o6GFJDoWaImsOBXYQ+RXfwDy4dq8U3FfOKZE5b3Yda5xr67YZGQv0JJSqcFO5iUcYNuVA0XtUtS1OBCLOR6NJk+osssRO2y40IwOTRNuDbUQjmAfPNMm2M+HwMh6BMJy2CkRbeg1ypNE16sSRZle0VR0/wG4jmsxTjmCQ4xFULOASdF/3c6xFE2jO/Wdx0+721ugTZRXnbCwoA5ZzL504benYsKMr1ZNlJxnTh6Yg15bGuG/u7ZJfn6Tn7TqJJ/PCaeu0CZkvTluuwFAo7LnJDjUv4LGI54loq1+XJAzbrRCgcT7B0UAqMeYBCpy2RjyCh413VTptvY4vo2xknmPbiUgwL5ypFpR5sch1PAKP7xRn2nLVB1ULoKmyeryv+XTJtm3bRF1dncjNzRXHH3+8uP3228XcuXPFG2+8IUZHR8WZZ55p/C5FJ9DPXn75ZXHcccfFfc3h4WH5wfT0aJOiiYkJ+TGdofdHF5Lb98klUCSAUkkedVAN+r7jCc2iqoKY2zrbZOsfHh1Tnj8Uu2N0pqv9RgNHEhtp1W1ZHAex7W3rH5EuGKI4J0PJcaUHH2WHtfUOyf3vFbvb+kwTBjrPQ0mvgxJ98EmT0/HxcSVioRVh/I+vNMivP3rcXEf7mFbYX9/dKR3kbo5Rqz7pKMvLEmkJ9plVeHJPK+l2t6tfd/flZaUrOe8qdNcSOU7sHlsWumhASOeK1wOQxVUFIjsjTWZN0XnsJMsuVc8D4B2U9UgsqymydZzoGqLFMrrv7u8csJ3nyQuLNDlXeX5U6c0BSUhz+7oNHf2G+4QWkJ2+XrLrYJk+MaaoisHhUZGjaCLW1qfde7VGYs7vMYsqC+SiG8XcNHcPGk47FfBiJi0wqzoPSDwlkWFvR7+YmNAyY73iQOeAoEcaCePlDt9DdVGOjNeifevFvbJTX+CkbST9wcnfIGf99tZ+uU/n6eXmqXgecKUajaetvs4hevzI2/u7fXsWvbC1VY7DFlQWyH1n9+9WG/cx+2OLZOxu7zOa6TrZH5WF2rintc/+GCwZ9DxR/VyoL8s1HMZOX5N6ljBux4+xroOC7HR5j5UVg/0jtu6xo5xpm56m/HjQuJGdtm5fu0d3+1NlgVfXYXl+eEzu9m8M6MecTBVebS/NJekZSGON5bWFtraLzhcy2qrctlpTA0Q3r9utz28KE8zxnTwPqoqyDHc5zffdVBDNJCYs7uNAi7arVq0S9957r1i2bJmMRrjlllvESSedJN5++23R1NQksrOzRWlppEOtpqZG/iwRJPzSa0XT2toqc3Kn+4lBLmW6ENPTnYuSO5u0FerllTlStG3tGRItLS0iyGxp1Fbxq7JHY27rRIgcmmliZDwk3tm5X9SVeHezae7UBOSM8WFX+600Rxsobt/fKg4qVSMq7enQroHC7AzR0a5lfrlFH9+KXY1tYkGhd+V77+zRyt1qCzMS7lfzdTA6pu03Ou579jd53nSKWLOjS7rVS3IzxLG1mY7OgVm6CePthjbR0mLPqWtm535NFCrOTbzPrJI5pq1IN3X22369xhZNhCFNRMW2hPQVbxpA7N7XJApyrB/bfS3a5DM3I823e9viyjyxqXlAvLBpr8hb5q2YofJ5ALxj037tWVubO277PKwuyJST7E27m0Rpmj1XY3Ondl/ImBhRev4XpGsTmr0tXa5fd9Oedvm5usDdvSvZdZAWCskFzJ7hcfHalr1iWbWapmc7dWdhcU66631RX5ojGjqHxSvv7hWr5mkimAoa27VtzFR4HpTrQ6st+9tEyzxvJ3Vv79XGWjWFWaKtTRsf2KU4Sxsj7GhsFy2z1ec97tSfNSU5GXIe4oTK/AyxnSIyGlrE0uKJlD0Pdrdp+7swzfrYti5Puye8c6BbNDY1e9a53sxTG/fKz0fPyXd2XutCHOUcb29olAYMVWw70Ck/l2fbv+e7HYMlo6NXO1dDwwPKXjs/pM05Gtqdb2+7nr1NZ053R5vocSGix7sOiugZMDQudu5rEqEK6wsj7Mzt6eoULUJt/F55lva+ybzh9ng0dej3ejHm2Zh3Qnfzkjlhf2OTK3NUd792no8NqT/Pmao8bfs2N7SIwyutnVMHurVFuJyMdMf383jkTmjXyv6OPlfvuatfe53xQTpvJpQ+DyryM0X7wJh4Z3ejWK5orDTd6e3tnfqi7TnnnGN8vWLFCinizps3T/z5z38WeXnO88tuvvlmceONN0Y4bevr60VVVZUoLlY32A0idBHKZiBVVa4m6W2D2+Tn45bWikffbhNdQ2OirKLSU3eqG2gVtklvRnTssvq4Zf+UrbSzrV8MpOeL6uoKz7ZnaEJrQDWnukxUV1c7fp36ymbx8u4eMRDKdvU6ZvYO6gPGQnWvWVOyV4gD/WI8M0/Za8aic1Tb9sW1ifer+TqgzyzWZxWUimoPsxGZv/5NO/4fPnauqK+rdfQaRyxMF+LZvaKhe9TVPp1o0gaUNSX5So7NgkGa1O4QvSMh26+3u1/r0J2fo+7cy8/eqJVR5RWL6soC29tSmKduW5Jx5PxWsam5QezpFb78TVXPA+AN5EZp6RuVjo3jD6q33SBkbuVesa1tUAyIHNvn01ia1tS1trxY6bk4v4YmC42idyzd9ev2vqMJywuqS9zdAy1cBwfVlYhXd3WI1pEscZKi/TG+d0TZvffgulLR0NksmoczlB6vodB++XlOVamy111S1yfEhlbRNeL+HEjGwD5tH8+tLHT8t+ZWdwjxbocYCGV5sr3berTF8bJC+9cps6CmRbyyp0f0jmc6fg23zwOa3Dfr4+xDF8wS1VXWnGkVlSGRl7VFlrf3pxcYOZ1eQdv5+r5N8uuzV8x1vL+oqojipcZzikR1tb1KhkQ092+Vnw+eV+No25aMkXN1u+gcGld+vg6Oa9s2p6ZcVFfbzwKORUEJCXmbpCCaW1zmKJJnUM+bpoV5Mm+5Id51UFaQI3qGBkR6Hh1v64vqnG86q6ZSVOuxRaooKiWX92bRNTgmMvJLXDkbQxnamLeq1Pm9MhmVEyGRmb5B7pP0/BJX+2Nc7JSfayrczaMTsXhWp1i9rVN0jVp/rnaFNAGODECqt2t5Os1htorW/jFj/uqE/hFNqJ1XVy2q41T1OX0ezC4vEO0D3WIo3dv5/nSC0gSmvGgbDblqly5dKrZv3y7OOussMTIyIrq6uiLcts3NzTL7NhE5OTnyIxo6KWfCxJUuQrfvlTNtD5tTKlfFqcyIHhqctxI0drRpq5tU0lJemJswW4lEW3p/Xp4LXGJUlp/j6u/U6g88ylpTtb3detYN5Zuqek0eSNAA18v9us/UhCzZ3zFfByTi0z78+9tNMg9saGxczK8oEO9ZbD/rLBk7W/vE89vapBDzH8fNd7w/luklhVRSRoKz0+wko3t5oZrjXaVnCVOprt3XG9Zz/SifT9V5QseT9lHHwKhYZOM1B3UnDU0C/HourKBs41cbZLafX39TxfMAeMM7jdrgn0p4S/LtT8bq9Hyxph77z4devcSvROFzgKjRn1kkSLt93f16Iyt6brt9rWTXATX7ItF2S3Ovsv3BeeL0fHT7mstnFYsn32kWW5v7lB4vHquUK9jG6AxLr8dZxIEuzfU0p9T5OVJTrH6cZaZbd5/ROMTp63Mzp/3dQ6620c3zoHtgVPQNa4vAc8oLLL8G/Ro1I1u7p1M8tblFLK311jxDMSc0VqSM0RMWVbo4L3LlNdzaNyIOVnRekKDcoOdn0hjUybZV6/MwGtuFRJpS5zLnntLzSNW1UJSXLSPUaHvpnl5aZ/9ZNziqjx2zM5VsV6zrgK5Pyhsmcdnq36C4Mc6rzs1Ss21mCnLTZQk/Za7SPLdKv1c5oVe/dotz1T7zzdDL0rGme2nnwJiYXeb87wzxGD1X/X5luKH13k7rz6rhMbXnopm6Um17yIjSNzJh9Iux23ya79OlSa5jJ8+DupI82VCZIhwwr7CG5WelmEL09fWJHTt2iFmzZsnGY1lZWWL16tXGz7ds2SIaGhpk9i3w1rXK3eZp8M1B3V6E3quCSkeIpUlyX/1qkBHuyOyu1M5ohtAzrDxvV1W3aILPEa+bfXHXXcoCc7J9t//jXfHFh94SX/u/t8VH737VyGdTyYOva2V5py+rNiavThv60AObFvF3tjrvas3HhPeBW0j85UEFN/OyCv++yo6r3Pigzeb9aUAf1ORn+be2yc3ItGw/bzN03UI55u/9f2vEjX9en+pNmba8rXdTX6E36nEq2vIiq5PJuepO0pwFqKKpk91O9W5YpgtJFAelClrY4kxbtyw3tk9zHzPbW3plCbdbYVnleMDoFu9DIzLuv+CkCVn0OKtV4TjLDI+n3TR74wYw+33Yp/HgRlK0UGp3EfmyY+fKz794ZrtoUdhYNxZrtmoly0fNK5PNhpzCJpVmhc3faDzWpy+YOR0f0liOTAE0hFA95uZGZMWKnwv1+vVpp+GTmcFRbZ+5aeiYDG4czc0Z7TQhI7I8ami7RHd5u21GxuddoeJjG69RHi3cqmhEprrZl5l6/VllZy7IjchyFM5jmLzsDEOo5QabTo+zF+M787jzQIqbYk5HAi3afulLXxLPPfec2L17t3jppZfERRddJDIyMsRll10mSkpKxNVXXy1jDp555hnZmOwTn/iEFGwTNSED7uEJIF3sVMbC3aAp9D6oUBMJ88MtaRdTD8S6WIN0txOhGt3VSJ0agzSBiIYFQZ6kei7a6qujVvnMqYvE4fWl4tj55eLkpVXyvVPDgXcORE6AVfDGHi3C4byVs1y9Dq2A8iLEthbnQkKbIRyoyRakzrPZekwKNSOzA2d/0cAk1QPEgRFtYJNvIwfXLYurCqVgTd3EydEXZG7/+7tyGx9Zt1+8vEPLFgVq2aBnnnJ3dbvU6w2JnDzPwpNztRme1NQp3IgkpESQs9Op3inLZxVFNDRVAXfQpigit5ATmNjW3Ccrn4jvPfmuOPOONeL7T77r+HVZoFA5HuDj1dQz5EpQtjNeZVHTCdX6OKtZb9qpGnYzc4d6J7AofaA7daJteBHF/r6+6IjZYmV9qXz2fe/JLcJL+Nl6zPxyRaYJdefFHv1eXVuc61iMysxIF+X63MKtMGaG7td9I950nefGq7v1mAO79PMie7Z3giObbPh6tcKoSbTlcbFqluhxIttdjhm5+a4XQl4sYwc//5zCJg8vjzlrAnRvs9oolGJeuGLQC6jxKtHoUBTt0atpKb7Bi0jLulL1ugSYAqLtvn37pEBLjcg+9KEPiYqKCvHKK6/IfA3i//2//yfOO+88cckll4iTTz5ZxiI88sgjqd7saQ+v5PMgmJ0zdp1sfrK7TRsILNQ7babSaUsTqp4hNU5b7ghOoh2v7gXZadvpoWhLpXk8mLLrtL3g8Nni0c++R/z508eL+646Vpy6TMvh2dHqbuU6Gnro84SBnVFuWKwvQrCT3Akd+sCJB1JuITHZ6aCMz+HcTHWDHb4/2a0E4FV8PxrTmSdbJy7Wnm9/fFXLPQ4iJNL+35ta1iXx/57eanlAGwSobOu+l3fbdoL7DTmuiRVzSl25RHgxyw7UKMSLyTkvolDJKFecOBUQWJBzU7Fg91lLDmFV7rUOfVFLhdOWnnk0SZRNF9v7xb0v7hJ3PbtD/uy13VpWoZvxAMUlqYLeLy1O0S2j0WORkc8RN8K+WZzz4j7H4yI340Eejzd2DRmivd+4WURJT08T3zr/YPn1X9btE+v3ag0YvRormu9FTiFhVbWY39DuzHigatyTLDKHT3/Vwt4iPf+YDTZ2MRbZfXHaWn9umRelvBJtOQPardOW70Mq7/Wx4OvOrqnDb3GUBUhyrdPfarM4nxnyeLtqddG2yeGzk/UH1Qvy0U5bp6IymKKi7QMPPCAOHDgghoeHpYBL/79o0aKI4N4777xTdHR0iP7+finYJsuzBe7ZFzUIrpwCTluetCab3BmlEPrg0wtoNZMHPk7yaKKdVFT+TRNgnuC7hcshVT64/XDa8jGm89HtyusiXdxXLdpSuQiVHWempxmDVDcYTttm59vZodhp6yYOw4hH8MBpS7lzzkRbf6PfP3nSAvn5obX7RHuK76m02PVmg+YMN09C/vuxt+XX5xxaKycir+3qmFJu2+/8fbP4xmPviG8/oTWjCSI02aZBL00YKO/RCbx4RUKj3UU9r1w32ZnphmvTjaBA74mee3QvrdEFCi+hCgJ2LkdHELiPR3C//SR6LdXdtj9bvU3cYjq3SQhxIjbSOTM0qokOJQqdtrSwxyKjlwvkJOyTiOk2HoGdtrQvOOvZm7isbFel+nQtUIMfiq5JBW7jSo6YWyYuOXKO/Ppbj7/jWURQ2Jjg7pzm7NgmvVu8CigzlZjnciFKVQl6rOqLnMx0kaNwYZ1YVO1uzG2M11zEXSSD8t2JrkHrY0nOs6Vrk+7RXhA27/SpeR4pMnDEgxcp1TltvRNt6TznilarMVP8zFRZMRhrsci501YXbfMyPXUCw2k7w0RbEGynLQ/MvFjRVQlNVrg8NJkDk0VdyohV5VyNJ4rSJNBtaQJNfmigS6yLEldcl0MWqJuk8aSUnUXe5tm6L5VlQXWHi6zYWGzRJ/vk+Cbxwi3L9MEaNa5y6gBq04+Jqkxbc+M5uxMGbiyg0mlbaSrHduLc8DIjLRarFpTLbFtyzP3+ldS5bWnC/JFfvSIu+sVL4it/2SCzzInfvrhLikA08P7uxSvEZcfWTym3Lb2vF7Zr3doffL1BmQCnGl6Eo3uR09xFEiWK9H/LLjgr0HHkEjov3BjhXFvn4hK/n1mludKh7gdGbqzeIC5I8QjEcv158Oj6A3JhmK5NEgtI0HCSL8eOMnoNPo/U59p6t0BORgLKlKRGTDzRdQJNvnnxwou81XBclvNrTb5HfbKcqlxbN/EIzH+9b5l85pLT1lzN4cX+dmua4ExblSL5ng5tzDnPpdOWs/yVOm09qr4wu0WdLjBRrAaRnxVMp62K8X48Fun7jo61nbzdeM8jFZUf1uYHI67GcYbT1uMxupFpbvFa4u1SvbDB8H3eaSyLX05b2j5qegbUAdEWuM4IM+IRXK6aeQW5/eiBTo6lZINJcgDxqp1Xq0T8UHU7YGSomQKxbo+acjJ2R6qMR2ABWHaz9UjYcdqELNEgaKfDAWQ8uIkNN7VxCwn2VGZKK66bGnvcOW0Vrq5XOnRWe9GIrIobkdkUbTkjjTrA+gktxHzqpIXy6/te3uPZ4lEytrb0ysxJ4oHX94rzfvaCePLtJvGTp7fJ73313IOk++4/T1ssJySv7+4UL24PvtuW4kn4nCcj161PbAqk2Ezdd4nDHObZ8rnEC5F2IhJowYAbqHgxQWfnohtBwRCI9G7KfsC5sapybcNVDtlKc3eJsw+uEbddeJiYX1nguOzY7Eikc2mqlVDyOUKCrVth3xDoPGhGxmNCFoVcNyNLUZagiqZv5F793OlL5NffffJdY/HUkwxhl2NcIx5BoZC/T2/ENVfPeHVKeF6m0GnrYebp/IoCQUZUEoadVG0O+tCDwEmm7ci4Nn7zIjuUIQMQX/tu4iVYbGRR1St4ruHm3KQxCuNlPIKTRWaex3glJqvKtPVibEdQn6OsjDQ5vm4OqJlvqgLRFrgemIVXdIOZX8LB/rOKc5OufMlJrhGR4JFoawwY1dwwjzQ5bVWID140ImOnLZUKeVFeSDToDgW3g112OcgB5PCYUqcCT/Z58u8WGhSctETLQH1qU7Ptf09NEvh4q1xddxqPMMSNyBQOwpyWCfrRjTgeFDtAg3Daf5Tvlwpe3dlhOGBocrqrrV98+g9vyIE9Ney7+MjZhphxud75eyq4bV/SYxwOmlUsxWYSmldvbhFBg9zzbkXbyGZkg7Yn53QP9OL8D0+ChqdEE7JJTlsFTQK9mCSfuLhSOi6PXVAufnrZEfJrblKzzcE2e5FvH92Qzs054EcTsujt9aIZmYp4BMKPyIlEsMO33uU1edWJ86W7jcZeqswIXojkZgeeKkcZL5SyMOM6Fkrh9eVVc0qCmq7xAqMT4THciMy78RpHxvF90QojYyHPnbYqcm3ZZUvb6fWYt0pBpq15Mcd70dbeInN4HuPNMecFROrN4M5p640hhWJAeBsb0YxMKRBtgbpGZAF12nI0gtVmJeFmZAOeNkFQJdpSKTWVL9LkR4XDwovGIyQu8oPVq2ZkKp22JO7z6zhdufZDtCXOOrhGfn56c7PjY00mKpUTc6fxCMN6FpTTrskJRdveEWeTAA8z0uJBrrCrT9SybX/z/C7Psv0SQTm1xIWH14knv3CSeP9hs+T/kxB064WHRjjv/vPURTLn7o09nWLNNi16IKi8vEPbvgsOrzP28f/8fbPnXeztsnG/JlYcNsedaDvXgdOWnRhFueodlhGCnQvXotv8TCcs0+/bW5t6XV+TXkySl9QUiTe+fqZ44FPHGfdQnsw7yYr0YgF3knDvgXN10lhVgbDvrdNWzZiQ32cqsgTJfcgL8rNdut9p/MU5nSxiqoLu81xK73Z/0ziHnod0K1DRr4EWPNnNx/dIp3gxL/OqOSWz2EUsGS+AFXhYGcW53rbiEXQx36smZEx4ca7PddWHF898M04bFceOIEj3LCvY6SLzkFEx6JXTNs/VvTGcaevNdWyupHESywTiA9EW2GJ4bNy4cfEAkVfNgpppa3RjtSjmsbhrx5nkbJVfjUhGD4aD9UY16xq6XA8aVU0g/G5GplK0jcy1VSPakquVX4sn/yo4fXm1FF3f3t9je7LGA7Xy/Gw5+VBFhctGZCrLijjTlgZ5nMsalG7EifjQMfVyJZwcrk4Eebf3gVd10fbYBRVS0P/55UeI+646Vvz52uMmnb9U0nrFqnny6988v1MEFXJDsYP4hEUVUmwmUZ/28X0v7xZBgXIzKVedLsmDZxX7L9oOeduowsjBd1EeqSI/0y7zK/KlyEr3Ejv7089JMl2r5knsYheTeV7UK1E0VjHDopSXDWz3dw2od9oqFm21MZeaxlipjEdgkwNV3ql4ftd4ED1gLm2nS86tY5TGTDz/UbGdJHpzEyOOkAlSIzKvmlNGx5LtcOS05fGad6ItO7PZeGN13O+H03YJNyVucVYFwq5Xr5uQaX9Dd9r2OY/L86MJ2aRnlc1MW68cwJxpS3N13g+OFl88yrQl6tCMzBMg2gJbcCdeypxkYYYnYDQYIlE3aNgV83gSuNcjpy2XwqnsxmxEJOxx14yMGpbwyrBKp21EybwHjmwaGB3Qz01lom212mZkO1v7ZTwENXRRMYk0D86P0o+/XXHPaISjuPGA05V0Liui1XNVkIuNM3LtLCwZ3YhTJNpSTtkVx2lC6K99FkJ3tvXLyR5NNMjJT5CwdPLSKnHUvPKY/+aSo7S4BGogE9SIhLcP9MiJMU06D6krkU7SL529VP7sp6u3eVYF4DQawU0TssmLkAO2G84U5XiUeWa4LN03IvNTtCUH/FJ9csz55E7xa5JsLpu1e1166bSlhR6i1YPGXtHCvgqnLW+v6ngEcn2O6a5ttwv5fK3v0Y0KfrK7zV5Fm9W8WKclwPHoHgz3lFDh0OOIBBXbyeMTGiO6Fb69aBDtZXPKSKetfdHWj/EaV6PRGILFWMuNyDx22i6uLnLltA3PBbzNsyVYO6C5ptO4PK+FUTfXEi+8eOW0JTMHn+dO3LZhp613CxyzOLMe8QhKgWgLHGeEsTuEBj8UOu223MHrTNu5Fruxhrsae+W01Z2sCksTjphbKj+/2eBOtGVnDQ0wVA9+nOacWoEcpuMTISn2uS0rYxZVFSh12nKX+qW1RcrLjzgiwW6uLbue1Yu2Oa6ctioHO7SvnTTl4BLKAp8bkZn5+AnzpZuHmnw1dg/6Ho1wRH2p5WOxpLpIPgdI8EtVpmIyXtbzbI9bWGE4yy89ul4sqymS7oO/v90oApVn6zIaIVq0tSraeT2od+u0pWgCHovMUSQSWWVZTXHE/dwpfk2SSfinxw0tqtstlWYHaFmBt05brxZ5oqO8lGyvYqct72Mau7gV6thtt6e93/cGljv1cdLCSm0b3FKjO7VUxyOoHn+HxXz35wVHb/D9UYXTtmNgRFnertcVGIuqnTdNHPChEZk5A5SfkVZF26zMNF8W5+h64ePkZC7ATYS9hMaUZEpwoxkMeNzsS4XT1ivRluY0vKjlZF4QzrRFPMJUA6ItcJgRlh9xA/Ei9F4V7DCyHo+gZ9q6LH9M3rlWvdP2nQM9rgbr5mgE1cJihYfxCOymJoFCVb6RkQWoKNOW82xVRiMwZ+qi7Ss7220N2Dp00YSvX9XHus3mhHxIH+CqXj13Uio4YJTbpcZpyyWifN9iJ5Ofou2qBbFdtbEgVy7nENJ9KIi8pOfZUjQCQ+Ltew+tjXjfqeZtRU3Iwgus2iKE1UUUrwf1XPrrVACjiCaqWqBjV6Nokc4qnEfO93MV8QheIhv86OM1u2JIp0dRSeZ7Mh1H/jsqoeeOIewrzLRV7bRVGUdFpfrkiibjrsosfqvVGcRCfbHbLdQ42It4BD7XShRVkrF44qZqgOE8WxWiLS3E01CYhl+qjBK9Hj8XOJKssXtI9Nl0YPrhtKVKC46G4IrJoGTaknmKXd9Orn0jKs0H0dbcwNxpfIcXUWpWnLZW5jNhF7B3x5wjEpzcHw3HvIeZttyM0kkDVBAfiLbAFvvidON14mTzAxIweaXeejxCviEumjtUqoInEm4zq8zQpISOAZXZbdinTfiD0oQs2jnhhWNwtz5hmKfQdcWOEQpSt5OF6mcTMvNglyZLNAF+bktrAJy22usNm5p+pDLA31hUsrGqb0wCUtCILJZTsqFDTUyHFV4z5dnagfNXNx1wfg/yCnK8/P/2zgO+qvru/z8SEsIKhJmEkbA3yBa3gqBW62qdj7taV1tXhz6t1vZ5amtb/1Zr1S61T93WXcUqCqgMZe8RVpgJIRBCIISR/+vzu+d7cnJzx7n3npXk8369MGACObn3nN/4/D7fz/frzZJn26Xe50ScRt5tEKIdZAyXaIpUwLMkwoLdHFYzHsGlzbmsF1AamUwm2w5jDoFgi420lwzOa+9QPII3oq21SU1RgnmH+1xcD+CQR2IX3DjshxgqY7g0RXGqeZ6TY0Sd8zP11xgH7WhGB9Z5vFkWp61UKDklSkDAc6enhDNjmxvxCOLeTQUcaImL36nc6Lp4hJauxQ+ImCf3U+KirbvrtY4JNiMznbYezFOodgJFSUQkyN5dquS8y7VNUrQ1hNE2Ge6vz2W9AgFeTFexOHzEfUE5lfHRC6ftmIIcfWi0ec9BxyNumjMUbYkjOXJBddpCIMX6GrmWdoUpnFjKZiLZfKBYoHQNFHZxZnEri/UxRkTCohQiEtx01iTTEMcvl4eUhMqGGo2KUkU2+SjFdoNkIhJM4cDhXEUsnCVHNpEMY8m0bZ2Z5o7TNqFM29AGxanO7slS4HFOISoTMG62TGuhxhSExhS7DDMaIgbRaYusXWSN4ZmWXFJrvAx+Xhzw+R3tAOcEnKShJmSpi7ZAnJZ2x1634xGw6Zfc6mTWDCXGJkA2Ll4ilRKbUyxBN+MRPGj8IlUjyTpt3ci0tR5ci8PQjcNxjP1OHAJ2M8Q5iAXJ5jBGYp+RserUmkvWF2s9FG0hYiOzH/RxKh7BEC4hJtnND/Wj0s3ReAQRbR2qHnA617YuHsE9sSfZBsB1jcjcXa/J4YpkIwelEVn9/PLKwFZ+NKzGSy0eIcuD9XmrlulaF7D7LLkdjwDyJD6mIpiZthCEhxuVYqgAJc5A0ZY4khHWNaCibbEhdPTu3Dahcv+xBaG4AXFmOQWEIOk+jE7UTuJEMzI3nTUiPsl74iQiqjq1YUh1ARmprEw2kYNzU+sGH42phmj72dpS25scOeV2Y6HW2XB5lBkNd+wgIkhWy3RXOpkm0oypysPyq1gUGOOEZHN75bJFnmqirpVhxiJt1c79gY1GmNSvc4O5AD+nuFrn+xyRsNxw2cI149S9J25tu4K0204MvP4igu0+kPimQ6pn/BBtsdZBHh8OgxMZT8Ipl0ZkHmySrc3IklkPdHDABRq7Id3hQDchkzECDaKcvl4n4xEkMx+sS9EJnggQXiBkY1iV+SpV8FwgIx3PmZP7CqczbR2NRzD+DadE27oSdGfiEbxw6PVL8oDJdF4G1GnrdjyCNdM60XG+nmjrwSFi6PuE7vGVSVZl1TltvVmfm3OVHdHWpYpBK3WZtsk4bd1tKCigd4S1lwRJHYq2JLlGZDmNIx5BnEW9jZxau0wwymXnbSx35XpwaiedSJ0sRwCLipPv3r63ynDWtHV+MLcKB2ga5o5o65zT1toYIdVcWylVxETbwSXX0gm9cvRGB6XNdrM5ZTHvRkmUbBgScdqaJ9QOC6VmyahNBwIad8hiu62PjcisDvVUBKLkohHs59kKEv2BhaQbDQdTYY6xcAyPRhAkCmK+z64AaUImLgVHqxz2JBqP4N69Lwe9yQhgItqKG89LIDgXdmmTcgVGnbOpVWBFW9Np68J6ILwZmdOYebYORCMIctDghEDXsFw/01Gn7ToXqsSiIaXsqMBzSqhAbwJxYjvZjKzO2ezM653fsS56JtWGX/IcyH0WNKetF/NCfzFKlCY2tlYdNhrHutiIDIjj0q5o64U7OfzZRyY+mnUm1xjTG9F26rCQyeTlr7Ym3EAZHDIq4bwyVSTSjOzQEXd6c1jJ7dA6qUxbjFGSF+32PTnJEG3nbaJo6xQUbYltILSJFb9hPEKma4tvZ0TbxE7/ZQMPp22ik18spJmQ0y5baVqDEl8I58mW+EqmrdOCspRz4PqQC+RkcwmIayJoORmPUN9pW+VMNIILebbWDLPJQ7rp39tdBJW4KH7I4m9PQk7b4644beV1R9yJnQODg5ayZ7+dtr07exuPMN9YYCXShExABqqMbasCFJEA58OS4n2m0zYS8vN+5XB1RbKirRN5tkLvzq2TjEdwb1EvgkwyThFZh0iJoNcUdm5rRiQkS5kP8QjYcFbYFBuwuZP1gNONKoWupgjqgmjrsNPWrWZkpvPTIWFcol8gWkvjKLcx46kcrnSSvFiJQwmisxnVXXBgo1w71ZxreQ66tsty9GDMKTONF/OC6bRNONP2qCcZp6bT1mYjMokgc6N6MZxQdVS6nltW77K//oLJR9bpbo314Zw5qJu68eQ++vf3vrYk4QrMQzXHPV2f1zltq21n2noRj5Do+sna4M/NwxcwrjBH70uxd9lhHKKS1KBoS2yDBlJodAXhLbyJVlfjz2WVNU1CtB2en60nP+Rf2XXnJZJnW2Bs+pwEE4RkSiaba1sXj+D8ogwNY0TsdzLXFv8WdDi8X06VlTkdj+BmEzIrpw8MibYLbURkYKEmmwTZHDmJuHcTKc2ra0Tm7NSE5x8ZmmiMZufeO2i4NrDgkOxNv5CxC2ORXcElWSDio3EAylzHFiQu2oKhZq5tcJqR4XnAYREWutEOzMYWhhonbPG5cYKMFfI6+pJp60H5nIhLK5K4T+T98cNpa63ocMZp6/5mHocpUk5ZtNveeqb8YI0uTccz4Zbg4GamrfRfCI/ycqoZmVOI+OOU0xYH7jKfJ1MmnYrT1ulDc4k/cdJp63SmLdYIo40qtwUpHviZmbYOrcec7DUC84oX84IcMGGvZDfmC9dmlsu38ijT1tgrxWOvh7EDyF6VkvTP14fioOyAAwcxTHjltAU/OXew7ieA++r2lxYmlBF/8IiI9EF02h7zwGmbXOa3NBPEftnt5nhYdzDX1lko2hLbSHMZTKpYqEQswwmY01YcmMi0TVRglFxbu6XmdoAg4pbTFoxOMde2rhGZOxN3Lxdyba3RCInkFici2sJJkkqkgxdOWzDE6GyORgTxrheOEwhZ1ufXSWSRmkiZfF0jMmcXOxivZDNgp6u26drITHf8nkoUZLTJ+7OlPPWGeLGQsW5oXrZZBpgow/KDl2sr2eQo14r2fmIjKkKpuI295vDRY2pHxaF6bk4nhX8cvNpZ4ItDz60u4eAEo3Hm0q0hB3QiSIWACJGNTbTF+CIbO6+6dUveod2sSDmAxyY+fL3nR05g0lFeHV1w2joo2oqo4+RB+cDu3ubaShOyvsZ6yenX29F4BDPT1rk17jgRbVPoJwHBSgRlp8wHeUZ0gxN5+HDdy5rSTWEvLztLi11HjtXaPmTEulES4VxvRGY8p7JXike5h05bcNqAUPzT7HW7bf8duUaYJdx+/aygOdtTV43RY9+K7fvVL95flbDBw3unbQKircMNla10alOX+Z3I/OlFLnWkiATm2joDRVtim2XbQpurUT0bdhQ34xEC1IgMTsJknbbWctn5Dubauum0tZbUJptn5mYjsnrZig46bTeVHXAlz1ZKK7GwQASDlFsmcx+u9Ui0xX0FZyhOzeNloEqJJxbgOKF3Y/Eti0fJh41XjouFuhvxCPWy/mxsZKUzrZcLWFtN/FzOtRWxMpk8WwGCr/WQLwjIsyDZxtGYUNjZ8YO6RECsDRbhuO9kTnVqw4FxAXtuO2Vq4sZwswxW1hGInhGxwu546mcjMlBozDUSd5Qokh+IuaWtR2OMHEAiIsYOXpTLijhV5qJo2zPBfgZOlcjaRYwOTh6cyly31sYBpZPxCP0cXoPJoYyT8QgS+eFkbwGUAYMFm/cm3U9C9k4YE5I9MA1Hmt6u3bU/5T4SIgxhvYhrdAtkGSfaS0LWaziPdWPtGDHT1uacJYJoJ5dywcM5bWBX814U80E8JD4D+epemxTyO7ZWj18xWr93L80vVl8WlSX0nnuXaZtlW+MQx7Ab+yrrc2IeahkH/YlFnHjTq+PEvqG9xFyfe0U0FSjaEtssM7paIzcnHFlwIi9FOif6DcqyMbBjMkjGbWE2ptlUnvRCLBzJpZRGJm5MgKk4E/a4vMBwR7SVPDXnRVs4jOTfTTYiAe8FRAmr29Mt8D3EURVvwyZuIacjJYQLT+ihS39RovnsrA1xv77aIuy6sRAzu2rb2AjIgrCtz03Iwp8bt3NtF24JHcxNKExetJWIFpTMBmUukIzv8Cz2cCYaC0y/RFvrIaOTmyf8W70SGHu9cGPAYSr3tRwI2wFjqZRy+haPYBy6YmxP5h63RiN4tUk2nbY25zFzI+9iWa8ZN+CwaFt1+KjpqHTDaetkPIKIAE6KtuZc54FoiwNZGVOcdtq6Eo9gOm2dG9tO6NVRr71wnXJYkLR438454QxGBrgnMV6mkr9dL7rBpfVipAMmu2OVxFnBoQsxy03E0GI7HsG43zp50HBS3nOMeaiis2s4qhOWvYtGsHL6wK7qm6PybUe7eRVBkIzTFlEdsj5xW1BOJtfWa6ft+MJOOlITa3Cvmik3ZSjaEltAtBTRNpLTtl2rlmb2o1Oh96kiC8n8DiG3ZKKM6tVB/z38PKlk11lP36T01S2nLX5WKYNNVGjG4ltcWJKB6DQFnZ0XbaU0r4/DeWpO5dpKNAIWU26evCZaGulmEzKQ0zZTPXjBUP37Jz8tivv6WfOs3MiRlQxNO07bKolHcDkfLdFmZE7GioSD8WKzMc6l4gjvlp2l3Xkw9qxJoBmGm0i+ZTzRFgtMgIOGPT7MY/L+JlMZ4tSBGeIT5NDC7UYVEDuANImzgwg4KKl0s9FHvLFNHFfJiCHlHuYchndlt+20NdzArjptjbkHh/12XWF2EOEM8R7I1XNeZHZGRMQGX9bLjoq24rTd5X6mLcYTuDjhGHc6G9/pOAqMbZVGIx4nI8AQYYQ+GOJwTKkJmYP3AYTkQYbbdnWKcUWlxrjrRpRWtLFqQ6m9sdVcr3nguky4EZnxfHvltIXgL27bWTYjEmSs93I+ijZm2Z1PD3lcDWc30xZ9MwS3BeU6p20Coq0HVVRW2rZqaVYAz6PbNmUo2hLbCzM4XDLT0yJu6DFRBC3X1syzTXIDDIFttLGpdMJ5BeEAOioEbreaj3TvEHoPcNInTpNEG3ph8e3WwkzcXk6euNVl2rrjYu1niMHJirbrPIpGCC+NXBPHZSOLcDeakAk4PccpOk79739zud6kxluEwRnihvtMFoUbyw7EzfUU54bbnYgTPexwM9MWi1G4F2BU6ZnioU1dMzL/RVscRonQF+/ngtNExH3JwfUScVLL++0kMg9uLY/tBDtgNJvxQrQdJaJtArm2fjchcyLXVoQ6r9xX1mgQCJp2BFJZx7kp2mKtIRtbJ92rEmXUw+HDZ6uI6ET1FdbUEgmE0mSnGGBU9OA+c/vwSZqQ4dDc6Xlb4hHwzDvxektpsBt53eOMA78FW5KbN3YbBwFOO1mHGn0OUhZtTaet++Nuv26JOW3l2twcqxqItjb2V1hnSvM2rzJtrbm2n6+3Kdr67LS1ZvjbrSYTp61XB7eyJ8aYjd4Ddswnbl+bOG0TEm096FcQjjTHY0RC6lC0JbZYarhs0egommvVFG0Dkmu7xQHXkplr64BoK/l32JC7VRIJoVmyEBMpmagnfrqw+A4XbbFIgLsmVfBvyILNjUxb6wLS7ql/tOZzTue9xS2NjOu0Pey6+IH76H8uGq435jj4eHXB1qhfKwshtxY6KBmDSIBNsjhK4zYiC4rTtlNbW4JbKkizkrwkKxMiRSQEoRkZFrQ4K4B7205O7AQHx/xEKTZE+UQbZzp5YCaLejwraMjphdN26bZ9tkUZ2aDIhqUxirbWeASvwIZcNuV25jJpROam+wrzQ7ds5w/7Ze2T7/A9ItcKwcCJ9Yv8zHCNO5kTCndTLyPLN9n+Bonm2bpxaC7xCHi9RfxKBXFHQrBwemwzm5El67QVUdThQ/QhRsb8qhQPUHe7dH2RkBixjaUHbM0LOw1nvRdzQgejgR3myXg5wZKfjO2UW82dI3FS/y7aZY28eDtxHXKw44XoHdeYYNNpW9d3whvxEZU1MK3F0zhETMbXutXAU8iVytoE4mPqMm29cdqCSf2MqMmNzkVNNlco2hJbLDcy50ZGiEYQZMAPimhr5gOm4FqSXFsnnLZS9uFkV/BYC11EJCTX0Mu93FXk6EiXZCdKvUV8gxjjVPMGp+MRzC7WcUqznXbaQkyIdSIs8QhSouoWEIvunTpQ//5XH6w2Hb7hHKoJuV/daiQBgUDcZvHyfoOWaSsLWsSrxHpPg+LyDFIzMolGwPNn5zBqooNjfrJzljSec5JexvgTLx5ByuecLCuPJe6jAzLy5yV3OB5+NyETZB6PdwAUFNHWKoYU7a4MRCOyepEDDjptzegfh+8RCATtW7V0rGTfjTzb8HXA+tJKT5y2bvQUwAGurOvkPU0FcUe6IaCNNZqRYW2RSGNFQe5/p52sMhev3pnafSCRIF5k2mINAr0LURZ28q53yEGeg/nVsZy2uDZoT/GiAPdW1eUnuy3gWcEzIwein9uISPA709a67sRaoNI4OI5FtceZtvWqiW2ItqgYdJvknLZHPc20BWMLcvQ6D3thN40nzQGKtiQhp61kk0RCBrSgZNqKo0gcRskwpqCjDtHGYCOb/6A2IRPglLMuZBKPGXBXVBYXmRO5ths9uOa+RjwC3MH7bDYfsCI5wT06uvu+WydylDUfPV4b0wVW4mFjiRtO7qPHjsrqo+rlryK7basNMdLN8H7ZyMZzH0lGmledaeMBcQfZXdgo2BW3EqXYOFRyQrQVp+2anfvV0ThRFN41IbP3c4nTFi7hZDbfyQIHgrURmWu5yHHGXdkwedFdGKKMOMHsRiS4ncVtF5nHk8m0xcYUdGrnj2hrx30p6zg77vRUEJHKqZxY67/V3YVS7q6G0zDa4WNQRNu6XFu3RVujEaxLPQUkIiHRyrFIVByqqVfi7vR9jLkTc/Si4r2BEUUHG+MrDrv2GuJcMrglKkerGJS+H3YyuMVp67SzPhIZ6WnmnjKekcNPMfRUIyJhto2IhDKfDhGt4JBY5ho7EQlirPByjd7FRjMyU0z24LqSy7T1bn1nPeyUXkjMtU0NirYkLigBWbG9otE6bVNxLWGwGWEI1ak6r2Rz51YTsoanb4eSW3y7Ldo6mGtr5qm5eM24ByT3NdFSWAgxdfl6rT07ER5kY8O220PxAy6DacNyY+ayymLHjSZk4R3U40VHSL4uSsSDAN5Ts5GUS83IJB5BohhSdSFCZEZTBieaOKbCNmNDF68JmYDnATnW2Hx/sHyn8gpsBJBFjmfFjbFCmktCiI4lRnvdXdhsRmZTtA1KPEJfoyIluXiEw75skofk2s+39KIRmVuxWnXRP85fuwjBdhyAtkVbF15jydBfF6eqxKmDc6lIchpx1JdUOOe0dasqa1xB6MBvYRIRCRKV4XT8AHpoyNohlVxbt+IbojE4gbFKBH0xrLiN7JFkzxRE0VaakX2xvizuwbk5H/nYiMy6N7ZzEGqKth42I7XTjKzaw6zd/I6SsV5tuwLP6/VdeETCvE17PP2+TQ2KtsSWMIYBEptwcWrEWnw7UcaUKhg4pYwyVdeSmXG4sdwZp63roq2Rc7MvoE5bI2vNiaZKbjcha1AKm6Crau/BI2a5jJciw8A4GzY0BJNFuJuNyCItMKLdlyKUuuq0tbmRrZJGZEYpbBBINPPLz3iEtLQWdVl6PufaSoWEXdEWXDmht/743JebPMvgktcfzwncPE6DnEsRCWMdmNXFI3hz74sDY6lN0VY26EFx2tot54wcj+BthqA0CIyXb4l73mvR1gkR1As3tsyXTqxzRahz22nr1hiGyiO5l91aN5rNyBx4vbEeA27li44zIhKSaWIpTtau7Zy/Z9GLJJW5GPePl/EI1lgHO9eM2CiQZ6wx3aavcUARV7Q1KvO8bEImjOzRQWc3oxx+mWG6ioaM9V7PR9HXuPGNCSKOQpfwCjtzlbyWXqyfMDYibhBVlXbjT2R952WmrXWdl2q2dnOHoi2xHY0wPL9DzFwecXF8vXlvAEpiQ4M+8sdSLYWSZmRzNpbV6wyZaAdzuaZCFzqDWxFxMJFysnoNvVwqcxMKDCdfsQPZNl4JzXVNZxJzOYrLFpO9V11OQTynLRaTmOgR8elV8wHzMCGKA7z6qLuZttbXBeJ7rGfZbETm4Xtm14XgxHMTszLBofEpKLm2icYjgG+P66U3Aygjn7thj8eVIe6NZXaakZlODI8W9Sf0Di3ml2+v0N2241ESkExbazmnNBkNejzC4NxsPeZjro/lFsLGrsZ4L9x2iZmZti44bd1wBUoGvKNOWxeEMMQVYL0O0caJ/N1YLluIBzgUcgPJJXZCtK0wRDRkjLrBeEO0RWNFrPkTqWaUOBI37tlUD1CRLYsqEK/iERI9YBIjQL5XTltjj7TR6AMSDYmj8MPBikZ7p0hEQoxcW31AF4BM20Ry4nHNskb3Mh7BjtN2fekBVysPwivwRhmVSottRrL45bQdYjzPRaUHXOvL0RwItGj7yCOPqPHjx6v27durbt26qYsuukitXbu23tecccYZ+sa1/rr11lt9u+amyDKjCZnEBERjdO8cLZCi9HJRsT3XjNsbYGxS7TSficW4wk56A48A7Uv+NCepckhk4qLRKEo53FigRxZt7Ys7m4wTYwh4bg/mdruYxwMT9yaX89TCRdtEm85s32c0QfKgQUJEl00UR6kIHzhZd8PVFwlZUOMwIZLzp7rG/QB/PHsojcSzGCuPzOxMGyCnrTw3xQ441MOBU1AcU07Ft8hG0e1MRbsHJ4k4bXGPXDqmp/79c3M2Ky+QTOFUGmfGw4zYiCnaetuook/nttoRhCiNePcKDlrELScOvCBsMjcl6H73qxEZhDW83vHKjsuMclm4hdw+bDTdSw5VaEH4lyZqbjhtZePuhNNW3IturAmRCyrrlniNN4OaZ2t9zh2JRzBiYdzItBWhBs43CJwrd8R2N1rB/Yo1CbYqbowJqTYjExcwTDBeiWQi2hbtPhDzgB37Talm8+ogT6Jx7MYj+OG0Baf07xo32q+q5ph5wOB/PII9py0OFPG8eC3a1kX5RB+L1htjrezB3GZ0r5yE4qUqfMi0lbxprPNgFoJwS5Ij0KLtrFmz1B133KHmzZunPv74Y3XkyBE1depUVVVVf6C8+eab1c6dO81fjz76qG/X3BRZZqMJGcCp/pmDuunfz1hTovxEBn0nGrpg8/rsNWP1KSROqs9/4nP1zpLtSebZpi4ixyO/Y2xxLBJyYux2nq1VlIDzGA6DZNFlqYeP6oWuG417rBSKaJvg5lxcfl6LthIDgIOGqsMhESbSItyraAT9vTqEvhfEGVnMet2IzJr3G6vBhZziByXT1prNbad0LFFExMOGERl4TiAb+WQaNTkFBBw5vOqZ4DN43UmF+uMnq0tcyxGOnCnsvmgr3ytWowqv4hEQpWG6ReJsPGTcwsGOW7mUbh/mYWwRkaGzR1UOkRwvsRzwZYaTyIsqDHHuOdXAFi4oLHvQQLaTC2KJK05bF0riwUAjw/3fy3aoP80sUne+tEhd9uxc21EkdnsKuCraGusGJ5y2+1yOR8D6Ap3SwcIt9nNtZVzDITockk4jB6hFpZUJOYAbHC54uF6U0m/sEWKt1XYYLlusXbyqZkPmvexhYrkG/cy0BYONWIxY4vIeY9yFoQj9O/zEbgydvOdYB7T18Jole9yO03ZAjChJNyqV7Iq2ZiMyj522GBuHpHh4RAIu2k6fPl1df/31atiwYWrUqFHq+eefV8XFxWrhwoX1vq5NmzYqNzfX/JWdHboxSOpggpeSGskkicVZg0Oi7aerS319+eUkx6nF5KkDuqoPvn+qzrfFyeQPXlmifvXBatt/f4uxqXM7z9ZaXgVxTFxJQYkZkMVYRnoLdeRYbUJu4GjXDEHU7cVaXTxCVUL5cHBYe9mETMAiUU6FZRHhdwd2OH9EBIgU3WEG+LsYj2BtRhbLfSSZtl6e4tt1IUBgRSaxK4dcDro85QAIjvpkNopOgKZVeKkyW6YlLEAhvx3NPPC4/2Ou+25bM1PYRdFWDp9i5SJXitPWQ1F0tDQji1OhI/MF5hC3Dz8TeT0Tqb6RzDvck34cCtnJipRyWYl/8GK9gu/pRKyWzG1wxOJAwGm6O+gMdjMewer2em3BNvXo9LXq/WU7tevuBYeqB+qa17onUMgaxQlns+m0dXFsQ2Veorm2ZhMyl+4DVJngEA5r7mRcbnKfepVnCzC+mxEJOyvizgle5dnK84rDbawtYh3o+i3a9jOeSxx4RDJvWMd6v1221v0xDsTEOBGJNcbchfEtVmSj1wd2OGCQ52uAR07bEwxdBuvHSGYYK5hfoV/4kWkL6kRb5to2SdE2nIqK0MDdqVNoUhRefPFF1aVLFzV8+HB1//33q4MH3XfFNBfQsAcbbtja7WQdYpMLhwOEIi/cSdGQk1knSxRQevPSdyaq753VX7s7/zx7o/pklT1H8WbZkBvNS7wTxw4lJtq6HDMAMMlKJ/NYZbrx2GS4g70QmuFQw3sOQSPexGhlxz5/nLZAHKXrIpQcu9ld204zMnldrByqMTJtXRYyzGZkMUqxDxoCclufnQfhDno8OziMkU2eU4jz0knBEBsbiFJ6Y5NiFEqybJUmZB1bJyXg3GC4bV9dsDXqpscp5DVyMx5B8tRjZbD6kXkmTltkQcZC3HZ+NyGLdJiXTDSCH8LzMDMrMroQIq5XL5y2cMNiXMPhiGT9OpNn6849Iv8uvk8qDb5qLIfqbom23xiRp+OycAD1zVH5ZuSLU80hzQotD+IRcG+kevhnZtq6FI8AxplO232274/dLmYwmy633OQFE3ECe5VnK8g1x8q13WEYAKRnghfg9ZR7fkMMF6sZj+CTaNuhTYYZtxFtjqprQua/aIvrlWczVkXZamPtPthYy3uFjNOYHyMZJ2BQwPq8Vcs016s/ra+Z3IvxKijkQN7LSqrIMS0UbZMlODvSOBw/flzddddd6uSTT9birHDVVVepgoIClZ+fr5YtW6Z+/OMf69zbN998M+q/dfjwYf1L2L9/v/k98Kspg58PCwm7P+fSrXvNPFv8vXiLkPat0nUY/9yN5eqT1bvU9cam10twjdIdvn/Xto6+p9j33z1lgHYF/uXzTer+t5arMb07xC23kgkToogX9xhKyjCx7Nh70GwQZ8cxgU29F9fXq1Nr3cQCjq8TjUZviSKZpMjoS/SaE30OMtNb6M0PynJQEoiyrUTyNPM7tPJ8bIGj9IuiMrVm1/4G33vXfqNBWjtvrwsbsGWqQou24d/30JHQggILHjevaYCxwMEYEe37HDQEOpRfBWVOSG8RyoXauveQ2rT7gOrqgDNCngOpBEBurpM/L0StFTv2q427K1VfDw6swpHcbDjdk/m5Tu3fWY+JOHR7Y+FWdc2JBS5cZf1M4Z4ds1y753oZjn902z5Uc0Qf8EUrn2vXKt2ze39kj2xzTN938HBUwXiXOG07OPsaJTofCAWdWpvxCHb/btmBunJeP8YWWQ9g/j1QXROxJHa3IY538uga4eiFCIr3t1v71MY1uUfgCnTj2nPbZ2pjAiIutpUfTLqKZndl6Drxb2W79KyhjPvLH59p/hnl3P9atE0/Z9U1R7XbO9nnAK4yMSO4uW7s2LqlXn/VHKtVJRWHUqpakngEmFDcut5hee11JRnW31jf2hFvSoz1GJ4Dt65rSF579dXmcu1avfh4fkJ/V1zOXdt7O2bhmuWQIdr3xR4H5GU7NyfYeQ5wzyM6cMNurCNDFabh7DUOCXLQR8GndSSqQeCm3VBaqYYar2ek+QjCchDWutgj7ztYode4g4yquGhOWxhTvLzmTm1CcyUc6+VVhxs4qNfu2m+Ouy1UreMVcbHcttjDL9pSrk4fGGo+FwmsrQB69GA/Ee+1S3ZdFI1Bue1M0fbYsWOBqJYKCnZf40Yj2iLbdsWKFeqLL76o9/9vueUW8/cjRoxQeXl5avLkyWrDhg2qX79+URucPfzwww3+/+7du1V1tTPNEIJ8Y8CxjAcxLS2+0Xp+UchJ2j8nQ5WW2os8GN+zjRZtpy/bps7r7/1GfU/VEV0GBYG1vTqoSkudf0+vHtVR/WdFK7Vl72H1wBuL1c/P6RPz6zeWhgbzDmk1tl/HVOicFXpv127brUZ0jj0w4l6AqKKvr0W1J9fXJSt0TWu2lqnS3sm5C9ZuDx0odMk6nvA1J/ocgPz2GVq0XbZpl+rV2l7sxFajaVTW8UOevK5W8lqHFgwrtu5p8L23loXuxzYtvLkfhY6ZoWsq2oFrqr/5Kq8IifDHa9y9B3PSQ4IsxM/N23bqBUw4lYdCi+3DVftVaWlwOp3mtm+pcI62YvMuVdg2deenPAdFJSHXXU7Lo46+9nnt0tUKpdTyzSVqZJxxyA3WbSvTHzu3Ukn/XJeM6Kwem3lQ/f3zDersPlkqzYWF5rrSg6ZAcWj/XnXIJSMCxrs2GWnq4JHjamnRdlXYqaFzau+BkIBwvPqAp2NDfnam2rG/Rs1esUVN6B054mrTrtCY3z79mKPXlsx8ANocD40NWG+s37JDdbDR3GPTjtA92S4j+XvSic1n+cGjat7qYjU8r+HGeFtZaDxo3eKIJ9eYk5WuSvYrVbStROVmplZFsGlXqCw9OyPxdYFd+ndprdaUHlQzV2xRZw9K7tB5XUlobZDTpqUqK4ve3d1JMmprVbvMdHWg5pj6em2xGtC1TdLPwY6Kw9r5CoEyo6ZSlbrYXKZz2wy1c3+NWr1lp8o4knwUw16jQd2xQ7hee2u4ZBjYtY1auatK3x/nDO4c9+u3lIYccm3TnB3XrPQwzNBLtzRcD8ajeHdoPGjj0XggdG8VWuOgqduukpKIc++mktBr197BtYud56C7sXxdpdfXDcVQ/F3Jiz1+COtIZ6uj7JLfLk0hUHL5llI1Ma/h/FRsjJdt090bLxOhe9vQenxlcaka0y3ya7/S2PvlZrn3vEQjOytd7a8+ptZu2an6dam/h1m8cZf+2KuDfb3ECfp2DL1OX23YrUpHRY+x3GLMOW0z02xdX7Lromh0aHFc6zKoMFm1absjxpOmQmVlZdMRbe+88071/vvvq9mzZ6uePUPlPdGYOHGi/lhUVBRVtEWEwj333FPPadurVy/VtWvXJp+Hi4cQpxv4We08hEV71umPEwfkqW7dIp8mhvPNcW3VE7O3qcXbD6g2HTo51tjGLuuLQpsinHD3ys917fs8dnkr9e1n56npa8rVJeML1ZQh3aPmyGDBCUb1y1fdPCiVL+haptSGfarqeEbc9w15VVU1uC+UOmFAz4juK6cZ1LNKqWW71Z7qFrbvq3B2VK7VH0cWdlfduoW6pLr1HICBeaVqwdZKVV6TbuuakclUUR3a1I/o18Pz4PdxAzKV+mSL2rS3psH17ju8Xn/s16Nr0q9/MvTLO6DUklJVcSStwfdNywgtIjp3aO/qNeFf7tJutS63rFCtVWG3+oscuOh3V4U2dEMK8lQ3jzoS26F/bqn6urhS7Tva0pHXSJ6DXZU79J+H98lV3bqFyjudYHDPCvXxur1qd3XD99sL9h0JLaL753dK+vtff3on9eycHfqAbldNK3WCUcrvJAtLd5muGLdfJ3yPVTsrVaXKivi9Dh5dpT/2zsPY4PzPGo3RBZ3UjuW71LaqFur8KK9BxZFQA9C+ecm/n07NB0Ju9mq1a/9hdaBFazXAxrNzdE1I3MrNaefLMwGG9+ioZq8vUzurW6qzIlxD1bFt+mPvbjmeXGN+p2Itgtakt075+x04ZjxL3d279vF9d6s1pcVq0/7apL/H8vLQfNe9Q+o/c6KN6L7evFeVHM5QJ4d930Seg7UVdevsvNzIa1+nyM9pq9fQqdwfcAZXGnmOfXt2dzX6Y2K/PVq0Ldp73Nb1Vh4NPW99cp0d16xMGNhKrwc37qnW728iLrfKI5tC15fX2dN7NafzcZWZvlodrDmuajLaR3Qt7z0curYBPbo4dm12noMRhceUmrdT7TxwLOL3RZwS3OH62nrnqbYe74OFob0OqPdW7lElB1XE6zzcYo/+2KNztm/zkZVBPSrUf9aWqz2HI68ZDxw+qrZXhPbTEwf38jwvODe7tdpffUAdy8Rarb6rdefBnfrjiN7O3Yt2OHVoK/W7z7aq1aUHVZcuuGcjP9vr94fG7Jw2rWxdXyrroli9Lop2V6ndR1qpYQnu25syWVlZjV+0hbr/ve99T7311ltq5syZqk+f2G5GsGTJEv0RjttotGrVSv8KBzelUzdmkMFDaOdnRbnmWiMb9oTeObZfm/7d2mv5fDwAAEYQSURBVOuyWEQCzNmwR50zPPp74QaSMYQgcDffz7GFndXNp/ZVz87eqP777ZVqfGHniNlFu/ZWq6PHa3UpWn7HNq40xwgn3yghw2Yy3muwpdzorp7TWrXO9EZYLDAC55E5mcx7hAW4ZB7165bc+2z3ORD6dg05PDaX27vmnRWHzeygjm287xI+yMgDgyi/79DReosbyShDDpiXYx7uf8mmDP++0oisdWZL168JubZlRXvU+pIqNbp3fafU+tL9+v5C+XJex9aBKuGRRg1wCTv1GumGgEb5IwQ9J1/7fsYzg1JsP+bWbUY8CWIfkv3+2a0z1ZmDu+kmPh+tKlFjCpJz1sUC76eMi26/TiLaFpdHvofM7sKtMz19z0b07Kj+vXyXWrmjMur3lTJdN8atROcD6+uJeRbzKNYE8ZAcU4hGfq03h/XooEVbZANGugZpToP8Vi+uUTKKd1fWpPz9pElMrotz2+jeOer/5hXrjt3Jfg/JkkROqJf3AXIFIdqiEWek72v3OZAxC3OS29ePOBRQksL9UXGoRucmg5y27j57Yws6qb9/uVkttnl/SKMvPAduXdfgvGztcis/eETtPnDEfE0TeqayvV0vtkpLUwNz26sV2/erNbsqVWGEhnfS1LZHTvJzfCTiPQf9usVe22DNrX+GlmmqXVaGb+tIc9+yJ/K+RWKZuujGjWmByYnH/i7S9awvrTL7cXTxOGMZdM1updaVHtCmj/Drs/bS8XRMz++g77P91UfVlr2HzHV3OAcO1zUhs3t9ya6LojEkv4MWbdeUVKqzohjdmiNpNl9f/5/QOJEI//znP9VLL72k2rdvr3bt2qV/HToUWiwgAuGXv/ylWrhwodq8ebN699131bXXXqtOO+00NXLkSL8vv9Hz9uLtWrwY0aODboKTCGcNDp3izFjtfbkFBlQwMEoejpPcffZAnV+DRddvpq+J+DWbjU7dyOrxQrAFyF+124isrqGX+6+XICfmyTYoQlZszbHjhhDe2lPBDPmFdtjmYxMygJN9ZAcDyXgW57c0mnGr8UX8RmQNI0uqj3jTiMwaiL9se8Pg/hVGgx50Lg6SYAukGWSsJg2JAgcTNrOIiUDGsd+NmtwQbXEglQrnGgeP01fsSqn5UDSKXWgEF+/ADHmL4SCDDU4WkG2j1N9Jhud3qPf8xWoylYjg4DZyjyc6L/j5M8j4F63Bj8wPnT1oRAZk3Nlt5CumQqkHTTYh2gLkdSfbHEuEOqfHXPsdvO2VY/rZODG8GZkc2iQDIkwAKv8y0t3d+o4p6GhmN9ppYLnbg/VYVka6KeYk2ghIRFuv14vxxirMV7vMRmRZvoz7yEmO1JxY/h/MEn6uI7E/BejFEWntIgd0ndp6/95GOwSNtj4B6NEBBhumFK+RZnwyfgvQSqTPipMN0O2A8Qw6DVhcvC9+k9nW3lZ9RsqpTnX+aa4EWrR9+umndZ7GGWecoZ2z8uvVV1/Vn8/MzFSffPKJmjp1qho8eLC699571aWXXqree+89vy+90YPB/bUFW/XvLxsXO5IiEpMN0faztaWehXEL6w2ByouBEwuhh78Zaoz30cpdEX9WmXxks+wF0klVTqFjgZNiKVvwCjjfxHUkE0kiSJfxAd3a6c7TXi4msDm3I9xIEzK/RFsJ6g8XbbFIw22K162zxws1uS+x+cIix0r10dApcFZYcxRXu9VvbSgQrTQ2B8ONRVCQkOcGB0FOjavbDUc4DlKc3lz0MTYMWOCi2ZaX4HACjm7QMyc1YeGMQV21kwFiORw/TlNsiPDy/roJGqgAaSJkparmqB4bgNdxLsONZmR4jSsMgcUK7ncRbYIo2m6yeZCyyWz66d18Gw4OpGQDHD4OgzJjQ+pmCbmVroYoJ4JrKpRUVtdz77r1DKHLOQTbZDthi1AnHcm9F233p3QAJYcUXhw0iWhrZz0bjX1GUyjpTu/2OgdNQ/FoyVo1GngP5L7v2i7Lk/cejb3sggoo6Trf1Qdn49AY11xWdVibN7BscfN5jwQaOOI9FkE0nHJpQhanSbXb9O7UVjusq2qOmeJ7JMd/54Dki8q8uKOi2qy+s7LGEPsGR2iq5gUyXoe/ljjEOnz0uF4nerGOC0diu5YYzeNjVfmgEaNfWOcf0sREW0xmkX5df/31+vPIoZ01a5bas2ePbiC2fv169eijjzb5XFovkHIUOBm/OapHwn9/XGEn1b5VS11CsGx7dOeM0+D+WGeUKAzo5s2gPrFvJ9U6I10PiOsjNGNAGRro42H39DqnbXXchblsImXz6QVwO6BTrlWwSIT5m0I5TBP6OF+qHA2IWrL4kQ1XLLaL0zZFl18qyMHFCsszaHYCbtfKM8FbQEdvfEvEhYibSzhk5M219sBpKwscLBzCF4Yi2g4zhI0gAacM4jbg7vhgRSg/K1W2GaKtuHidBMKfCD+by5xzB9sBYx8Eqcz0tJTdbHCtnzYwlL/14YpQZqaTbCn37mAvltMW5XUArxkOJL2kY5tMszJgZYQ1AzboGDcwfnjtTrSzyZSKlVhgLpbKGzkE9OuasWZBdUP4dWMcxhwHZI72Yl4AkUSFRMBYjrERdHdRYMLhlswhi4ujb5JtOW09Fm0RDYRnCIe34W6xpKoDPLiPu0s8QiqirXEQ5IVoC8YUhNzYi7bEvj8w5kLs8cLJKm68eNdkRQRliFF+iD0o/Y7mtN1pVGzhWXfbPR0remCjsYeyUh4QMTTTIiJGvE7DaYs4sCCQ0yZDr3HB1giVmOK0HeKT09asCgkbO8UY099DI5GVE3qLaBv9kGiNIZR6WVUb7RAGBx2RRHnSiEVb4h/isp02LFd1SGKRg4lCNrkzVpcor8BACpcOxsy+hsvLbbBYGGss0L4yxEQrXxaJwBg/784pcOqM02c4QSKV7liR0mUvRVsgC4lETv2FrzaFOp5O9PA1xT0tAqwdAWqHz/EIVlH7i/Vlpnhf4kH5aDRapqeZjgh5fYRqY+OS5UEjPLwnECQgAolIK+5MWdgMMzYLQQJC2k2nhLLdH/9kfUSXXKJs3yeirTvPvzj4N9oQtdyIRsAz60QszTnDQk0tP3JYtD1y7LgZF+KGcB5NZMTrg+9tRdzQXkcjhIsKyyOItiUVdSIXxpGggE0aKCo9EPd5xPrkYM0xvT6J1FTHK7CplDJF6/gH5DAN851XTWRFuExFRLT+fS0wuXwPj+4VWvMht7QxibaYQ2Stl8zaC2AtIRE9XjptpXIiGSoMMb9ja2/EKdkTLIwjkO42nOEQqtw+KJvUL7RenrdxT4OxPxqlxvVBUPajzF8clXBe7g3by0j8W54Ru+U1ssfcEGFtszcgTttYazA8x3uqvI3CiQfusbqD0KoG1+u301YOVuS5EDD/+xGNEB7Zg9cnmhi6bFtoXTWql397GxzQIjIESyVrBSixR3BWviQw4IF/Z8n2pKMRhNMHhUTbz9eHOhZ6gbhsIUB46RQScWy+ISYK2/Ye1BMPNklw5HoFNlzicItVUmZt6OW1aHvqgND98buP1pqla3aACC3v8/hC5zrdO51ra8Yj+Oi0PbFvZ72BxYJXFhXitEWTGT+wusCt7DIW4Dlt3XfCWJ1SSy2bbjQxhOsFYoUXm9FkuPGUPtrxgvfz/WU7HHPauiUi+ZVrK073VPNshSlDuquWaS105USkcshkweEFxmE8p+I4dBN8j6yMNP09ZYwS9hvNU7yORhDkoARZoeGIYCMCTlDAnIA8aLhW490X8gwgrgNztJ9IREK4cCcZh3AUeSXSyH0PITOVkn2Z20KH1u5e+2gbzqYgxiM4kWuL9+nQkdDhQ6rRM4msGTAGJHt/yBozGRNKMozpXSfqx4oyEierF2M/XG5wMsJJb1332Mqz9SEaQeYiWZuEl1TLYWe+EbvlNaYYGsPBam0A7BfRHMGVh4/qRrRBctrG6t2ANR2uOSO9herrk1s0ntN2gAe9dCKBqA7MJTCiWCsrBZjZJApxZM/Q3OUHmJfrcm0ZkZAoFG1JA/6zqkSX7MCNdlK/Lkm/QqcOCP3dZdv2mafcbrO+1Bg4DfeLH6KtdVH5ZVFIsIZA5PVGOJo4Fi4YeN3QS7j9jH76pBqLwoffW2X77329udx8j70+Ha7LL7Qh2gbAaYuDi4l9Q+6KWet264+l5sbWn5P1POP1sDpt0UwCDmBsAmVD6TajejbcdK+UJmTotOxDiZMdMI7cfGpf/fsnZqTutt1mOm1dEm27+iPa4sDMSdEWm31xKk1f6ZzbVjYmbmQKRwL3dUEn4/ApbBzbb5QQS3miX07bSJsOOdTxOrvQzuspJX+xmqiBIEQjCEPzIpcdS56tl2W9IlxiLRIpz9guXlaRSC46nt89NuKSwpFNvxdindO5gluMsmWsGb04fBB3GyrHJJcx6XgEj5rw4FAEh2OI6xCxJGYTMg9EUYxVsqf7wtibxEPWi37cp4KIPOEHTKbT1qeMcxFDI61tgiTaRjs4lwiHtpnpnsch2TLHhK1PxGWLmDC/Dj3rnLbhoq23sYyxI3siNFg21lSIoPL7npRoCzYjSxyKtqQBrxvRCJeO7ZlSNgvC+NG5EprC3I0NYwPcQAZOr0sUMFgiBxALcWuDly+MaIST+ycvfqfsTjAWNpGQxSQaa3idw4NFwu++PUoLdW8t3q4+XlWSWDSCh87lRJ22KD0T14+fTltwuhFTMnPt7vobW5+cE/kRDhOkWQeeWzR48AKzGZmlUYiUCosLLahcf3KhzuaDM/i9pcm7beEA2mncDyLkNRWnrRmP4OChybnD8/TH6Q5GJIgA4kU0QjwnS+Vhf7sLi2iLeyW8QeWuADYhEyT/euX22CKYzLd9PHyv4zptd9RvSCXxCF41IQOtWqabWaOp5Np6WUXSoXWG2Zk9Ubdt1eGjOibD69dZSNXpZEYjeHQf4/6QcXxtko0gJevYq0xbxKaN7BFaYyyKkXtsOm09OkSXvcgcY29i32nbKnAHTKggsxoB/IpHQD48orUiibY5ARBt5TrDK0EkGqFTQJqQxVufmHm2Hhk7IiHNAtGcT8xoME5sMF7bgT45bes3I2s4H8k+x0+XrTCYzciShqItaeBOkhPYb49NPhpBOMVYIHxRFBKM3Ga9TyUKECBlwJRcWwgi4rQV17GXQDS3LmwiscmYaLyORrCWkIlr8IG3ltuKSahrQuZdnm2iAhScozis0DEVbf3NikLnexG7D9Yc9aS7tp37UlwS4sa3ul+9QL4XFoaSlSZO2yA2IbPSPsxtG75hsAuEsJpjtbrsP9+lXDgpIUTDw1RKn5N32jonLJw9tLvOCkc2mDjpU6XYcJOgy7NXiNOzodPW33gEbHBFnAnfoO8yYjyCKdp2iJgPG44c9gXBaTuoe11DKqtQKvEIXjUhCy87FRErGcy5zaMDSckRTFS0FZctHG5ocug1InrgECGZZjBbfBizRvbsUG+tkCiytvQq09ZuMzLJxvSquaLsySAk4/DAtmjrY4VDtCiXncYcLEYAr0EsA2KNEDEgh8ThmbZBiB2AMxVs3XtIu9WFPdIszec9it31yWrjwGZwrj9uVoCsdMmxf+LT9eZ4iNcVzvpeHsTFxIvsQTVq+Fp72VYjz9YYR/3Eemjo5Z6gKUDRltTjXwu3KzxDJ/XrbDaKSoVTjNxSacblJnj4JVfGjzBwMyJhY8gJunrXfn3aioW5CLq+xCPEEBfqmpD5dzp499kDtWMFG5mfv7sy5tfCfSWb+QmFnXxbTEDoizXZWF1+fpfZQzRDiThKT9GAosRjZ0c4Ig5KHhlYKgsKD58TlLuLoLhk2z79foroMtxw/AWZ604q1Pl02Hi/m6TbVjqAww3uVnOn3p1R9h/KTyszNgleIM+gU/EIUsY93hh3nHLbyhjspdNWKgbCnSx+xyOA4T2yI0YklAQ00xYMM64Zhz6x5gVpYBkE0bZ1Zrq5mbcK5CIoeh09JI0QZ60rTfrfEMHXq+ifWOWoQc2zlWcIjlM4xCTrPshOW6tDTJrpJBuP4FWmLRjTO77TVkwVXq3HMB+jRBrZl1K1Zke09etetYq2uFcPH607ZNjps9MWa/s+UZp8yeFXEBqRwSWNfSied1nzWa8xCMKyFRlXEKFmfb+lSbA4Nf2KIfjZ+UP175+fs1lrDuuNMRRirp/7PZigkK+PZ3ZFWNXPsgA5bfE6wSiCGM5YpjLSEIq2xAQn7q9+Xax/f9m4Xo68MihhR9k9NqbifHILDFQYBDBm+uEcDW9G9oXRgA3NoFAq5TW5NjJti0ynrX+ng3Ap//6yE/T79vaSHTGdFOjECwcrJnU/HFcQgHA/owmHiJ+REBeeW+7FRBcZEpEwa+1uS6ZtMJy2cKTXLSi8FUutzci2lh/SJU9wR8tJepBBs7SbTwu5bZ+dtTG10nwXm66htFWEU68iEuA8lnHP6UY55wzL1R8/ckC0xZw7Z0PoQNPLgz3E4URyskBY9zMewRqRsDxMtJXxIoiiLXLs0BwF649wx5WAcU5ebzks8ht5ra0NVOuctt6KNFef2Ft/fGl+cUKNSaM1IvPS2bQ0TrOpcHb7LITpZjC5kd2LicwbMo54gTjErHFGycQjeCmiidMWsW2RsppxwLPYcOFKBIAX1FVAljWKTFs4aeH8h9D8+boyc46X590vp2396IH6c6lUb/mdHyrPe58IEQlByt21Atc5xEcMqViXy1pJ1o9DfHTaAuynpg3rrkXwh95ZaVb4DvQpz9a6l5aq3hlrSurNNxBHYZ4IgiEFewLZY62OU51E6kPRlpj8c94W/WBjU3TO8NDGNFVQZimbUYkKcIv1Rp4tXER+hKpjgQZBD4KdNWbCjzxbII3Foom2WPSIQ8Tv0zfcI+jOHm8haebZGgK510B872VDgNoRgCZkVkS0/WR1qbkp9020NYRsHLIg+xdCBsQOlJkN8ngxJs5elLdKNALKhv04ZEmGqycU6MOOtSWVSZXrF1uaYLmJOPk3hblR3AKxD1hQQ0hzerMpc+PXW8qTakBkBTnTyLbEOOHlgUWBIRpuLT9Yr5GdOG2zfXXaNhRtIYjJIVkQ4xFw0CPVPTKORLonDx89rh0mgZkXjOicz9aUNmhE5nU8whkDu+qyV3S2/7+5W1LMtPVGYMJc0TojXR92SKZhYxBtU21G5kc8wnBjfMShSDLjroimXmXaysGHCNuLI7ht8bNgz4UxYUyBd2tw2ZPY2ZPVNczL8lV0vHh0D/37VwxjEdaPmLowx/uRCy30NdY26C8gYE4VZ3dQBFG5TmtTPBkvva6qsPN+SzPxR6ev0XtV7O/xfuP19HPcFH76jaF6z4J+Pf8w5qv+PubZCpONffSM1XVzuphi+ndtp80eQWCIzeatpD6NY2dKXAdl5099VqR/f9eUAY6KnrJAkKZcbrHOpzxbAYOhbDjhshWB8RQf8mytjiTkq0Yq2UQpOAQDbNCx+fAbOJJBrJKt+Rv9y7ONl7dkZbsZj+B/wxlwUv8uemMgwh4Wuiit9wNk/OL745bEolHKHZEj67VYajYj27rPXDwEPc/WCko95VBs9rrEc8Pl4AElk24izsJYXbSdxM14EhyGDc3L1vfvrCRecysfLN+pP543IldvVLwiLztLC43I4pMDJiDNv5CZ7Bcyh+LePGA4f19dsFX/HnOsHEYGthlZFOeI+ax1auNaFEkyh3k4aMahDwR8vxqRAdz/t53RT//+uTmb1SGjUVdy8QjeCEx4H0cYYmIiEQmmaOujWJJsMzKIn+JadXveCDeAiKtxWZgLP7FM2wzPS5bBogj3B+KqAO4hrxqwgknGWnvNrkrzXowEDtXlkN+vOC3higkhJ/6na0r1nCWVF3jW/SxJj9TkC/eabLm8PCSw1Y/DEJdxjW8v3h7YNe/95w3Ra5T/rCrR/U5knMLBnpdrpWggPvL2M/rXixDx22kLzhzUTTtqcegtovxSY4/ltznLihivPlpprwE5CRGMlSPxnb/M3qj2Hjyis0W/5UADMiti18epbiIlZImyvtS/PNvwgejZ2Ru1qwYuLzkx9Bo4kjB411gWXpEbenXyPXdVrgMs2Lw3YmMlbOJE4PPLaWvNg5SmMpEQcRRZoUEAYse4wtDmQVwTfi18cK9ZozukiYuXebbWjWtmepoe+z40yt2HBaB8KBFOH9gtKdEW5Wbiane7ND98w+AmcIH9v4/XuRKNIEweEnrNZ1gciomC13/G6tCC9dwRecrrZ1Dc1dbDJ8SDSLMNv4BYiDx2bHqRtQpR4ZEPVpv5535U0SQiNodn8YaLtkHIsxU6tslUY40S7s/WlvoajwC+MSJP522ibFeiuuyCpkoS7+FlFYlEJCxOoBlZsJy2lQk1g5HqDNwfXru2pHmoNNWxC/YdFT5k2oKxxrrri/UN52eJJZnosQkBzkocPII5G6K7beUABwf+nXzOZkX+9ol9O2m35WsLtpo9EdAMzE/6GrngyNuV50iakMEQE5SqLVNcNqqdYNJChRtE0PM8Xn/YNfE8eeVoXUn22oJt6tGP1ur/P9iIdQkC3z29r56vBD+1BwFzioyT4rY1Gz33Cs7eBhVrMO9AjC8ytBsSn2CMJsRX0L30r59v0r//4bRBjrtAIAggBB0LcTTncgvkRoEBPg6c0hxLNmjIjvJLHMNiQZwccNtGjxrwz7UavolAAxw4qrCRCAflZci0wobeyeZCSQtQdkTbALnCRNwLgmtCcm3hmJCMOlloeJ2tNMRwGUgmWRBdB7E4bWBdPl2kw45ooCT6wOFjKrd9phrjlWjrotMWP/szszaoaY/P1pthlK7ddGofV77XWYMNoXzt7nrdmBMBIjtKwZHHN9qHA4u6XNuDprAhDmW42vzEGpHwv/9epTeXeC6vm1Sggko8p60c8smhX1CYbNzL2ODhGTK7nnscjwCw9rzltJDb9i+fb9JOPwGCSCxxUVxFWGt6KSaO7pUTtWN3UBuRSUUaxDiImbH6HoSzpdz7xomCRMjE6nsQCYj54hfp4LHTdvLg7qbTVvJhw40T6P3hNVIBGCsiQZzrEOiDYOy40nDbvvr1VnOukrgtv4DomZWRpg+7ULEA9hgNV4MUOyBNJ7HORVXFC3NCJf0/OXewrrYIItOG5apfXzqy3gHCYKNCIAjgAPmh84eZAr2f+1IrU8RUsLpEz0nLAui0xYHxaUaj+neXJNdIuTlC0ZaoJ2cU6cZKEFcxSLohHkrpuzTnchoMTBKPMNDHXBl0FrdqtH5FIwgQOIG1BFY26CLaisPVb7BwkM7sspiN7ErAa+zfIkOcUugYGsk5jv8nom1QJnFrri3o7mM+mbVxBBaPInL44bQFVsEMa1dp0NJYwEIMJXhwSYpr2Q7vLg0tlCYPzHF9QyYuD3Qdt2aoOkVl9RF1ydNz1K8/XKOqjxxXJ/XrrD666zRdKuYGOGBAx2WIAQs2x+/AHSsaAS5bP8azAkM83GKIiW8t3q5FdQheo42SXr8bZL04f4tuTomX51cXjwhMrEAk4ADCdaJUMlLJsTiapSFMUBDX+NwNe7QQAt0Rw4FfXc+/PbanztPFHPre0h3aOf+rD1arMb/8WJ31+1lRYxMk89jrrHasR1DGC6edXbdtEJy2OLAUISfaQUMkMIa73bwyGiI64KA3EXdwhRHngOZG+Lm9BFVFUsmCUm8Ba3I0WcKzNs5wu3uJGVu3vizqayll334f8gvYnyLWC4cMry/YWs8A4KdwJ/tbNPoFcvDlVwRZrH0LxOWH3l2pKzBP7t+53r4giKAp+gPnDTb/HLT1OeZPOIL/fO24QBxsWHNtYeRA1joMc3C1SiROUPjmCfnmXiSR8bw5E9wVMPEEuD9e/ipUhvbjcwa7tnmsy7V1R7TFgh2iBYQ/cXX5AUqvrOUbfjUhE2RBgyYoVnAiDPcSXClBchaKgBwp17ZOZPbXGYyyMkyAEDjue31pA3djWdVh7b7D/B2kpjmYsGWT2N1vp63hQEYjJrxWOKX2shO1FWvJEErdWmcGs/w6GhjzpBu03YgEiJxS2j91kPuHNihhhLCBjYLkPTsJnDdwE8BF9dtvjVQvfmeiq2XoWJyfOTj5iITDR4/ppoCSZ+sHVqftwZqj6tGP1ug/33Fmf9+bp4hoK+736yYV+naoY5e2rVqaa49IzcjEZd4nYE5bCHeIysCz+Y7heMH775f7CiLIjaeEHPI/e3uFOv23M9WfjfguvIbRnIGoGPNDYMppm6kuGBnafL4wZ3OCmbb+rg9ETPz5uyvN5mLxkK+TQx8vwVoV7uCyAzW6gZdd9vqUZxvevPKjlaEIJut6FlUFfmSIjy/M0dFQeB2l2iLqMxWAxk8yNlw6pme9fPx8n522QIRPybgvr5ImZMF43QAOY2Xdj1xg8JNzhgQiHzYeqL74n4uGqzvO7KeG9wjOfhXg9btgVL4p3AcBuL9R5YmIxj/N3GBWsnp9YBUPNB+HSx3jj7XxLIkORdtmzuOfrNMl52cM6qom9XNv0JFcWyxUkOXnNOKyRcmW3wOT5K3C8eu16yMcEQ2lyUh4Q6+xhZ0C5V4yRdvN5fVcrHDXLDK67/rtDIbw+f8uP0Fvat9cvF3d9eqSemWcIkrhvQ9KnpUsLqYODZ3A9vc5e0mctguN9xSCjF+LR2ssw/AAHWAkwmlhm4Z4/GdliRbL0SBsYFf3nSoQOUWskkw1J/nXolBDjfumDlTfHtfLk3tJysplA5QIn68r0zEwaBYp5dW+OW33VKlnZm3UB5/IZ7vh5ELlN8MsGzNsNO+dOlA1Bobnd4joXMTBXrExBxd2CUZzSgHPisR9vL4w5F7zsxs7+K8TC1T7Vi11fAgeZYgisoaMdkgi8Qh+rLmuP6nQdM+L0BUNrGuk1NfvLuj3TB2oqyDgar782Xn1minFddr6cMgK0U5yI5clUFWyz8izRUmuH0gFI9zs4vo1oxF8Ws+i8dmYAsm+LIkZj9DV58qsSA3JBL+dtuAMo6IHESnI1i6vCr1undoGx2kL+napq0K98IR8s4liYwBzwg+nuWcsa0rgNZIKGmk2J9EyQTvohnALUFVD4hMcRYF4ji4/WxYq0bxv6iBXv1f/bhAwW+mTH+mY6iRfGmH6IwPQRAiN3LDpuf4kd/IUk3ERvrd0Z73sRYiifjf0iuawap2RrrsTI35AeHPxNn3vQFRAszy/OX9kvvrT1WO04/b9ZTvVHS8u0mXSaOj3m+khx1oQu5z/9zeGqKeuGqMuH9fL1+uQhbZUxPi5oIA7Dk5fMMwQXRobkg2FrtoohYrHe8tCC6QLRnlXmi8uxOVGvpZToFkVmhnANQTHg1ecOrCr6bi3I3ZY+WDFTtOB5VdJnWSrQoT58+yQG+OBc4cEotEXGiWKKPTQBcN8caKllmtb/x5H05wjx2q129zvxjmRkA2e5ET6LdoiUxnlpuixMOu+M9ULN05Q3zm1r/7cp2tCOX1BiUcAED/G9O6o3+OX54eE71gCIowSfuUGW8Fr9cotJ+pmuajGuuIv89WmPYdsiba9fa6MkY7odtgnTlufytUx9w3q3l6/7zPWhATS+Rv9rxzDOhb87YtNuvojajxCQJy2spe0GjckAs5PULWCagU8/xDmxWkLF36QkGgerJXc3vOTYEQkiPcpSHm2VmTNjn20m43qmwoUbZsxKOVCviBybaTxh1tAGDjDaIT0vZcWm3l+TvGpUWp6ljFQ+QleywU/naKumlj/RNgP0BUUGzAsyOU1x4YnaHm2Apyp0s36K8OJgIEci0pww0l9AnPSCvfEs9eM1RtxZJV965m56n8/WK3mGYtx+TmCBNwV3xiZp6/ZT8KbR/jRhEzA/aRfk/Q0XXHQGIGjHiVR0DLiRdBA1JVscS9FTumy/tgn69TvPlqbUNO0WPxr0TZTePLSSYVyQymJS8Rti83xx0a2Ie47v0BZKUqNURaPHGDMBVLGGwT+cu049dwN4wPZ2Toaw6I4bTcZJeXY3Acl984K3ntEJQl+i4kAlV+I6hBxEAfMyCSFOBspg1Wctn4JTNcZblvkMMdqTijRCIigCEIlDg5IINyifBaxA7e9sa5BDwQBVXISteVXQz0RHxJpRgYTgJ+iLZg2rLsZkYCGZCjvx1JWmhf7wbfH9dTVHsiIfW1BaB61stunyJF4XG3ZWwXBHIE1pDUiQZy2yL0PEqcZ1Qq3ntFP9fIhk5p4x4l968/pfu6xYoE9FxqQYwyCU53Exv8VA/EFZBq+PD+UZfudU0IOBre5b9ogLWShecvtLy5SD76zwpGohOI9B7UrE+XqQQ9V9xpERUjH7b9+sVELtht2V+nFObqrB7FkQoTkeYaw/NnaUp1tiIH9svH+OkTDOWtwd/W368bpUk4s0M4e2l1nQ7/23UnqJ+fUheeT+oS7zfzOq/zFhcPVgp9NUQN8jo1wJCLBaIYRDRzewPGDbDDEI3jF9ScX6s0WhOU/flakrvrLfLUrgVzCSCCWRMq/JOvOS6SsfIZxaGiHOUV7dP46xKWxPjb8QiyObNwgHjx4/tDAHIgBlEG71UjObact3Ij7q0NCkfQO8FPosrNOONVw6wfBaRsJOMAluzvS8yal3H7lyJ87PE/HHcCdON2SXRo9zzY4rzG63L9880R98Lfv0FH1j3mhzvLhSMwW1jt+NVkS8QEVG3adWWJS8LPfxTTjQAyi3kwjxgj9L9AHw8/n/tbTQ/u/pz8rauC2Ffc6hP0gAcMEqvJgOApKsy/Ze85cV6qbfQG/mjnGet0W/nSKunvKAL8vhXg4p+OwEw71oF7nOUZ8jDRHJtGhaNtMeX3hNi2eotTcK6ETC1qc6N96ej/953/M3aK+9cwcW+W8sUC5nATroxENqc/VJxbosO8V2/er+ZvKzQUsnG9+5//Ga0YGkfmvn4dctldN6K3dbUEDE+OSh6ZqdzXcYbed0U//DEF0VAUFOF5wTwI4PfzOfobjCSW5jRmJSPh8/e6YnVhlYfRND122AGPN/148Qj1x5Wj9HCOi5bwnPldFpaE88mSAQI0NErrNn+6DS1pEWzgEKozcxHi8syQkMp/rYzSCIFEz3xrT0/Vqm+YAymHRAERiOxo0IfNRNIrHWUZEQlCctrFiHGTNZ6XEcAX6NZegegVrlHgNyXYfqA5Enm04qFL4weT++vf/Wrg9oltYGlbB/ezXAQ96RWDtgP2LONhjgX4IUgkh2bJ+NbBFvBeqGp6YsT4w8WTIiMUBIhqSvbGwzm376tfFZnMg5B4H7QDn3TtPVi9+58TAHDSiMgBxSVvLD6kVxuvmd0PPcPBa4YAmKK8ZcZdpw0Pu/jG9c3xrLGqHb56QbxpKrP1hSEMo2jZD4LJ6fk7oJP2mU/p6unGEOPKTcwer564fr09IIST+v4/XpfRvSmOKyYP9j0YIIlg4iAsNAqjEDviZpRWvozFK1eFI+ffynWruxj16wpHywyCC6+NCyD54rcRtG0S3d2NkXGGOzoOG02vNrshC6M6KQ2YJkuTZeQ3E4ve+d4p2deHA7ncfrUs5GuHCE3r4UmqMZl5wMGBOhVhuJ1vxgxUhF94lPjiDw7l36iB9yPTT84f6fSlNhqFmrm1D0bYwwKKt1dUcRKet9RqRZ2pt+IVDKrMRmY+uQFQSIHJk4Za9pnBjBdcpmbBBE23lEKpTm5b6ICySMI6mhX41IbNWCEgMiZ2IhFnrStWhI8f0YQrcmX6ueaYNza2XHY0S5iAIoGKk+dNnG7RYj/f+gbdW6P93x5n9VL+uwXPpBW29jaZK442oi71GHEfQRFvSvLjohB7qsctGqUcuGaGCzKS+nbXxAs/NzDiVgs0dirbNkNkb9ulFA0TTS8b08OUazhzcTf3p6rH69y9/VWyWDyYKOnBLoL/VKULqc+MpoaZoaIIgroMgnPJHW0RCuAU/fTu0cPzGiLxAZFcR55D30+9ohKYCnhvZBM42yi/DQXUDTLjI0fPzeYLj8MkrR+vfo5R4fUniblsIoFIm7Uc0gjDZcNt+tDJyB24r/1oUcrChjD4IhxXIsUScCytUnI9IwOGoON43m5m2wRVtISLK+IFoiiDSLTvLfG5mrqkb4/ZXH9UOxtDXtPL1+iSD+TsvLFB3vLRIPfVZkXp/2Q718Hsr1Rm/m6ke/2R9IHNCAQ6+zh8aiqB4+auGDdWKjXgEHFb5idwDS7fGb0b2oXFIhsoGv4W+8MxwEfn8Bv038PyjOfX//HuVuuPFxbrfCeZVNqyyT3jVKkVb4icY72AOCHp+MQ7ixMTgZL+LpghF22bIy4tCm8trdNl8uq/lJJjk4FL6fZJuWzTUQSMVNPjwMp+xsYGTcogL2ENigwM3iDQGCiISkSANJL5zakh0Jk2HG04uVKcO6OLbwVFT3jT8efZGtbh4b73PoZnf0zM36N9fOdH/bGjkB0tzFrmuRHhv6Q499kN4FHejH0w1Sm5xPX/9fGPUr4OAhwNKcOWE3r4LCMQdTurXxRTxf/7uSp3bL866oJUZh/PHq8ao12+dZB6aBhEzR9riBJWsVRw++LmmBbec1ldXCqFh17+X7VS//WituvOlxeq5Lzdrl600vLx6QqjXQNC4YHioAmv2+t1axIsUj1DgswggubbxnLbIaJWDvXMD0NAQZcriYh/QrZ0uVQ8CeGa+e1pf82AXzmRk5P/60hGcpxIgPKKJoi0h9rj9jH7aSLi2pFK9aPRbIg2haNvMWFS8Vy3fWaUy01uo/zIaVPnJj84ZZG54I5WTxWPG6hKzIRQ3wbG5ySJ8wqnQJjN4+bDCREvZGFyB0jGYNB0mD+mu/u+miSovrCkZSZ5Lx/bU2Xkob73iz/PUh8t36v//3Jeb1C/fX6V///2z+uuyqSCA7vDgnaU7TOHFLm8skgZk/v4saK6JElLwP/9erZ11kViwZa8qKj2gIywuNDK8SNMDB46hpm5KvTB3i7r2719p1xqagSA7MshAUAqK+y8aU4aEDno+X1+mRbkd+w6pO19apP8fIlf8BtnQ8x+YrP5x4wQdBYY4GJTlXzaup3rmv8aqxQ+erZ6/YYLOhQ0ivTpmqUl9O+kD/te+ru+2LTYc435fu1TnLNm6Tx+URctwh6kD1XjIzR8dgIMIRNGdY+RMnmw01QsKV08s0CXKAPfr01eP8SVyqDEzqHt71d1w0CPfNog9OAgJIshUv2dqSA967ON1am+KvY6aKhyRmxl/+2KzmQEYhI6gyKaSDexvpq9J6O+ic+xna408W0Yj2MqNgaAT5DxbqyMBbuBwsZkQEp32WRnqtVsnqTMHdVWHjx5Xt724SN32z4Xq4fdCgi3ExbvPHhiYAy4cxsBtDVHrmVn23bYY95du3aezpDGX+Q1KSO+eMlD/Hs465LSHCwkvG+4BiDh4n0jTjiN64orR2lUpjT9RUh6U566xx09AGDlYc0w3zLr8z3O1A7RnTmv1u2+PUkFpSAenIrJC0XgRGd6PfmuULo9H9mXQuXx8qBLj9QVb9dgMXluwVW0xDtb8bqiH749qBVwaDsq+9/JiVXX4aIOv+2B5KBrhnAA0fRR+OG2wjqS5a8oAFSRaZ6ar3192grpyQi/19+vHN4r7NGhgfJdqp5w2mRzvCUkANPLEwSua+v7+47V87SJA0baZgRP0nh1aqRtPDk5Tp3vPHqRPJeGcmFNUZvvvLdteocoO1OjTzKC7Q4KyoHj0WyN1TtWNpwTn/Y8EFoz/c9Fw7Qo823DWEELig/HwL9eOU9calRSS6YeGUxAXgyYcidv29QXbVKnRTCgWuyqq1b2vLTUjfoLQ0Aev6Q+mDDArR/4wY7365furTcED+bvvG67nKyeGOsyTps0Fo/LV8zeOV+0N8YPxTc49axKR8MBby3W3djTGevW7kwKf3ddYmDa0u+rYJkPtqKjWjbyQM/ijN5Zp9+23x/YMRHXMry4erh7+5jB9uP/+sp3qoqe+VBt3HzA/j+zwj1fV5dkGBUR4YC6GsyxoQHB85JKRgZhTGysyNuWxBwchCQETxkMXDNO/f2l+sVplaeZKQlC0bWb814kF6rXrh6lBASgjE1BqhRMW8Ovpa6KWOoXzqRGNcNrALiqzJW9lu6V7v79sVCBc1vG4YkJvXS4RFIcEIY0FBPtjQ4sybWwScfjxo2nBE2ylIeK4ghydT/vXLzbF/Fo0KPj+K4tVeVWNrhpA+XGQuP2M/upn5w/Vv//7l5vUjc9/rV0DbxoNyHDNowLQgIx4l28L5/tFJ+TrrFPiDIjDEpAT/Np3J6keFEkco1VGurpkdKgxzPdfXqL+aES+3Hlmf/WbS0eqIIC57LqTCtUrt5yoY0fWlx5QFz71pZplNOGcu3GP7t+Akv9xNHUQj5g2LFevvX55YUh8IoQk1uvovBG5uoriF++vtK0HNReajNL11FNPqcLCQpWVlaUmTpyovvrqK78vKbCkBXDjfudZA3Tm27JtFTrPxA4z1pQ2WMATQggJbWpRpr3kwbP14UcQBVuA6xK37T/nbdFO2mg88WmRLjdvm5munrp6jO9NhyJx0yl91B+vGq2yMtK0gHDxn75UL8zdbLpsg/o+EHdAo7zHrxht5nCS1DmlfxfVv1s7nc3/6i2TVPfs4B9CNzaumBCKSEAmLNysqNK6b1rwDtEhyL7//VP0wV9l9VF1w3Nf6ZxbyXOHiAYHFyFeHiawDwchyfHAeUNUq5Zpat7GcrNSkDQh0fbVV19V99xzj3rooYfUokWL1KhRo9S0adNUaWlI1CPBB+U4Pzds8U9+WqQ377H4dE2JWrljv272gU68hBBCGtIYREKM4cN7ZOucSmRURmpKhuicJz9dr3//q0tG+J6rGIvzR+arN249SeV1yFIbd1fprvFsQEaIc/mbH999mnrnjpNZyu0SA7u3V+cMy1Wd22bqpmqXjQuJuEEElWMv3jxRN3uTnFtk8IJzh+f5fXmEEEJs0jOnjfru6f30QTey6kkTE20fe+wxdfPNN6sbbrhBDR06VD3zzDOqTZs26u9//7vfl0YS4LLxvcxw/gffWaH+s7LhCcuRY8fVIx+uVjc+v0D/GXmn6HhMCCGk8QrLf7pqrOrdqY0WOL/1zBy1vqTSdHo9OWO9uuX/FupMxSvG9wpE8zE7UTTv3nmKGluQo/980egeKpsNyAhxbMxoDAdSjZlnrhmrvvrvKeqk/l1U0GnVMl1HNyASCMZaiLc5bTLUxL7sd0EIIY0JRPG8ddtJdKyH0ejbQ9bU1KiFCxeq+++/3/x/aWlpasqUKWru3Lm+XhtJnB9MHqBK9lerl7/aqjvCoqHOgO7t9Of2HzqqG08s3LJX/xmNdmCjJ4QQ0rhBtvnrt05S1/xtvlpXckBd9uxcdc2kQvXivC1qT1WN/hoIoNKooLFUkLx080Rd5jW+MCTeEkJIY6ExRQtIJBCiMx5+b6W6fHwvlZHeJLxJhBDSbGCfoiYq2paVlaljx46p7t3r55riz2vWrIn4dw4fPqx/Cfv3hzrUHT9+XP9qyuDnQ7BzkH/Ohy8YqoXbT9fsVtf+/auI3dF/fclwdd6IUNlTkH8WEkwaw3NASHN7Drq2y1Qv3zxRV1Is3VahnpgRikMo7NxG3XP2QHXe8FydqRiU67VDRloLdWr/zvr3jem6mxNBew4I8YOm8hyc0r+zjs8Ajf1nId7TVJ4DQlKBz4F32B1rGr1omwyPPPKIevjhhxv8/927d6vq6uhNUJrKjVFRUaEnJDiSg8rPJvdQR2tq1NwtIUFdGJ7bVv332YWqZ8d0ZhaTJv8cENIcn4PHvtlH/Xz6JrW5vFr917hc9Y0hnVXL9BaqrCzUGZyQ5vAcEOIlfA4I4XNACOcDb6msDMXBNXnRtkuXLio9PV2VlJTU+//4c25ubsS/gygFNC6zOm179eqlunbtqrKzs1VTX5ShhAg/a9A3J89/hw0EiDs0pueAkOb4HLzA8Z94RJCfA0K8gs8BIXwOCOF84C1ZWVnNQ7TNzMxUY8eOVTNmzFAXXXSRufDAn++8886If6dVq1b6VzhYrDeHBTs2J83lZyUkGnwOCOFzQAjnA0K4LiKE+wNCuE/2Grt6XKMXbQFcs9ddd50aN26cmjBhgnr88cdVVVWVuuGGG/y+NEIIIYQQQgghhBBCCEmIJiHaXn755TqP9sEHH1S7du1SJ5xwgpo+fXqD5mSEEEIIIYQQQgghhBASdJqEaAsQhRAtDoEQQgghhBBCCCGEEEIaCww1JYQQQgghhBBCCCGEkABB0ZYQQgghhBBCCCGEEEICBEVbQgghhBBCCCGEEEIICRAUbQkhhBBCCCGEEEIIISRAULQlhBBCCCGEEEIIIYSQAEHRlhBCCCGEEEIIIYQQQgIERVtCCCGEEEIIIYQQQggJEC39voAgUFtbqz/u37/f70txnePHj6vKykqVlZWl0tKo2ZPmCZ8DQvgcEML5gBCuiwjh/oAQ7pP9QPRH0SOjQdFWKS1igl69ennx3hBCCCGEEEIIIYQQQpq5HtmhQ4eon29RG0/WbSauux07dqj27durFi1aqKau5kOc3rp1q8rOzvb7cgjxBT4HhPA5IITzASFcFxHC/QEh3Cf7AaRYCLb5+fkxq+DptEWwb1qa6tmzp2pOQLClaEuaO3wOCOFzQAjnA0K4LiKE+wNCuE/2mlgOW4GhpoQQQgghhBBCCCGEEBIgKNoSQgghhBBCCCGEEEJIgKBo28xo1aqVeuihh/RHQporfA4I4XNACOcDQrguIoT7A0K4Tw4ybERGCCGEEEIIIYQQQgghAYJOW0IIIYQQQgghhBBCCAkQFG0JIYQQQgghhBBCCCEkQFC0JYQQQgghhBBCCCGEkABB0baZ8dRTT6nCwkKVlZWlJk6cqL766iu/L4kQ1/j5z3+uWrRoUe/X4MGDzc9XV1erO+64Q3Xu3Fm1a9dOXXrppaqkpITvCGnUzJ49W11wwQUqPz9f3/Nvv/12vc/X1taqBx98UOXl5anWrVurKVOmqPXr19f7mvLycnX11Ver7Oxs1bFjR3XTTTepAwcOePyTEOLec3D99dc3mB/OOeecel/D54A0Zh555BE1fvx41b59e9WtWzd10UUXqbVr19b7GjvroOLiYvWNb3xDtWnTRv87P/zhD9XRo0c9/mkIce85OOOMMxrMB7feemu9r+FzQBozTz/9tBo5cqRe1+PXpEmT1Icffmh+nnNBsKFo24x49dVX1T333KMeeughtWjRIjVq1Cg1bdo0VVpa6velEeIaw4YNUzt37jR/ffHFF+bn7r77bvXee++p119/Xc2aNUvt2LFDXXLJJXw3SKOmqqpKj+84pIvEo48+qp544gn1zDPPqPnz56u2bdvquQALNgGC7cqVK9XHH3+s3n//fS2A3XLLLR7+FIS4+xwAiLTW+eHll1+u93k+B6Qxg3UNBNl58+bpsfzIkSNq6tSp+tmwuw46duyYFmxramrUnDlz1AsvvKCef/55ffBHSFN5DsDNN99cbz7AWkngc0AaOz179lS//vWv1cKFC9WCBQvUWWedpS688EK91gecCwJOLWk2TJgwofaOO+4w/3zs2LHa/Pz82kceecTX6yLELR566KHaUaNGRfzcvn37ajMyMmpff/118/+tXr26FsPi3Llz+aaQJgHu57feesv88/Hjx2tzc3Nrf/vb39Z7Flq1alX78ssv6z+vWrVK/72vv/7a/JoPP/ywtkWLFrXbt2/3+CcgxPnnAFx33XW1F154YdS/w+eANDVKS0v1szBr1izb66APPvigNi0trXbXrl3m1zz99NO12dnZtYcPH/bhpyDE2ecAnH766bU/+MEPov4dPgekKZKTk1P717/+lXNBI4BO22YCTshxsoIyWCEtLU3/ee7cub5eGyFugrJvlMf27dtXu6ZQ3gTwPOC03fpMIDqhd+/efCZIk2XTpk1q165d9e77Dh066LgcmQvwEZEI48aNM78GX485A85cQpoKM2fO1OWygwYNUrfddpvas2eP+Tk+B6SpUVFRoT926tTJ9joIH0eMGKG6d+9ufg0qM/bv3286tAhpzM+B8OKLL6ouXbqo4cOHq/vvv18dPHjQ/ByfA9KUgHP8lVde0W5zxCRwLgg+Lf2+AOINZWVl+gG1LroA/rxmzRq+DaRJAiEKZXzYkKPU6eGHH1annnqqWrFihRauMjMztTgV/kzgc4Q0ReTejjQXyOfwEUKWlZYtW+oNDp8N0lRANALKwPv06aM2bNigHnjgAXXuuefqzXl6ejqfA9KkOH78uLrrrrvUySefrEUpYGcdhI+R5gv5HCGN/TkAV111lSooKNAmj2XLlqkf//jHOvf2zTff1J/nc0CaAsuXL9ciLeLQkGH+1ltvqaFDh6olS5ZwLgg4FG0JIU0WbMAFhK9DxMWi7LXXXtMNmAghhDRPrrjiCvP3cBJijujXr592306ePNnXayPEaZDpiQNra64/Ic2NaM+BNbMf8wEatWIewIEe5gVCmgIwMUGghdv8jTfeUNddd53OfCbBh/EIzQSUe8A5Et4RFn/Ozc317boI8RK4SQYOHKiKior0fY/YkH379tX7Gj4TpCkj432suQAfwxtUolN4eXk55wvSZEGEDtZKmB8AnwPSVLjzzjt1Q8nPPvtMN6MR7KyD8DHSfCGfI6SxEO05iARMHsA6H/A5II0dVFb0799fjR07Vj3yyCO6Wesf/vAHzgWNAIq2zeghxQM6Y8aMeiUi+DNs8oQ0Bw4cOKBPzXGCjuchIyOj3jOBUihk3vKZIE0VlIJj82G975FNiKxaue/xEZt4ZFwJn376qZ4zZCNDSFNj27ZtOtMW8wPgc0AaO+jBB6EKJbAYwzH+W7GzDsJHlNRaD/I+/vhjlZ2drctqCWnsz0Ek4EYE1vmAzwFpamBdf/jwYc4FjQG/O6ER73jllVd0h/Dnn39ed0W+5ZZbajt27FivIywhTYl77723dubMmbWbNm2q/fLLL2unTJlS26VLF905Ftx66621vXv3rv30009rFyxYUDtp0iT9i5DGTGVlZe3ixYv1L0zzjz32mP79li1b9Od//etf67H/nXfeqV22bFnthRdeWNunT5/aQ4cOmf/GOeecUzt69Oja+fPn137xxRe1AwYMqL3yyit9/KkIce45wOfuu+++2rlz5+r54ZNPPqkdM2aMvs+rq6vNf4PPAWnM3HbbbbUdOnTQ66CdO3eavw4ePGh+Tbx10NGjR2uHDx9eO3Xq1NolS5bUTp8+vbZr1661999/v08/FSHOPgdFRUW1v/jFL/T9j/kAa6O+ffvWnnbaaea/weeANHZ+8pOf1M6aNUvf41j7488tWrSo/c9//qM/z7kg2FC0bWY8+eSTenGWmZlZO2HChNp58+b5fUmEuMbll19em5eXp+/3Hj166D9jcSZApLr99ttrc3Jyatu0aVN78cUX64UcIY2Zzz77TItU4b+uu+46/fnjx4/X/uxnP6vt3r27PsibPHly7dq1a+v9G3v27NEibbt27Wqzs7Nrb7jhBi10EdIUngNs1iFCQXzKyMioLSgoqL355psbHGLzOSCNmUj3P34999xzCa2DNm/eXHvuuefWtm7dWh9840D8yJEjPvxEhDj/HBQXF2uBtlOnTnpN1L9//9of/vCHtRUVFfX+HT4HpDFz44036rUO9sRY+2DtL4It4FwQbFrgP367fQkhhBBCCCGEEEIIIYSEYKYtIYQQQgghhBBCCCGEBAiKtoQQQgghhBBCCCGEEBIgKNoSQgghhBBCCCGEEEJIgKBoSwghhBBCCCGEEEIIIQGCoi0hhBBCCCGEEEIIIYQECIq2hBBCCCGEEEIIIYQQEiAo2hJCCCGEEEIIIYQQQkiAoGhLCCGEEEIIIYQQQgghAYKiLSGEEEIIIT4xc+ZM1aJFC7Vv3z6+B4QQQgghxISiLSGEEEIIaTTU1taqKVOmqGnTpjX43J/+9CfVsWNHtW3bNk+upbCwUD3++OOefC9CCCGEENK8oGhLCCGEEEIaDXClPvfcc2r+/Pnq2WefNf//pk2b1I9+9CP15JNPqp49ezr6PY8cOeLov0cIIYQQQkg8KNoSQgghhJBGRa9evdQf/vAHdd9992mxFu7bm266SU2dOlWNHj1anXvuuapdu3aqe/fu6pprrlFlZWXm350+fbo65ZRTtCO3c+fO6vzzz1cbNmwwP79582YtDL/66qvq9NNPV1lZWerFF1+0dV34e3/961/VxRdfrNq0aaMGDBig3n333Xpf88EHH6iBAweq1q1bqzPPPFN/v3C++OILdeqpp+qvwc/6/e9/X1VVVenP/eMf/9A/2/r1682vv/3229XgwYPVwYMHk3o9CSGEEEJI8KBoSwghhBBCGh3XXXedmjx5srrxxhvVH//4R7VixQrtvD3rrLO0cLtgwQIt0JaUlKjLLrvM/HsQP++55x79+RkzZqi0tDQtsh4/frzev/+Tn/xE/eAHP1CrV6+OGMUQjYcfflh/v2XLlqnzzjtPXX311aq8vFx/buvWreqSSy5RF1xwgVqyZIn6zne+o7+PFQjI55xzjrr00kv1vwHxGCLunXfeqT9/7bXXmv/u0aNH1b///W8tFENYhlBMCCGEEEKaBi1qYU0ghBBCCCGkkVFaWqqGDRumRdF//etfWrj9/PPP1UcffWR+DfJt4VZdu3atdriGAxdu165d1fLly9Xw4cO187VPnz46qxaibbxM27vuukv/EqftT3/6U/XLX/7SFIjhiv3www+1EPvAAw+od955R61cudL8NyDa/uY3v1F79+7V7l8Iuenp6fWiHyDawvWLfw/OX3ztyJEjtfj75ptvaicu/m1CCCGEENJ0oNOWEEIIIYQ0Srp166a++93vqiFDhqiLLrpILV26VH322WdaKJVfiA0AEoGAWIErr7xS9e3bV2VnZ2vhFRQXF9f7t8eNG5fUNUFMFdq2bau/B8RlANfuxIkT6339pEmT6v0ZP8Pzzz9f72eA0xdOYERBgJycHPW3v/1NPf3006pfv34N3LqEEEIIIaTx09LvCyCEEEIIISRZWrZsqX+BAwcOaPcpnKvh5OXl6Y/4fEFBgfrLX/6i8vPztRgKh21NTU29r4fgmgwZGRn1/gz3bXj0QizwM0CIhns2nN69e5u/nz17tnbk7ty5Uztw27dvn9T1EkIIIYSQYELRlhBCCCGENAnGjBmjYxLgnhUh18qePXt0TAIEWzT6kugBr4AjOLwx2bx58xr8DKtWrVL9+/eP+u/MmTNHC9Pvvfee+vGPf6zzbl944QXXrpsQQgghhHgP4xEIIYQQQkiT4I477tD5tog/+Prrr3UkAvJtb7jhBnXs2DEdK9C5c2f15z//WRUVFalPP/1UNyXziltvvVXHM/zwhz/U4vFLL72koxCsQISFKAshFs3K8PXIwZVGZJWVleqaa67RTtxzzz1XNyBDs7I33njDs5+DEEIIIYS4D0VbQgghhBDSJEDcwZdffqkF2qlTp6oRI0boJmFo8JWWlqZ/vfLKK2rhwoU6EuHuu+9Wv/3tbz27PsQbwAn89ttvq1GjRqlnnnlG/epXv2qQiTtr1iy1bt067QYePXq0evDBB/XPBtAcDdEN8vfwM+L3iFTYvn27Zz8LIYQQQghxlxa1tbW1Ln8PQgghhBBCCCGEEEIIITah05YQQgghhBBCCCGEEEICBEVbQgghhBBCCCGEEEIICRAUbQkhhBBCCCGEEEIIISRAULQlhBBCCCGEEEIIIYSQAEHRlhBCCCGEEEIIIYQQQgIERVtCCCGEEEIIIYQQQggJEBRtCSGEEEIIIYQQQgghJEBQtCWEEEIIIYQQQgghhJAAQdGWEEIIIYQQQgghhBBCAgRFW0IIIYQQQgghhBBCCAkQFG0JIYQQQgghhBBCCCEkQFC0JYQQQgghhBBCCCGEEBUc/j+1sNn/8ygz7QAAAABJRU5ErkJggg==" }, "metadata": {}, "output_type": "display_data" @@ -290,8 +290,8 @@ "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2025-11-02T13:09:31.986196Z", - "start_time": "2025-11-02T13:09:31.983898Z" + "end_time": "2025-11-02T20:14:05.781248Z", + "start_time": "2025-11-02T20:14:05.774153Z" } }, "source": [ @@ -340,8 +340,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-11-02T13:09:32.012024Z", - "start_time": "2025-11-02T13:09:32.010425Z" + "end_time": "2025-11-02T20:14:05.813958Z", + "start_time": "2025-11-02T20:14:05.812374Z" } }, "cell_type": "code", @@ -353,8 +353,8 @@ "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2025-11-02T13:09:32.047796Z", - "start_time": "2025-11-02T13:09:32.044621Z" + "end_time": "2025-11-02T20:14:05.839567Z", + "start_time": "2025-11-02T20:14:05.837022Z" } }, "source": [ @@ -364,7 +364,7 @@ "# BASE_URL = (\"http://34.141.187.117\") # Example: \"https://api.faim.example.com\"\n", "BASE_URL = (\"https://api.faim.it.com\") # Example: \"https://api.faim.example.com\"\n", "# FAIM_API_KEY = os.environ[\"FAIM_API_KEY\"] # \"your-secret-api-key\"\n", - "FAIM_API_KEY = \"api_key_1_28bbe832-bbb3-4444-83bd-06d8615bffbb_6hCNkGmAy4TUgcXD8s71t9ALz39CIxJKksHRKBU-dzM\"\n", + "FAIM_API_KEY = \"api_key_1_8f1e9cfd-261e-4f7a-a888-c7813fe720c2_cHCOR1R8g0NwVL0lk4MxzWhr7tbbgij-HAD4AmUx3Eg\"\n", "client = ForecastClient(\n", " base_url=BASE_URL,\n", " api_key=FAIM_API_KEY, # Optional: API key for authentication\n", @@ -395,8 +395,8 @@ "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2025-11-02T13:09:32.064134Z", - "start_time": "2025-11-02T13:09:32.062414Z" + "end_time": "2025-11-02T20:14:05.860254Z", + "start_time": "2025-11-02T20:14:05.858482Z" } }, "source": [ @@ -411,8 +411,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-11-02T13:09:32.077835Z", - "start_time": "2025-11-02T13:09:32.075596Z" + "end_time": "2025-11-02T20:14:05.899237Z", + "start_time": "2025-11-02T20:14:05.894819Z" } }, "cell_type": "code", @@ -440,8 +440,8 @@ "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2025-11-02T13:09:32.091706Z", - "start_time": "2025-11-02T13:09:32.088676Z" + "end_time": "2025-11-02T20:14:05.933396Z", + "start_time": "2025-11-02T20:14:05.930522Z" } }, "source": [ @@ -487,8 +487,8 @@ "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2025-11-02T13:09:32.883338Z", - "start_time": "2025-11-02T13:09:32.114395Z" + "end_time": "2025-11-02T20:14:07.616676Z", + "start_time": "2025-11-02T20:14:05.952174Z" } }, "source": [ @@ -513,33 +513,17 @@ " raise" ], "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "API error: status=401, code=INVALID_API_KEY, message=API key not found or inactive, request_id=\n" - ] - }, { "name": "stdout", "output_type": "stream", "text": [ - "✗ Forecast failed: API key not found or inactive | status=401 | error_code=INVALID_API_KEY\n", + "✓ Forecast successful!\n", "\n", - "Error type: AuthenticationError\n", - "Details: {}\n" - ] - }, - { - "ename": "AuthenticationError", - "evalue": "API key not found or inactive | status=401 | error_code=INVALID_API_KEY", - "output_type": "error", - "traceback": [ - "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m", - "\u001B[0;31mAuthenticationError\u001B[0m Traceback (most recent call last)", - "Cell \u001B[0;32mIn[12], line 3\u001B[0m\n\u001B[1;32m 1\u001B[0m \u001B[38;5;28;01mtry\u001B[39;00m:\n\u001B[1;32m 2\u001B[0m \u001B[38;5;66;03m# Make forecast request\u001B[39;00m\n\u001B[0;32m----> 3\u001B[0m response \u001B[38;5;241m=\u001B[39m \u001B[43mclient\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mforecast\u001B[49m\u001B[43m(\u001B[49m\u001B[43mModelName\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mFLOWSTATE\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mrequest\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 5\u001B[0m \u001B[38;5;28mprint\u001B[39m(\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124m✓ Forecast successful!\u001B[39m\u001B[38;5;124m\"\u001B[39m)\n\u001B[1;32m 6\u001B[0m \u001B[38;5;28mprint\u001B[39m(\u001B[38;5;124mf\u001B[39m\u001B[38;5;124m\"\u001B[39m\u001B[38;5;130;01m\\n\u001B[39;00m\u001B[38;5;124mResponse: \u001B[39m\u001B[38;5;132;01m{\u001B[39;00mresponse\u001B[38;5;132;01m}\u001B[39;00m\u001B[38;5;124m\"\u001B[39m)\n", - "File \u001B[0;32m~/Documents/Personal/research/FAIM/faim-client/faim_sdk/client.py:247\u001B[0m, in \u001B[0;36mForecastClient.forecast\u001B[0;34m(self, model, request)\u001B[0m\n\u001B[1;32m 245\u001B[0m \u001B[38;5;66;03m# Map HTTP status code to exception class\u001B[39;00m\n\u001B[1;32m 246\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m response\u001B[38;5;241m.\u001B[39mstatus_code \u001B[38;5;129;01min\u001B[39;00m (\u001B[38;5;241m401\u001B[39m, \u001B[38;5;241m403\u001B[39m):\n\u001B[0;32m--> 247\u001B[0m \u001B[38;5;28;01mraise\u001B[39;00m AuthenticationError(\n\u001B[1;32m 248\u001B[0m message\u001B[38;5;241m=\u001B[39mmessage,\n\u001B[1;32m 249\u001B[0m status_code\u001B[38;5;241m=\u001B[39mresponse\u001B[38;5;241m.\u001B[39mstatus_code,\n\u001B[1;32m 250\u001B[0m error_response\u001B[38;5;241m=\u001B[39merror_response,\n\u001B[1;32m 251\u001B[0m )\n\u001B[1;32m 252\u001B[0m \u001B[38;5;28;01melif\u001B[39;00m response\u001B[38;5;241m.\u001B[39mstatus_code \u001B[38;5;241m==\u001B[39m \u001B[38;5;241m402\u001B[39m:\n\u001B[1;32m 253\u001B[0m \u001B[38;5;28;01mraise\u001B[39;00m InsufficientFundsError(\n\u001B[1;32m 254\u001B[0m message\u001B[38;5;241m=\u001B[39mmessage,\n\u001B[1;32m 255\u001B[0m status_code\u001B[38;5;241m=\u001B[39mresponse\u001B[38;5;241m.\u001B[39mstatus_code,\n\u001B[1;32m 256\u001B[0m error_response\u001B[38;5;241m=\u001B[39merror_response,\n\u001B[1;32m 257\u001B[0m )\n", - "\u001B[0;31mAuthenticationError\u001B[0m: API key not found or inactive | status=401 | error_code=INVALID_API_KEY" + "Response: ForecastResponse(outputs=[point.shape=(1, 20, 1)], metadata={'model_name': 'flowstate', 'model_version': '1', 'transaction_id': '89e66b93-a48d-45e7-ae0b-def5816bbc16', 'cost_amount': 27000, 'cost_currency': 'USD'})\n", + "\n", + "Response details:\n", + " - Point predictions shape: (1, 20, 1)\n", + " - Metadata: {'model_name': 'flowstate', 'model_version': '1', 'transaction_id': '89e66b93-a48d-45e7-ae0b-def5816bbc16', 'cost_amount': 27000, 'cost_currency': 'USD'}\n" ] } ], @@ -554,7 +538,12 @@ }, { "cell_type": "code", - "metadata": {}, + "metadata": { + "ExecuteTime": { + "end_time": "2025-11-02T20:14:07.735959Z", + "start_time": "2025-11-02T20:14:07.635581Z" + } + }, "source": [ "# Plot forecast vs ground truth\n", "plt.figure(figsize=(14, 6))\n", @@ -599,8 +588,19 @@ "plt.tight_layout()\n", "plt.show()" ], - "outputs": [], - "execution_count": null + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 13 }, { "cell_type": "markdown", @@ -611,7 +611,12 @@ }, { "cell_type": "code", - "metadata": {}, + "metadata": { + "ExecuteTime": { + "end_time": "2025-11-02T20:14:07.755936Z", + "start_time": "2025-11-02T20:14:07.750679Z" + } + }, "source": [ "# Calculate error metrics\n", "mae = np.mean(np.abs(predictions - y_true))\n", @@ -638,8 +643,42 @@ "print(\"\\nPoint-by-point comparison:\")\n", "print(comparison_df.to_string(index=False))" ], - "outputs": [], - "execution_count": null + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Forecast Accuracy Metrics:\n", + " MAE (Mean Absolute Error): 47.77\n", + " RMSE (Root Mean Squared Error): 53.50\n", + " MAPE (Mean Absolute % Error): 270.81%\n", + "\n", + "Point-by-point comparison:\n", + " Year Ground Truth Predicted Error Abs Error Error %\n", + " 1 157.600006 109.040283 -48.559723 48.559723 30.812008\n", + " 2 142.600006 102.783310 -39.816696 39.816696 27.921946\n", + " 3 145.699997 105.247070 -40.452927 40.452927 27.764534\n", + " 4 94.300003 106.716339 12.416336 12.416336 13.166846\n", + " 5 54.599998 109.298645 54.698647 54.698647 100.180672\n", + " 6 29.900000 113.787292 83.887291 83.887291 280.559509\n", + " 7 17.500000 99.867477 82.367477 82.367477 470.671326\n", + " 8 8.600000 89.409088 80.809090 80.809090 939.640503\n", + " 9 21.500000 70.229668 48.729668 48.729668 226.649612\n", + " 10 64.300003 59.482063 -4.817940 4.817940 7.492908\n", + " 11 93.300003 51.612942 -41.687061 41.687061 44.680664\n", + " 12 119.599998 45.011467 -74.588531 74.588531 62.364994\n", + " 13 111.000000 39.899113 -71.100891 71.100891 64.054855\n", + " 14 104.000000 36.814964 -67.185036 67.185036 64.600998\n", + " 15 63.700001 36.436573 -27.263428 27.263428 42.799728\n", + " 16 40.400002 46.089672 5.689671 5.689671 14.083343\n", + " 17 29.799999 50.359055 20.559055 20.559055 68.990120\n", + " 18 15.200000 56.709183 41.509182 41.509182 273.086731\n", + " 19 7.500000 60.124245 52.624245 52.624245 701.656555\n", + " 20 2.900000 59.597107 56.697105 56.697105 1955.072632\n" + ] + } + ], + "execution_count": 14 }, { "cell_type": "markdown", @@ -650,14 +689,19 @@ }, { "cell_type": "code", - "metadata": {}, + "metadata": { + "ExecuteTime": { + "end_time": "2025-11-02T20:14:07.771751Z", + "start_time": "2025-11-02T20:14:07.770183Z" + } + }, "source": [ "# Close the client connection\n", "# client.close()\n", "# print(\"✓ Client connection closed\")" ], "outputs": [], - "execution_count": null + "execution_count": 15 }, { "cell_type": "markdown", @@ -690,7 +734,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.0" + "version": "3.11.0" } }, "nbformat": 4, diff --git a/faim_sdk/__init__.py b/faim_sdk/__init__.py index 2bcc25e..2328b4d 100644 --- a/faim_sdk/__init__.py +++ b/faim_sdk/__init__.py @@ -50,6 +50,15 @@ ForecastResponse: Contains prediction outputs (point, quantiles, samples) and metadata. +Evaluation Tools: + The faim_sdk.eval subpackage provides metrics and visualization: + - Metrics: mse, mase, crps_from_quantiles + - Visualization: plot_forecast (requires: pip install faim-sdk[viz]) + + >>> from faim_sdk.eval import mse, plot_forecast + >>> mse_score = mse(test_data, response.point) + >>> fig, ax = plot_forecast(train_data[0], response.point[0], test_data[0]) + Exceptions: - AuthenticationError: API key issues (401, 403) - ValidationError: Invalid request parameters (422) @@ -133,4 +142,4 @@ "ConfigurationError", ] -__version__ = "0.2.0" +__version__ = "0.2.1" From cb6d27360e87505c70805b5a82267b63dcd65948 Mon Sep 17 00:00:00 2001 From: Andrei Chernov Date: Tue, 4 Nov 2025 12:26:50 +0100 Subject: [PATCH 04/10] added eval --- README.md | 168 ++ examples/flowstate_simple_example.ipynb | 212 ++- examples/model_comparison_example.ipynb | 936 +++++++++++ faim_sdk/eval/__init__.py | 76 + faim_sdk/eval/metrics.py | 566 +++++++ faim_sdk/eval/py.typed | 0 faim_sdk/eval/visualization.py | 400 +++++ tests/unit/test_eval_metrics.py | 388 +++++ tests/unit/test_eval_visualization.py | 393 +++++ uv.lock | 2059 +++++++++++++++++++++++ 10 files changed, 5110 insertions(+), 88 deletions(-) create mode 100644 examples/model_comparison_example.ipynb create mode 100644 faim_sdk/eval/__init__.py create mode 100644 faim_sdk/eval/metrics.py create mode 100644 faim_sdk/eval/py.typed create mode 100644 faim_sdk/eval/visualization.py create mode 100644 tests/unit/test_eval_metrics.py create mode 100644 tests/unit/test_eval_visualization.py create mode 100644 uv.lock diff --git a/README.md b/README.md index 4d7ca97..40d3241 100644 --- a/README.md +++ b/README.md @@ -15,6 +15,7 @@ Production-ready Python SDK for FAIM (Foundation AI Models) - a high-performance - **🔄 Async Support**: Built-in async/await support for concurrent requests - **📊 Rich Error Handling**: Machine-readable error codes with detailed diagnostics - **🧪 Battle-Tested**: Production-ready with comprehensive error handling +- **📈 Evaluation Tools**: Built-in metrics (MSE, MASE, CRPS) and visualization utilities ## Installation @@ -140,6 +141,173 @@ print(response.metadata) # {'model_name': 'chronos2', 'model_version': '1.0', 'inference_time_ms': 123} ``` +## Evaluation & Metrics + +The SDK includes a comprehensive evaluation toolkit (`faim_sdk.eval`) for measuring forecast quality with standard metrics and visualizations. + +### Installation + +For visualization support, install with the viz extra: + +```bash +pip install faim-sdk[viz] +``` + +### Available Metrics + +#### Mean Squared Error (MSE) + +Measures average squared difference between predictions and ground truth. + +```python +from faim_sdk.eval import mse + +# Evaluate point forecast +mse_score = mse(test_data, response.point, reduction='mean') +print(f"MSE: {mse_score:.4f}") + +# Per-sample MSE +mse_per_sample = mse(test_data, response.point, reduction='none') +print(f"MSE per sample shape: {mse_per_sample.shape}") # (batch_size,) +``` + +#### Mean Absolute Scaled Error (MASE) + +Scale-independent metric comparing forecast to naive baseline (better than MAPE for series with zeros). + +```python +from faim_sdk.eval import mase + +# MASE requires training data for baseline +mase_score = mase(test_data, response.point, train_data, reduction='mean') +print(f"MASE: {mase_score:.4f}") + +# Interpretation: +# MASE < 1: Better than naive baseline +# MASE = 1: Equivalent to naive baseline +# MASE > 1: Worse than naive baseline +``` + +#### Continuous Ranked Probability Score (CRPS) + +Proper scoring rule for probabilistic forecasts - generalizes MAE to distributions. + +```python +from faim_sdk.eval import crps_from_quantiles + +# Evaluate probabilistic forecast with quantiles +crps_score = crps_from_quantiles( + test_data, + response.quantiles, + quantile_levels=[0.1, 0.5, 0.9], + reduction='mean' +) +print(f"CRPS: {crps_score:.4f}") +``` + +### Visualization + +Plot forecasts with training context and ground truth: + +```python +from faim_sdk.eval import plot_forecast + +# Plot single sample (remember to index batch dimension!) +fig, ax = plot_forecast( + train_data=train_data[0], # (seq_len, features) - 2D array + forecast=response.point[0], # (horizon, features) - 2D array + test_data=test_data[0], # (horizon, features) - optional + title="Time Series Forecast" +) + +# Save to file +fig.savefig("forecast.png", dpi=300, bbox_inches="tight") +``` + +#### Multi-Feature Visualization + +```python +# Option 1: All features on same plot +fig, ax = plot_forecast( + train_data[0], + response.point[0], + test_data[0], + features_on_same_plot=True, + feature_names=["Temperature", "Humidity", "Pressure"] +) + +# Option 2: Separate subplots per feature +fig, axes = plot_forecast( + train_data[0], + response.point[0], + test_data[0], + features_on_same_plot=False, + feature_names=["Temperature", "Humidity", "Pressure"] +) +``` + +### Complete Evaluation Example + +```python +import numpy as np +from faim_sdk import ForecastClient, Chronos2ForecastRequest +from faim_sdk.eval import mse, mase, crps_from_quantiles, plot_forecast +from faim_client.models import ModelName + +# Initialize client +client = ForecastClient(base_url="https://api.faim.example.com") + +# Prepare data splits +train_data = np.random.randn(32, 100, 1) +test_data = np.random.randn(32, 24, 1) + +# Generate forecast +request = Chronos2ForecastRequest( + x=train_data, + horizon=24, + output_type="quantiles", + quantiles=[0.1, 0.5, 0.9] +) +response = client.forecast(ModelName.CHRONOS2, request) + +# Evaluate point forecast (use median) +point_pred = response.quantiles[:, :, 1:2] # Extract median, keep 3D shape +mse_score = mse(test_data, point_pred) +mase_score = mase(test_data, point_pred, train_data) + +# Evaluate probabilistic forecast +crps_score = crps_from_quantiles( + test_data, + response.quantiles, + quantile_levels=[0.1, 0.5, 0.9] +) + +print(f"MSE: {mse_score:.4f}") +print(f"MASE: {mase_score:.4f}") +print(f"CRPS: {crps_score:.4f}") + +# Visualize best and worst predictions +mse_per_sample = mse(test_data, point_pred, reduction='none') +best_idx = np.argmin(mse_per_sample) +worst_idx = np.argmax(mse_per_sample) + +fig1, ax1 = plot_forecast( + train_data[best_idx], + point_pred[best_idx], + test_data[best_idx], + title=f"Best Forecast (MSE: {mse_per_sample[best_idx]:.4f})" +) +fig1.savefig("best_forecast.png") + +fig2, ax2 = plot_forecast( + train_data[worst_idx], + point_pred[worst_idx], + test_data[worst_idx], + title=f"Worst Forecast (MSE: {mse_per_sample[worst_idx]:.4f})" +) +fig2.savefig("worst_forecast.png") +``` + ## Error Handling The SDK provides **machine-readable error codes** for robust error handling: diff --git a/examples/flowstate_simple_example.ipynb b/examples/flowstate_simple_example.ipynb index 1382c86..0ee9f4f 100644 --- a/examples/flowstate_simple_example.ipynb +++ b/examples/flowstate_simple_example.ipynb @@ -16,8 +16,8 @@ "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2025-11-02T20:14:00.516676Z", - "start_time": "2025-11-02T20:14:00.512097Z" + "end_time": "2025-11-03T19:29:40.434952Z", + "start_time": "2025-11-03T19:29:40.353462Z" } }, "source": [ @@ -25,14 +25,14 @@ "# !pip install numpy pandas matplotlib statsmodels" ], "outputs": [], - "execution_count": 1 + "execution_count": 31 }, { "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2025-11-02T20:14:02.793038Z", - "start_time": "2025-11-02T20:14:00.532314Z" + "end_time": "2025-11-03T19:29:40.621780Z", + "start_time": "2025-11-03T19:29:40.615481Z" } }, "source": [ @@ -48,7 +48,7 @@ "from faim_sdk import FlowStateForecastRequest, ForecastClient" ], "outputs": [], - "execution_count": 2 + "execution_count": 32 }, { "cell_type": "markdown", @@ -59,8 +59,8 @@ "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2025-11-02T20:14:05.421657Z", - "start_time": "2025-11-02T20:14:02.930056Z" + "end_time": "2025-11-03T19:29:41.140539Z", + "start_time": "2025-11-03T19:29:41.029672Z" } }, "source": [ @@ -106,14 +106,14 @@ ] } ], - "execution_count": 3 + "execution_count": 33 }, { "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2025-11-02T20:14:05.451275Z", - "start_time": "2025-11-02T20:14:05.439088Z" + "end_time": "2025-11-03T19:29:41.299827Z", + "start_time": "2025-11-03T19:29:41.283178Z" } }, "source": [ @@ -184,19 +184,19 @@ "" ] }, - "execution_count": 4, + "execution_count": 34, "metadata": {}, "output_type": "execute_result" } ], - "execution_count": 4 + "execution_count": 34 }, { "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2025-11-02T20:14:05.506011Z", - "start_time": "2025-11-02T20:14:05.499919Z" + "end_time": "2025-11-03T19:29:41.702640Z", + "start_time": "2025-11-03T19:29:41.673551Z" } }, "source": [ @@ -227,7 +227,7 @@ ] } ], - "execution_count": 5 + "execution_count": 35 }, { "cell_type": "markdown", @@ -240,8 +240,8 @@ "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2025-11-02T20:14:05.758916Z", - "start_time": "2025-11-02T20:14:05.615480Z" + "end_time": "2025-11-03T19:29:42.713916Z", + "start_time": "2025-11-03T19:29:42.595488Z" } }, "source": [ @@ -284,14 +284,14 @@ "output_type": "display_data" } ], - "execution_count": 6 + "execution_count": 36 }, { "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2025-11-02T20:14:05.781248Z", - "start_time": "2025-11-02T20:14:05.774153Z" + "end_time": "2025-11-03T19:31:32.637040Z", + "start_time": "2025-11-03T19:31:31.666740Z" } }, "source": [ @@ -300,8 +300,8 @@ "# For univariate time series, features = 1\n", "\n", "# Use last 200 years for context, forecast next 10 years\n", - "context_length = 250\n", - "horizon = 20\n", + "context_length = 2048\n", + "horizon = 50\n", "\n", "# Use data from index -110 to -10 for context\n", "x = sunspots[-context_length - horizon : -horizon].reshape(1, context_length, 1)\n", @@ -316,17 +316,18 @@ ], "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "Input shape: (1, 250, 1)\n", - "Context period: 250 years\n", - "Forecasting 20 years ahead\n", - "Ground truth available: 20 points\n" + "ename": "ValueError", + "evalue": "cannot reshape array of size 259 into shape (1,2048,1)", + "output_type": "error", + "traceback": [ + "\u001B[31m---------------------------------------------------------------------------\u001B[39m", + "\u001B[31mValueError\u001B[39m Traceback (most recent call last)", + "\u001B[36mCell\u001B[39m\u001B[36m \u001B[39m\u001B[32mIn[52]\u001B[39m\u001B[32m, line 10\u001B[39m\n\u001B[32m 7\u001B[39m horizon = \u001B[32m50\u001B[39m\n\u001B[32m 9\u001B[39m \u001B[38;5;66;03m# Use data from index -110 to -10 for context\u001B[39;00m\n\u001B[32m---> \u001B[39m\u001B[32m10\u001B[39m x = \u001B[43msunspots\u001B[49m\u001B[43m[\u001B[49m\u001B[43m-\u001B[49m\u001B[43mcontext_length\u001B[49m\u001B[43m \u001B[49m\u001B[43m-\u001B[49m\u001B[43m \u001B[49m\u001B[43mhorizon\u001B[49m\u001B[43m \u001B[49m\u001B[43m:\u001B[49m\u001B[43m \u001B[49m\u001B[43m-\u001B[49m\u001B[43mhorizon\u001B[49m\u001B[43m]\u001B[49m\u001B[43m.\u001B[49m\u001B[43mreshape\u001B[49m\u001B[43m(\u001B[49m\u001B[32;43m1\u001B[39;49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mcontext_length\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[32;43m1\u001B[39;49m\u001B[43m)\u001B[49m\n\u001B[32m 12\u001B[39m \u001B[38;5;66;03m# Ground truth for comparison (last 10 years)\u001B[39;00m\n\u001B[32m 13\u001B[39m y_true = sunspots[-horizon:]\n", + "\u001B[31mValueError\u001B[39m: cannot reshape array of size 259 into shape (1,2048,1)" ] } ], - "execution_count": 7 + "execution_count": 52 }, { "cell_type": "markdown", @@ -340,8 +341,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-11-02T20:14:05.813958Z", - "start_time": "2025-11-02T20:14:05.812374Z" + "end_time": "2025-11-03T19:31:32.642179Z", + "start_time": "2025-11-03T19:29:48.452251Z" } }, "cell_type": "code", @@ -353,8 +354,8 @@ "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2025-11-02T20:14:05.839567Z", - "start_time": "2025-11-02T20:14:05.837022Z" + "end_time": "2025-11-03T19:31:32.642728Z", + "start_time": "2025-11-03T19:29:49.488109Z" } }, "source": [ @@ -363,8 +364,7 @@ "# BASE_URL = \"http://localhost:8003\" # Example: \"https://api.faim.example.com\"\n", "# BASE_URL = (\"http://34.141.187.117\") # Example: \"https://api.faim.example.com\"\n", "BASE_URL = (\"https://api.faim.it.com\") # Example: \"https://api.faim.example.com\"\n", - "# FAIM_API_KEY = os.environ[\"FAIM_API_KEY\"] # \"your-secret-api-key\"\n", - "FAIM_API_KEY = \"api_key_1_8f1e9cfd-261e-4f7a-a888-c7813fe720c2_cHCOR1R8g0NwVL0lk4MxzWhr7tbbgij-HAD4AmUx3Eg\"\n", + "FAIM_API_KEY = os.environ[\"FAIM_API_KEY\"] # \"your-secret-api-key\"\n", "client = ForecastClient(\n", " base_url=BASE_URL,\n", " api_key=FAIM_API_KEY, # Optional: API key for authentication\n", @@ -389,14 +389,14 @@ ] } ], - "execution_count": 8 + "execution_count": 38 }, { "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2025-11-02T20:14:05.860254Z", - "start_time": "2025-11-02T20:14:05.858482Z" + "end_time": "2025-11-03T19:31:32.977320Z", + "start_time": "2025-11-03T19:31:32.974722Z" } }, "source": [ @@ -406,42 +406,26 @@ "# logging.basicConfig(level=logging.DEBUG)\n" ], "outputs": [], - "execution_count": 9 + "execution_count": 53 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-11-02T20:14:05.899237Z", - "start_time": "2025-11-02T20:14:05.894819Z" + "end_time": "2025-11-03T19:43:27.826683Z", + "start_time": "2025-11-03T19:43:27.816494Z" } }, "cell_type": "code", - "source": "x.shape", - "outputs": [ - { - "data": { - "text/plain": [ - "(1, 250, 1)" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "execution_count": 10 - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": "# Create FlowState forecast request\nrequest = FlowStateForecastRequest(\n x=x,\n horizon=horizon,\n model_version=\"1\", # Use version 1 (backend requires integer versions)\n scale_factor=1.0, # Optional: normalization factor\n prediction_type=\"point\", # Optional: prediction mode\n compression=\"zstd\" # Use compression for efficiency\n)\n\nprint(f\"Request created:\")\nprint(f\" - Input shape: {request.x.shape}\")\nprint(f\" - Horizon: {request.horizon}\")\nprint(f\" - Model version: {request.model_version}\")\nprint(f\" - Compression: {request.compression}\")" + "source": "x =np.concat([x,x])", + "outputs": [], + "execution_count": 63 }, { "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2025-11-02T20:14:05.933396Z", - "start_time": "2025-11-02T20:14:05.930522Z" + "end_time": "2025-11-03T19:43:28.320481Z", + "start_time": "2025-11-03T19:43:28.313023Z" } }, "source": [ @@ -449,9 +433,9 @@ "request = FlowStateForecastRequest(\n", " x=x,\n", " horizon=horizon, # or specific version like \"1.0\"\n", - " scale_factor=0.65, # Optional: normalization factor\n", + " scale_factor=1.0, # Optional: normalization factor\n", " prediction_type=\"mean\", # Optional: prediction mode\n", - " compression=None\n", + " # compression=None\n", " # compression=\"zstd\", # Use compression for efficiency\n", ")\n", "\n", @@ -467,14 +451,26 @@ "output_type": "stream", "text": [ "Request created:\n", - " - Input shape: (1, 250, 1)\n", - " - Horizon: 20\n", + " - Input shape: (2, 250, 1)\n", + " - Horizon: 50\n", " - Model version: 1\n", - " - Compression: None\n" + " - Compression: zstd\n" ] } ], - "execution_count": 11 + "execution_count": 64 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-11-03T19:43:29.752799Z", + "start_time": "2025-11-03T19:43:29.750764Z" + } + }, + "cell_type": "code", + "source": "", + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -487,8 +483,8 @@ "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2025-11-02T20:14:07.616676Z", - "start_time": "2025-11-02T20:14:05.952174Z" + "end_time": "2025-11-03T19:43:30.813101Z", + "start_time": "2025-11-03T19:43:30.625141Z" } }, "source": [ @@ -513,21 +509,61 @@ " raise" ], "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Failed to parse error response: Expecting value: line 2 column 1 (char 1)\n", + "API error: status=502, no error_response\n" + ] + }, { "name": "stdout", "output_type": "stream", "text": [ - "✓ Forecast successful!\n", - "\n", - "Response: ForecastResponse(outputs=[point.shape=(1, 20, 1)], metadata={'model_name': 'flowstate', 'model_version': '1', 'transaction_id': '89e66b93-a48d-45e7-ae0b-def5816bbc16', 'cost_amount': 27000, 'cost_currency': 'USD'})\n", + "✗ Forecast failed: Request failed with status 502 | status=502\n", "\n", - "Response details:\n", - " - Point predictions shape: (1, 20, 1)\n", - " - Metadata: {'model_name': 'flowstate', 'model_version': '1', 'transaction_id': '89e66b93-a48d-45e7-ae0b-def5816bbc16', 'cost_amount': 27000, 'cost_currency': 'USD'}\n" + "Error type: APIError\n", + "Details: {}\n" ] + }, + { + "ename": "APIError", + "evalue": "Request failed with status 502 | status=502", + "output_type": "error", + "traceback": [ + "\u001B[31m---------------------------------------------------------------------------\u001B[39m", + "\u001B[31mAPIError\u001B[39m Traceback (most recent call last)", + "\u001B[36mCell\u001B[39m\u001B[36m \u001B[39m\u001B[32mIn[65]\u001B[39m\u001B[32m, line 3\u001B[39m\n\u001B[32m 1\u001B[39m \u001B[38;5;28;01mtry\u001B[39;00m:\n\u001B[32m 2\u001B[39m \u001B[38;5;66;03m# Make forecast request\u001B[39;00m\n\u001B[32m----> \u001B[39m\u001B[32m3\u001B[39m response = \u001B[43mclient\u001B[49m\u001B[43m.\u001B[49m\u001B[43mforecast\u001B[49m\u001B[43m(\u001B[49m\u001B[43mModelName\u001B[49m\u001B[43m.\u001B[49m\u001B[43mFLOWSTATE\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mrequest\u001B[49m\u001B[43m)\u001B[49m\n\u001B[32m 5\u001B[39m \u001B[38;5;28mprint\u001B[39m(\u001B[33m\"\u001B[39m\u001B[33m✓ Forecast successful!\u001B[39m\u001B[33m\"\u001B[39m)\n\u001B[32m 6\u001B[39m \u001B[38;5;28mprint\u001B[39m(\u001B[33mf\u001B[39m\u001B[33m\"\u001B[39m\u001B[38;5;130;01m\\n\u001B[39;00m\u001B[33mResponse: \u001B[39m\u001B[38;5;132;01m{\u001B[39;00mresponse\u001B[38;5;132;01m}\u001B[39;00m\u001B[33m\"\u001B[39m)\n", + "\u001B[36mFile \u001B[39m\u001B[32m~/Documents/Personal/research/FAIM/faim-client/faim_sdk/client.py:296\u001B[39m, in \u001B[36mForecastClient.forecast\u001B[39m\u001B[34m(self, model, request)\u001B[39m\n\u001B[32m 289\u001B[39m \u001B[38;5;28;01mraise\u001B[39;00m ServiceUnavailableError(\n\u001B[32m 290\u001B[39m message=message,\n\u001B[32m 291\u001B[39m status_code=response.status_code,\n\u001B[32m 292\u001B[39m error_response=error_response,\n\u001B[32m 293\u001B[39m )\n\u001B[32m 294\u001B[39m \u001B[38;5;28;01melse\u001B[39;00m:\n\u001B[32m 295\u001B[39m \u001B[38;5;66;03m# Fallback for unmapped status codes\u001B[39;00m\n\u001B[32m--> \u001B[39m\u001B[32m296\u001B[39m \u001B[38;5;28;01mraise\u001B[39;00m APIError(\n\u001B[32m 297\u001B[39m message=message,\n\u001B[32m 298\u001B[39m status_code=response.status_code,\n\u001B[32m 299\u001B[39m error_response=error_response,\n\u001B[32m 300\u001B[39m )\n\u001B[32m 302\u001B[39m \u001B[38;5;66;03m# Deserialize successful response\u001B[39;00m\n\u001B[32m 303\u001B[39m \u001B[38;5;28;01mtry\u001B[39;00m:\n", + "\u001B[31mAPIError\u001B[39m: Request failed with status 502 | status=502" + ] + } + ], + "execution_count": 65 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-11-03T19:31:47.317564Z", + "start_time": "2025-11-03T19:31:47.311049Z" + } + }, + "cell_type": "code", + "source": "response", + "outputs": [ + { + "data": { + "text/plain": [ + "ForecastResponse(outputs=[point.shape=(1, 50, 1)], metadata={'model_name': 'flowstate', 'model_version': '1', 'transaction_id': '18d320eb-f487-4860-b137-f232ce9ab76e', 'cost_amount': 300, 'cost_currency': 'USD'})" + ] + }, + "execution_count": 58, + "metadata": {}, + "output_type": "execute_result" } ], - "execution_count": 12 + "execution_count": 58 }, { "cell_type": "markdown", @@ -540,8 +576,8 @@ "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2025-11-02T20:14:07.735959Z", - "start_time": "2025-11-02T20:14:07.635581Z" + "end_time": "2025-11-03T11:09:48.631852Z", + "start_time": "2025-11-03T11:09:48.521954Z" } }, "source": [ @@ -600,7 +636,7 @@ "output_type": "display_data" } ], - "execution_count": 13 + "execution_count": 28 }, { "cell_type": "markdown", @@ -613,8 +649,8 @@ "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2025-11-02T20:14:07.755936Z", - "start_time": "2025-11-02T20:14:07.750679Z" + "end_time": "2025-11-03T11:09:48.657990Z", + "start_time": "2025-11-03T11:09:48.647876Z" } }, "source": [ @@ -678,7 +714,7 @@ ] } ], - "execution_count": 14 + "execution_count": 29 }, { "cell_type": "markdown", @@ -691,8 +727,8 @@ "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2025-11-02T20:14:07.771751Z", - "start_time": "2025-11-02T20:14:07.770183Z" + "end_time": "2025-11-03T11:09:48.698517Z", + "start_time": "2025-11-03T11:09:48.696624Z" } }, "source": [ @@ -701,7 +737,7 @@ "# print(\"✓ Client connection closed\")" ], "outputs": [], - "execution_count": 15 + "execution_count": 30 }, { "cell_type": "markdown", diff --git a/examples/model_comparison_example.ipynb b/examples/model_comparison_example.ipynb new file mode 100644 index 0000000..c1ea4c5 --- /dev/null +++ b/examples/model_comparison_example.ipynb @@ -0,0 +1,936 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# FAIM SDK: Complete Model Comparison with Evaluation Metrics\n", + "\n", + "This notebook demonstrates:\n", + "- Synthetic data generation for testing\n", + "- Forecasting with all available models (FlowState, Chronos2, TiRex)\n", + "- Both point and probabilistic forecasts\n", + "- Comprehensive evaluation with MSE, MASE, and CRPS metrics\n", + "- Visualization of results" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Setup and Imports" + ] + }, + { + "cell_type": "code", + "metadata": { + "ExecuteTime": { + "end_time": "2025-11-03T21:34:44.766466Z", + "start_time": "2025-11-03T21:34:43.895562Z" + } + }, + "source": [ + "import os\n", + "import sys\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "\n", + "# Import FAIM SDK\n", + "from faim_sdk import (\n", + " ForecastClient,\n", + " FlowStateForecastRequest,\n", + " Chronos2ForecastRequest,\n", + " TiRexForecastRequest,\n", + ")\n", + "from faim_client.models import ModelName\n", + "\n", + "# Import evaluation tools\n", + "from faim_sdk.eval import mse, mase, crps_from_quantiles, plot_forecast\n", + "\n", + "# Import data generation utilities\n", + "from generate_data import generate_linear_trend_series, generate_correlated_multi_series\n", + "\n", + "print(\"✓ All imports successful\")" + ], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✓ All imports successful\n" + ] + } + ], + "execution_count": 1 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. Initialize FAIM Client\n", + "\n", + "**Note**: Update the `BASE_URL` and `FAIM_API_KEY` with your actual endpoint and API key." + ] + }, + { + "cell_type": "code", + "metadata": { + "ExecuteTime": { + "end_time": "2025-11-03T21:34:44.785954Z", + "start_time": "2025-11-03T21:34:44.783436Z" + } + }, + "source": [ + "# Configuration\n", + "BASE_URL = \"https://api.faim.it.com\"\n", + "FAIM_API_KEY = os.environ[\"FAIM_API_KEY\"] # \"your-secret-api-key\"\n", + "# Initialize client\n", + "client = ForecastClient(\n", + " base_url=BASE_URL,\n", + " api_key=FAIM_API_KEY,\n", + " timeout=120.0,\n", + " verify_ssl=True,\n", + ")\n", + "\n", + "print(f\"✓ ForecastClient initialized: {BASE_URL}\")\n", + "print(f\" Authentication: {'Enabled' if FAIM_API_KEY else 'Disabled'}\")" + ], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✓ ForecastClient initialized: https://api.faim.it.com\n", + " Authentication: Enabled\n" + ] + } + ], + "execution_count": 2 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. Generate Synthetic Data\n", + "\n", + "We'll test with two datasets:\n", + "1. **Linear Trend**: Simple single-feature time series\n", + "2. **Correlated Multi-Series**: Two correlated features with seasonality" + ] + }, + { + "cell_type": "code", + "metadata": { + "ExecuteTime": { + "end_time": "2025-11-03T21:34:44.935793Z", + "start_time": "2025-11-03T21:34:44.930324Z" + } + }, + "source": [ + "# Configuration\n", + "BATCH_SIZE = 8\n", + "CONTEXT_LENGTH = 2000\n", + "HORIZON = 48\n", + "SEED = 42\n", + "\n", + "# Generate linear trend dataset (single feature)\n", + "print(\"Generating linear trend dataset...\")\n", + "linear_full = generate_linear_trend_series(\n", + " batch_size=BATCH_SIZE,\n", + " context_length=CONTEXT_LENGTH + HORIZON,\n", + " trend_slope=0.05,\n", + " noise_std=0.5,\n", + " seed=SEED\n", + ")\n", + "\n", + "# Split into train and test\n", + "linear_train = linear_full[:, :CONTEXT_LENGTH, :]\n", + "linear_test = linear_full[:, CONTEXT_LENGTH:, :]\n", + "\n", + "print(f\" Train shape: {linear_train.shape}\")\n", + "print(f\" Test shape: {linear_test.shape}\")\n", + "\n", + "# Generate correlated multi-series dataset (2 features)\n", + "print(\"\\nGenerating correlated multi-series dataset...\")\n", + "multi_full = generate_correlated_multi_series(\n", + " batch_size=BATCH_SIZE,\n", + " context_length=CONTEXT_LENGTH + HORIZON,\n", + " correlation=0.8,\n", + " seasonal_period=24,\n", + " seasonal_amplitude=2.0,\n", + " trend_slope=0.02,\n", + " noise_std=0.3,\n", + " seed=SEED\n", + ")\n", + "\n", + "# Split into train and test\n", + "multi_train = multi_full[:, :CONTEXT_LENGTH, :]\n", + "multi_test = multi_full[:, CONTEXT_LENGTH:, :]\n", + "\n", + "print(f\" Train shape: {multi_train.shape}\")\n", + "print(f\" Test shape: {multi_test.shape}\")\n", + "\n", + "# Calculate correlation for verification\n", + "corr = np.corrcoef(multi_train[0, :, 0], multi_train[0, :, 1])[0, 1]\n", + "print(f\" Correlation between features: {corr:.3f}\")" + ], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Generating linear trend dataset...\n", + " Train shape: (8, 2000, 1)\n", + " Test shape: (8, 48, 1)\n", + "\n", + "Generating correlated multi-series dataset...\n", + " Train shape: (8, 2000, 2)\n", + " Test shape: (8, 48, 2)\n", + " Correlation between features: 0.999\n" + ] + } + ], + "execution_count": 3 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4. Visualize Training Data" + ] + }, + { + "cell_type": "code", + "metadata": { + "ExecuteTime": { + "end_time": "2025-11-03T21:34:45.315534Z", + "start_time": "2025-11-03T21:34:44.988210Z" + } + }, + "source": [ + "fig, axes = plt.subplots(2, 2, figsize=(15, 8))\n", + "\n", + "# Plot linear trend samples\n", + "for i in range(2):\n", + " axes[0, i].plot(linear_train[i, :, 0], label=\"Training Data\", linewidth=1.5)\n", + " axes[0, i].axvline(x=CONTEXT_LENGTH-1, color='red', linestyle='--', alpha=0.5, label='Forecast Start')\n", + " axes[0, i].set_title(f\"Linear Trend - Sample {i+1}\")\n", + " axes[0, i].set_xlabel(\"Time Step\")\n", + " axes[0, i].set_ylabel(\"Value\")\n", + " axes[0, i].legend()\n", + " axes[0, i].grid(True, alpha=0.3)\n", + "\n", + "# Plot multi-series samples\n", + "for i in range(2):\n", + " axes[1, i].plot(multi_train[i, :, 0], label=\"Feature 1\", linewidth=1.5)\n", + " axes[1, i].plot(multi_train[i, :, 1], label=\"Feature 2\", linewidth=1.5, alpha=0.7)\n", + " axes[1, i].axvline(x=CONTEXT_LENGTH-1, color='red', linestyle='--', alpha=0.5, label='Forecast Start')\n", + " axes[1, i].set_title(f\"Correlated Multi-Series - Sample {i+1}\")\n", + " axes[1, i].set_xlabel(\"Time Step\")\n", + " axes[1, i].set_ylabel(\"Value\")\n", + " axes[1, i].legend()\n", + " axes[1, i].grid(True, alpha=0.3)\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "print(\"✓ Training data visualization complete\")" + ], + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✓ Training data visualization complete\n" + ] + } + ], + "execution_count": 4 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5. Forecast with All Models\n", + "\n", + "We'll test each model with both datasets and evaluate their performance." + ] + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-11-03T21:34:45.342253Z", + "start_time": "2025-11-03T21:34:45.338511Z" + } + }, + "cell_type": "code", + "source": "linear_train.shape", + "outputs": [ + { + "data": { + "text/plain": [ + "(8, 2000, 1)" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 5 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 5.1 FlowState (Point Forecasts)" + ] + }, + { + "cell_type": "code", + "metadata": { + "ExecuteTime": { + "end_time": "2025-11-03T21:38:53.736782Z", + "start_time": "2025-11-03T21:38:49.145028Z" + } + }, + "source": [ + "print(\"=\" * 60)\n", + "print(\"FLOWSTATE MODEL\")\n", + "print(\"=\" * 60)\n", + "\n", + "# Linear trend dataset\n", + "print(\"\\n1. Linear Trend Dataset (single feature)\")\n", + "request_linear_fs = FlowStateForecastRequest(\n", + " x=linear_train,\n", + " horizon=HORIZON,\n", + " scale_factor=1.0,\n", + " prediction_type=\"mean\",\n", + " output_type=\"point\"\n", + ")\n", + "\n", + "response_linear_fs = client.forecast(ModelName.FLOWSTATE, request_linear_fs)\n", + "print(f\" Response shape: {response_linear_fs.point.shape}\")\n", + "print(f\" Metadata: {response_linear_fs.metadata}\")\n", + "\n", + "# Evaluate\n", + "mse_linear_fs = mse(linear_test, response_linear_fs.point)\n", + "mase_linear_fs = mase(linear_test, response_linear_fs.point, linear_train)\n", + "print(f\" MSE: {mse_linear_fs:.4f}\")\n", + "print(f\" MASE: {mase_linear_fs:.4f}\")\n", + "\n", + "# Multi-series dataset\n", + "print(\"\\n2. Correlated Multi-Series Dataset (2 features)\")\n", + "request_multi_fs = FlowStateForecastRequest(\n", + " x=multi_train,\n", + " horizon=HORIZON,\n", + " scale_factor=1.0,\n", + " prediction_type=\"mean\",\n", + " output_type=\"point\"\n", + ")\n", + "\n", + "response_multi_fs = client.forecast(ModelName.FLOWSTATE, request_multi_fs)\n", + "print(f\" Response shape: {response_multi_fs.point.shape}\")\n", + "print(f\" Metadata: {response_multi_fs.metadata}\")\n", + "\n", + "# Evaluate\n", + "mse_multi_fs = mse(multi_test, response_multi_fs.point)\n", + "mase_multi_fs = mase(multi_test, response_multi_fs.point, multi_train)\n", + "print(f\" MSE: {mse_multi_fs:.4f}\")\n", + "print(f\" MASE: {mase_multi_fs:.4f}\")\n", + "\n", + "print(\"\\n✓ FlowState forecasts complete\")" + ], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "============================================================\n", + "FLOWSTATE MODEL\n", + "============================================================\n", + "\n", + "1. Linear Trend Dataset (single feature)\n" + ] + }, + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001B[31m---------------------------------------------------------------------------\u001B[39m", + "\u001B[31mKeyboardInterrupt\u001B[39m Traceback (most recent call last)", + "\u001B[36mCell\u001B[39m\u001B[36m \u001B[39m\u001B[32mIn[14]\u001B[39m\u001B[32m, line 15\u001B[39m\n\u001B[32m 6\u001B[39m \u001B[38;5;28mprint\u001B[39m(\u001B[33m\"\u001B[39m\u001B[38;5;130;01m\\n\u001B[39;00m\u001B[33m1. Linear Trend Dataset (single feature)\u001B[39m\u001B[33m\"\u001B[39m)\n\u001B[32m 7\u001B[39m request_linear_fs = FlowStateForecastRequest(\n\u001B[32m 8\u001B[39m x=linear_train,\n\u001B[32m 9\u001B[39m horizon=HORIZON,\n\u001B[32m (...)\u001B[39m\u001B[32m 12\u001B[39m output_type=\u001B[33m\"\u001B[39m\u001B[33mpoint\u001B[39m\u001B[33m\"\u001B[39m\n\u001B[32m 13\u001B[39m )\n\u001B[32m---> \u001B[39m\u001B[32m15\u001B[39m response_linear_fs = \u001B[43mclient\u001B[49m\u001B[43m.\u001B[49m\u001B[43mforecast\u001B[49m\u001B[43m(\u001B[49m\u001B[43mModelName\u001B[49m\u001B[43m.\u001B[49m\u001B[43mFLOWSTATE\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mrequest_linear_fs\u001B[49m\u001B[43m)\u001B[49m\n\u001B[32m 16\u001B[39m \u001B[38;5;28mprint\u001B[39m(\u001B[33mf\u001B[39m\u001B[33m\"\u001B[39m\u001B[33m Response shape: \u001B[39m\u001B[38;5;132;01m{\u001B[39;00mresponse_linear_fs.point.shape\u001B[38;5;132;01m}\u001B[39;00m\u001B[33m\"\u001B[39m)\n\u001B[32m 17\u001B[39m \u001B[38;5;28mprint\u001B[39m(\u001B[33mf\u001B[39m\u001B[33m\"\u001B[39m\u001B[33m Metadata: \u001B[39m\u001B[38;5;132;01m{\u001B[39;00mresponse_linear_fs.metadata\u001B[38;5;132;01m}\u001B[39;00m\u001B[33m\"\u001B[39m)\n", + "\u001B[36mFile \u001B[39m\u001B[32m~/Documents/Personal/research/FAIM/faim-client/faim_sdk/client.py:189\u001B[39m, in \u001B[36mForecastClient.forecast\u001B[39m\u001B[34m(self, model, request)\u001B[39m\n\u001B[32m 187\u001B[39m \u001B[38;5;66;03m# Make API call\u001B[39;00m\n\u001B[32m 188\u001B[39m \u001B[38;5;28;01mtry\u001B[39;00m:\n\u001B[32m--> \u001B[39m\u001B[32m189\u001B[39m response = \u001B[43mforecast_v1_ts_forecast_model_name_model_version_post\u001B[49m\u001B[43m.\u001B[49m\u001B[43msync_detailed\u001B[49m\u001B[43m(\u001B[49m\n\u001B[32m 190\u001B[39m \u001B[43m \u001B[49m\u001B[43mmodel_name\u001B[49m\u001B[43m=\u001B[49m\u001B[43mmodel\u001B[49m\u001B[43m,\u001B[49m\n\u001B[32m 191\u001B[39m \u001B[43m \u001B[49m\u001B[43mmodel_version\u001B[49m\u001B[43m=\u001B[49m\u001B[43mrequest\u001B[49m\u001B[43m.\u001B[49m\u001B[43mmodel_version\u001B[49m\u001B[43m,\u001B[49m\n\u001B[32m 192\u001B[39m \u001B[43m \u001B[49m\u001B[43mclient\u001B[49m\u001B[43m=\u001B[49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[43m.\u001B[49m\u001B[43m_client\u001B[49m\u001B[43m,\u001B[49m\n\u001B[32m 193\u001B[39m \u001B[43m \u001B[49m\u001B[43mbody\u001B[49m\u001B[43m=\u001B[49m\u001B[43mpayload_file\u001B[49m\u001B[43m,\u001B[49m\n\u001B[32m 194\u001B[39m \u001B[43m \u001B[49m\u001B[43m)\u001B[49m\n\u001B[32m 196\u001B[39m \u001B[38;5;28;01mexcept\u001B[39;00m \u001B[38;5;167;01mKeyError\u001B[39;00m \u001B[38;5;28;01mas\u001B[39;00m e:\n\u001B[32m 197\u001B[39m \u001B[38;5;66;03m# Backend returned error response with unexpected format\u001B[39;00m\n\u001B[32m 198\u001B[39m logger.error(\u001B[33mf\u001B[39m\u001B[33m\"\u001B[39m\u001B[33mFailed to parse error response: \u001B[39m\u001B[38;5;132;01m{\u001B[39;00me\u001B[38;5;132;01m}\u001B[39;00m\u001B[33m\"\u001B[39m)\n", + "\u001B[36mFile \u001B[39m\u001B[32m~/Documents/Personal/research/FAIM/faim-client/faim_client/api/forecast/forecast_v1_ts_forecast_model_name_model_version_post.py:246\u001B[39m, in \u001B[36msync_detailed\u001B[39m\u001B[34m(model_name, model_version, client, body)\u001B[39m\n\u001B[32m 107\u001B[39m \u001B[38;5;250m\u001B[39m\u001B[33mr\u001B[39m\u001B[33;03m\"\"\"Generate time series forecast\u001B[39;00m\n\u001B[32m 108\u001B[39m \n\u001B[32m 109\u001B[39m \u001B[33;03m Generate time series forecasts using the specified Triton model.\u001B[39;00m\n\u001B[32m (...)\u001B[39m\u001B[32m 237\u001B[39m \u001B[33;03m Response[Union[ErrorResponse, File]]\u001B[39;00m\n\u001B[32m 238\u001B[39m \u001B[33;03m\"\"\"\u001B[39;00m\n\u001B[32m 240\u001B[39m kwargs = _get_kwargs(\n\u001B[32m 241\u001B[39m model_name=model_name,\n\u001B[32m 242\u001B[39m model_version=model_version,\n\u001B[32m 243\u001B[39m body=body,\n\u001B[32m 244\u001B[39m )\n\u001B[32m--> \u001B[39m\u001B[32m246\u001B[39m response = \u001B[43mclient\u001B[49m\u001B[43m.\u001B[49m\u001B[43mget_httpx_client\u001B[49m\u001B[43m(\u001B[49m\u001B[43m)\u001B[49m\u001B[43m.\u001B[49m\u001B[43mrequest\u001B[49m\u001B[43m(\u001B[49m\n\u001B[32m 247\u001B[39m \u001B[43m \u001B[49m\u001B[43m*\u001B[49m\u001B[43m*\u001B[49m\u001B[43mkwargs\u001B[49m\u001B[43m,\u001B[49m\n\u001B[32m 248\u001B[39m \u001B[43m\u001B[49m\u001B[43m)\u001B[49m\n\u001B[32m 250\u001B[39m \u001B[38;5;28;01mreturn\u001B[39;00m _build_response(client=client, response=response)\n", + "\u001B[36mFile \u001B[39m\u001B[32m~/Documents/Personal/research/FAIM/faim-client/.venv/lib/python3.12/site-packages/httpx/_client.py:825\u001B[39m, in \u001B[36mClient.request\u001B[39m\u001B[34m(self, method, url, content, data, files, json, params, headers, cookies, auth, follow_redirects, timeout, extensions)\u001B[39m\n\u001B[32m 810\u001B[39m warnings.warn(message, \u001B[38;5;167;01mDeprecationWarning\u001B[39;00m, stacklevel=\u001B[32m2\u001B[39m)\n\u001B[32m 812\u001B[39m request = \u001B[38;5;28mself\u001B[39m.build_request(\n\u001B[32m 813\u001B[39m method=method,\n\u001B[32m 814\u001B[39m url=url,\n\u001B[32m (...)\u001B[39m\u001B[32m 823\u001B[39m extensions=extensions,\n\u001B[32m 824\u001B[39m )\n\u001B[32m--> \u001B[39m\u001B[32m825\u001B[39m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[38;5;28;43mself\u001B[39;49m\u001B[43m.\u001B[49m\u001B[43msend\u001B[49m\u001B[43m(\u001B[49m\u001B[43mrequest\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mauth\u001B[49m\u001B[43m=\u001B[49m\u001B[43mauth\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mfollow_redirects\u001B[49m\u001B[43m=\u001B[49m\u001B[43mfollow_redirects\u001B[49m\u001B[43m)\u001B[49m\n", + "\u001B[36mFile \u001B[39m\u001B[32m~/Documents/Personal/research/FAIM/faim-client/.venv/lib/python3.12/site-packages/httpx/_client.py:914\u001B[39m, in \u001B[36mClient.send\u001B[39m\u001B[34m(self, request, stream, auth, follow_redirects)\u001B[39m\n\u001B[32m 910\u001B[39m \u001B[38;5;28mself\u001B[39m._set_timeout(request)\n\u001B[32m 912\u001B[39m auth = \u001B[38;5;28mself\u001B[39m._build_request_auth(request, auth)\n\u001B[32m--> \u001B[39m\u001B[32m914\u001B[39m response = \u001B[38;5;28;43mself\u001B[39;49m\u001B[43m.\u001B[49m\u001B[43m_send_handling_auth\u001B[49m\u001B[43m(\u001B[49m\n\u001B[32m 915\u001B[39m \u001B[43m \u001B[49m\u001B[43mrequest\u001B[49m\u001B[43m,\u001B[49m\n\u001B[32m 916\u001B[39m \u001B[43m \u001B[49m\u001B[43mauth\u001B[49m\u001B[43m=\u001B[49m\u001B[43mauth\u001B[49m\u001B[43m,\u001B[49m\n\u001B[32m 917\u001B[39m \u001B[43m \u001B[49m\u001B[43mfollow_redirects\u001B[49m\u001B[43m=\u001B[49m\u001B[43mfollow_redirects\u001B[49m\u001B[43m,\u001B[49m\n\u001B[32m 918\u001B[39m \u001B[43m \u001B[49m\u001B[43mhistory\u001B[49m\u001B[43m=\u001B[49m\u001B[43m[\u001B[49m\u001B[43m]\u001B[49m\u001B[43m,\u001B[49m\n\u001B[32m 919\u001B[39m \u001B[43m\u001B[49m\u001B[43m)\u001B[49m\n\u001B[32m 920\u001B[39m \u001B[38;5;28;01mtry\u001B[39;00m:\n\u001B[32m 921\u001B[39m \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;129;01mnot\u001B[39;00m stream:\n", + "\u001B[36mFile \u001B[39m\u001B[32m~/Documents/Personal/research/FAIM/faim-client/.venv/lib/python3.12/site-packages/httpx/_client.py:942\u001B[39m, in \u001B[36mClient._send_handling_auth\u001B[39m\u001B[34m(self, request, auth, follow_redirects, history)\u001B[39m\n\u001B[32m 939\u001B[39m request = \u001B[38;5;28mnext\u001B[39m(auth_flow)\n\u001B[32m 941\u001B[39m \u001B[38;5;28;01mwhile\u001B[39;00m \u001B[38;5;28;01mTrue\u001B[39;00m:\n\u001B[32m--> \u001B[39m\u001B[32m942\u001B[39m response = \u001B[38;5;28;43mself\u001B[39;49m\u001B[43m.\u001B[49m\u001B[43m_send_handling_redirects\u001B[49m\u001B[43m(\u001B[49m\n\u001B[32m 943\u001B[39m \u001B[43m \u001B[49m\u001B[43mrequest\u001B[49m\u001B[43m,\u001B[49m\n\u001B[32m 944\u001B[39m \u001B[43m \u001B[49m\u001B[43mfollow_redirects\u001B[49m\u001B[43m=\u001B[49m\u001B[43mfollow_redirects\u001B[49m\u001B[43m,\u001B[49m\n\u001B[32m 945\u001B[39m \u001B[43m \u001B[49m\u001B[43mhistory\u001B[49m\u001B[43m=\u001B[49m\u001B[43mhistory\u001B[49m\u001B[43m,\u001B[49m\n\u001B[32m 946\u001B[39m \u001B[43m \u001B[49m\u001B[43m)\u001B[49m\n\u001B[32m 947\u001B[39m \u001B[38;5;28;01mtry\u001B[39;00m:\n\u001B[32m 948\u001B[39m \u001B[38;5;28;01mtry\u001B[39;00m:\n", + "\u001B[36mFile \u001B[39m\u001B[32m~/Documents/Personal/research/FAIM/faim-client/.venv/lib/python3.12/site-packages/httpx/_client.py:979\u001B[39m, in \u001B[36mClient._send_handling_redirects\u001B[39m\u001B[34m(self, request, follow_redirects, history)\u001B[39m\n\u001B[32m 976\u001B[39m \u001B[38;5;28;01mfor\u001B[39;00m hook \u001B[38;5;129;01min\u001B[39;00m \u001B[38;5;28mself\u001B[39m._event_hooks[\u001B[33m\"\u001B[39m\u001B[33mrequest\u001B[39m\u001B[33m\"\u001B[39m]:\n\u001B[32m 977\u001B[39m hook(request)\n\u001B[32m--> \u001B[39m\u001B[32m979\u001B[39m response = \u001B[38;5;28;43mself\u001B[39;49m\u001B[43m.\u001B[49m\u001B[43m_send_single_request\u001B[49m\u001B[43m(\u001B[49m\u001B[43mrequest\u001B[49m\u001B[43m)\u001B[49m\n\u001B[32m 980\u001B[39m \u001B[38;5;28;01mtry\u001B[39;00m:\n\u001B[32m 981\u001B[39m \u001B[38;5;28;01mfor\u001B[39;00m hook \u001B[38;5;129;01min\u001B[39;00m \u001B[38;5;28mself\u001B[39m._event_hooks[\u001B[33m\"\u001B[39m\u001B[33mresponse\u001B[39m\u001B[33m\"\u001B[39m]:\n", + "\u001B[36mFile \u001B[39m\u001B[32m~/Documents/Personal/research/FAIM/faim-client/.venv/lib/python3.12/site-packages/httpx/_client.py:1014\u001B[39m, in \u001B[36mClient._send_single_request\u001B[39m\u001B[34m(self, request)\u001B[39m\n\u001B[32m 1009\u001B[39m \u001B[38;5;28;01mraise\u001B[39;00m \u001B[38;5;167;01mRuntimeError\u001B[39;00m(\n\u001B[32m 1010\u001B[39m \u001B[33m\"\u001B[39m\u001B[33mAttempted to send an async request with a sync Client instance.\u001B[39m\u001B[33m\"\u001B[39m\n\u001B[32m 1011\u001B[39m )\n\u001B[32m 1013\u001B[39m \u001B[38;5;28;01mwith\u001B[39;00m request_context(request=request):\n\u001B[32m-> \u001B[39m\u001B[32m1014\u001B[39m response = \u001B[43mtransport\u001B[49m\u001B[43m.\u001B[49m\u001B[43mhandle_request\u001B[49m\u001B[43m(\u001B[49m\u001B[43mrequest\u001B[49m\u001B[43m)\u001B[49m\n\u001B[32m 1016\u001B[39m \u001B[38;5;28;01massert\u001B[39;00m \u001B[38;5;28misinstance\u001B[39m(response.stream, SyncByteStream)\n\u001B[32m 1018\u001B[39m response.request = request\n", + "\u001B[36mFile \u001B[39m\u001B[32m~/Documents/Personal/research/FAIM/faim-client/.venv/lib/python3.12/site-packages/httpx/_transports/default.py:250\u001B[39m, in \u001B[36mHTTPTransport.handle_request\u001B[39m\u001B[34m(self, request)\u001B[39m\n\u001B[32m 237\u001B[39m req = httpcore.Request(\n\u001B[32m 238\u001B[39m method=request.method,\n\u001B[32m 239\u001B[39m url=httpcore.URL(\n\u001B[32m (...)\u001B[39m\u001B[32m 247\u001B[39m extensions=request.extensions,\n\u001B[32m 248\u001B[39m )\n\u001B[32m 249\u001B[39m \u001B[38;5;28;01mwith\u001B[39;00m map_httpcore_exceptions():\n\u001B[32m--> \u001B[39m\u001B[32m250\u001B[39m resp = \u001B[38;5;28;43mself\u001B[39;49m\u001B[43m.\u001B[49m\u001B[43m_pool\u001B[49m\u001B[43m.\u001B[49m\u001B[43mhandle_request\u001B[49m\u001B[43m(\u001B[49m\u001B[43mreq\u001B[49m\u001B[43m)\u001B[49m\n\u001B[32m 252\u001B[39m \u001B[38;5;28;01massert\u001B[39;00m \u001B[38;5;28misinstance\u001B[39m(resp.stream, typing.Iterable)\n\u001B[32m 254\u001B[39m \u001B[38;5;28;01mreturn\u001B[39;00m Response(\n\u001B[32m 255\u001B[39m status_code=resp.status,\n\u001B[32m 256\u001B[39m headers=resp.headers,\n\u001B[32m 257\u001B[39m stream=ResponseStream(resp.stream),\n\u001B[32m 258\u001B[39m extensions=resp.extensions,\n\u001B[32m 259\u001B[39m )\n", + "\u001B[36mFile \u001B[39m\u001B[32m~/Documents/Personal/research/FAIM/faim-client/.venv/lib/python3.12/site-packages/httpcore/_sync/connection_pool.py:256\u001B[39m, in \u001B[36mConnectionPool.handle_request\u001B[39m\u001B[34m(self, request)\u001B[39m\n\u001B[32m 253\u001B[39m closing = \u001B[38;5;28mself\u001B[39m._assign_requests_to_connections()\n\u001B[32m 255\u001B[39m \u001B[38;5;28mself\u001B[39m._close_connections(closing)\n\u001B[32m--> \u001B[39m\u001B[32m256\u001B[39m \u001B[38;5;28;01mraise\u001B[39;00m exc \u001B[38;5;28;01mfrom\u001B[39;00m\u001B[38;5;250m \u001B[39m\u001B[38;5;28;01mNone\u001B[39;00m\n\u001B[32m 258\u001B[39m \u001B[38;5;66;03m# Return the response. Note that in this case we still have to manage\u001B[39;00m\n\u001B[32m 259\u001B[39m \u001B[38;5;66;03m# the point at which the response is closed.\u001B[39;00m\n\u001B[32m 260\u001B[39m \u001B[38;5;28;01massert\u001B[39;00m \u001B[38;5;28misinstance\u001B[39m(response.stream, typing.Iterable)\n", + "\u001B[36mFile \u001B[39m\u001B[32m~/Documents/Personal/research/FAIM/faim-client/.venv/lib/python3.12/site-packages/httpcore/_sync/connection_pool.py:236\u001B[39m, in \u001B[36mConnectionPool.handle_request\u001B[39m\u001B[34m(self, request)\u001B[39m\n\u001B[32m 232\u001B[39m connection = pool_request.wait_for_connection(timeout=timeout)\n\u001B[32m 234\u001B[39m \u001B[38;5;28;01mtry\u001B[39;00m:\n\u001B[32m 235\u001B[39m \u001B[38;5;66;03m# Send the request on the assigned connection.\u001B[39;00m\n\u001B[32m--> \u001B[39m\u001B[32m236\u001B[39m response = \u001B[43mconnection\u001B[49m\u001B[43m.\u001B[49m\u001B[43mhandle_request\u001B[49m\u001B[43m(\u001B[49m\n\u001B[32m 237\u001B[39m \u001B[43m \u001B[49m\u001B[43mpool_request\u001B[49m\u001B[43m.\u001B[49m\u001B[43mrequest\u001B[49m\n\u001B[32m 238\u001B[39m \u001B[43m \u001B[49m\u001B[43m)\u001B[49m\n\u001B[32m 239\u001B[39m \u001B[38;5;28;01mexcept\u001B[39;00m ConnectionNotAvailable:\n\u001B[32m 240\u001B[39m \u001B[38;5;66;03m# In some cases a connection may initially be available to\u001B[39;00m\n\u001B[32m 241\u001B[39m \u001B[38;5;66;03m# handle a request, but then become unavailable.\u001B[39;00m\n\u001B[32m 242\u001B[39m \u001B[38;5;66;03m#\u001B[39;00m\n\u001B[32m 243\u001B[39m \u001B[38;5;66;03m# In this case we clear the connection and try again.\u001B[39;00m\n\u001B[32m 244\u001B[39m pool_request.clear_connection()\n", + "\u001B[36mFile \u001B[39m\u001B[32m~/Documents/Personal/research/FAIM/faim-client/.venv/lib/python3.12/site-packages/httpcore/_sync/connection.py:103\u001B[39m, in \u001B[36mHTTPConnection.handle_request\u001B[39m\u001B[34m(self, request)\u001B[39m\n\u001B[32m 100\u001B[39m \u001B[38;5;28mself\u001B[39m._connect_failed = \u001B[38;5;28;01mTrue\u001B[39;00m\n\u001B[32m 101\u001B[39m \u001B[38;5;28;01mraise\u001B[39;00m exc\n\u001B[32m--> \u001B[39m\u001B[32m103\u001B[39m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[38;5;28;43mself\u001B[39;49m\u001B[43m.\u001B[49m\u001B[43m_connection\u001B[49m\u001B[43m.\u001B[49m\u001B[43mhandle_request\u001B[49m\u001B[43m(\u001B[49m\u001B[43mrequest\u001B[49m\u001B[43m)\u001B[49m\n", + "\u001B[36mFile \u001B[39m\u001B[32m~/Documents/Personal/research/FAIM/faim-client/.venv/lib/python3.12/site-packages/httpcore/_sync/http11.py:136\u001B[39m, in \u001B[36mHTTP11Connection.handle_request\u001B[39m\u001B[34m(self, request)\u001B[39m\n\u001B[32m 134\u001B[39m \u001B[38;5;28;01mwith\u001B[39;00m Trace(\u001B[33m\"\u001B[39m\u001B[33mresponse_closed\u001B[39m\u001B[33m\"\u001B[39m, logger, request) \u001B[38;5;28;01mas\u001B[39;00m trace:\n\u001B[32m 135\u001B[39m \u001B[38;5;28mself\u001B[39m._response_closed()\n\u001B[32m--> \u001B[39m\u001B[32m136\u001B[39m \u001B[38;5;28;01mraise\u001B[39;00m exc\n", + "\u001B[36mFile \u001B[39m\u001B[32m~/Documents/Personal/research/FAIM/faim-client/.venv/lib/python3.12/site-packages/httpcore/_sync/http11.py:106\u001B[39m, in \u001B[36mHTTP11Connection.handle_request\u001B[39m\u001B[34m(self, request)\u001B[39m\n\u001B[32m 95\u001B[39m \u001B[38;5;28;01mpass\u001B[39;00m\n\u001B[32m 97\u001B[39m \u001B[38;5;28;01mwith\u001B[39;00m Trace(\n\u001B[32m 98\u001B[39m \u001B[33m\"\u001B[39m\u001B[33mreceive_response_headers\u001B[39m\u001B[33m\"\u001B[39m, logger, request, kwargs\n\u001B[32m 99\u001B[39m ) \u001B[38;5;28;01mas\u001B[39;00m trace:\n\u001B[32m 100\u001B[39m (\n\u001B[32m 101\u001B[39m http_version,\n\u001B[32m 102\u001B[39m status,\n\u001B[32m 103\u001B[39m reason_phrase,\n\u001B[32m 104\u001B[39m headers,\n\u001B[32m 105\u001B[39m trailing_data,\n\u001B[32m--> \u001B[39m\u001B[32m106\u001B[39m ) = \u001B[38;5;28;43mself\u001B[39;49m\u001B[43m.\u001B[49m\u001B[43m_receive_response_headers\u001B[49m\u001B[43m(\u001B[49m\u001B[43m*\u001B[49m\u001B[43m*\u001B[49m\u001B[43mkwargs\u001B[49m\u001B[43m)\u001B[49m\n\u001B[32m 107\u001B[39m trace.return_value = (\n\u001B[32m 108\u001B[39m http_version,\n\u001B[32m 109\u001B[39m status,\n\u001B[32m 110\u001B[39m reason_phrase,\n\u001B[32m 111\u001B[39m headers,\n\u001B[32m 112\u001B[39m )\n\u001B[32m 114\u001B[39m network_stream = \u001B[38;5;28mself\u001B[39m._network_stream\n", + "\u001B[36mFile \u001B[39m\u001B[32m~/Documents/Personal/research/FAIM/faim-client/.venv/lib/python3.12/site-packages/httpcore/_sync/http11.py:177\u001B[39m, in \u001B[36mHTTP11Connection._receive_response_headers\u001B[39m\u001B[34m(self, request)\u001B[39m\n\u001B[32m 174\u001B[39m timeout = timeouts.get(\u001B[33m\"\u001B[39m\u001B[33mread\u001B[39m\u001B[33m\"\u001B[39m, \u001B[38;5;28;01mNone\u001B[39;00m)\n\u001B[32m 176\u001B[39m \u001B[38;5;28;01mwhile\u001B[39;00m \u001B[38;5;28;01mTrue\u001B[39;00m:\n\u001B[32m--> \u001B[39m\u001B[32m177\u001B[39m event = \u001B[38;5;28;43mself\u001B[39;49m\u001B[43m.\u001B[49m\u001B[43m_receive_event\u001B[49m\u001B[43m(\u001B[49m\u001B[43mtimeout\u001B[49m\u001B[43m=\u001B[49m\u001B[43mtimeout\u001B[49m\u001B[43m)\u001B[49m\n\u001B[32m 178\u001B[39m \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;28misinstance\u001B[39m(event, h11.Response):\n\u001B[32m 179\u001B[39m \u001B[38;5;28;01mbreak\u001B[39;00m\n", + "\u001B[36mFile \u001B[39m\u001B[32m~/Documents/Personal/research/FAIM/faim-client/.venv/lib/python3.12/site-packages/httpcore/_sync/http11.py:217\u001B[39m, in \u001B[36mHTTP11Connection._receive_event\u001B[39m\u001B[34m(self, timeout)\u001B[39m\n\u001B[32m 214\u001B[39m event = \u001B[38;5;28mself\u001B[39m._h11_state.next_event()\n\u001B[32m 216\u001B[39m \u001B[38;5;28;01mif\u001B[39;00m event \u001B[38;5;129;01mis\u001B[39;00m h11.NEED_DATA:\n\u001B[32m--> \u001B[39m\u001B[32m217\u001B[39m data = \u001B[38;5;28;43mself\u001B[39;49m\u001B[43m.\u001B[49m\u001B[43m_network_stream\u001B[49m\u001B[43m.\u001B[49m\u001B[43mread\u001B[49m\u001B[43m(\u001B[49m\n\u001B[32m 218\u001B[39m \u001B[43m \u001B[49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[43m.\u001B[49m\u001B[43mREAD_NUM_BYTES\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mtimeout\u001B[49m\u001B[43m=\u001B[49m\u001B[43mtimeout\u001B[49m\n\u001B[32m 219\u001B[39m \u001B[43m \u001B[49m\u001B[43m)\u001B[49m\n\u001B[32m 221\u001B[39m \u001B[38;5;66;03m# If we feed this case through h11 we'll raise an exception like:\u001B[39;00m\n\u001B[32m 222\u001B[39m \u001B[38;5;66;03m#\u001B[39;00m\n\u001B[32m 223\u001B[39m \u001B[38;5;66;03m# httpcore.RemoteProtocolError: can't handle event type\u001B[39;00m\n\u001B[32m (...)\u001B[39m\u001B[32m 227\u001B[39m \u001B[38;5;66;03m# perspective. Instead we handle this case distinctly and treat\u001B[39;00m\n\u001B[32m 228\u001B[39m \u001B[38;5;66;03m# it as a ConnectError.\u001B[39;00m\n\u001B[32m 229\u001B[39m \u001B[38;5;28;01mif\u001B[39;00m data == \u001B[33mb\u001B[39m\u001B[33m\"\u001B[39m\u001B[33m\"\u001B[39m \u001B[38;5;129;01mand\u001B[39;00m \u001B[38;5;28mself\u001B[39m._h11_state.their_state == h11.SEND_RESPONSE:\n", + "\u001B[36mFile \u001B[39m\u001B[32m~/Documents/Personal/research/FAIM/faim-client/.venv/lib/python3.12/site-packages/httpcore/_backends/sync.py:128\u001B[39m, in \u001B[36mSyncStream.read\u001B[39m\u001B[34m(self, max_bytes, timeout)\u001B[39m\n\u001B[32m 126\u001B[39m \u001B[38;5;28;01mwith\u001B[39;00m map_exceptions(exc_map):\n\u001B[32m 127\u001B[39m \u001B[38;5;28mself\u001B[39m._sock.settimeout(timeout)\n\u001B[32m--> \u001B[39m\u001B[32m128\u001B[39m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[38;5;28;43mself\u001B[39;49m\u001B[43m.\u001B[49m\u001B[43m_sock\u001B[49m\u001B[43m.\u001B[49m\u001B[43mrecv\u001B[49m\u001B[43m(\u001B[49m\u001B[43mmax_bytes\u001B[49m\u001B[43m)\u001B[49m\n", + "\u001B[36mFile \u001B[39m\u001B[32m~/.pyenv/versions/3.12.3/lib/python3.12/ssl.py:1233\u001B[39m, in \u001B[36mSSLSocket.recv\u001B[39m\u001B[34m(self, buflen, flags)\u001B[39m\n\u001B[32m 1229\u001B[39m \u001B[38;5;28;01mif\u001B[39;00m flags != \u001B[32m0\u001B[39m:\n\u001B[32m 1230\u001B[39m \u001B[38;5;28;01mraise\u001B[39;00m \u001B[38;5;167;01mValueError\u001B[39;00m(\n\u001B[32m 1231\u001B[39m \u001B[33m\"\u001B[39m\u001B[33mnon-zero flags not allowed in calls to recv() on \u001B[39m\u001B[38;5;132;01m%s\u001B[39;00m\u001B[33m\"\u001B[39m %\n\u001B[32m 1232\u001B[39m \u001B[38;5;28mself\u001B[39m.\u001B[34m__class__\u001B[39m)\n\u001B[32m-> \u001B[39m\u001B[32m1233\u001B[39m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[38;5;28;43mself\u001B[39;49m\u001B[43m.\u001B[49m\u001B[43mread\u001B[49m\u001B[43m(\u001B[49m\u001B[43mbuflen\u001B[49m\u001B[43m)\u001B[49m\n\u001B[32m 1234\u001B[39m \u001B[38;5;28;01melse\u001B[39;00m:\n\u001B[32m 1235\u001B[39m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[38;5;28msuper\u001B[39m().recv(buflen, flags)\n", + "\u001B[36mFile \u001B[39m\u001B[32m~/.pyenv/versions/3.12.3/lib/python3.12/ssl.py:1106\u001B[39m, in \u001B[36mSSLSocket.read\u001B[39m\u001B[34m(self, len, buffer)\u001B[39m\n\u001B[32m 1104\u001B[39m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[38;5;28mself\u001B[39m._sslobj.read(\u001B[38;5;28mlen\u001B[39m, buffer)\n\u001B[32m 1105\u001B[39m \u001B[38;5;28;01melse\u001B[39;00m:\n\u001B[32m-> \u001B[39m\u001B[32m1106\u001B[39m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[38;5;28;43mself\u001B[39;49m\u001B[43m.\u001B[49m\u001B[43m_sslobj\u001B[49m\u001B[43m.\u001B[49m\u001B[43mread\u001B[49m\u001B[43m(\u001B[49m\u001B[38;5;28;43mlen\u001B[39;49m\u001B[43m)\u001B[49m\n\u001B[32m 1107\u001B[39m \u001B[38;5;28;01mexcept\u001B[39;00m SSLError \u001B[38;5;28;01mas\u001B[39;00m x:\n\u001B[32m 1108\u001B[39m \u001B[38;5;28;01mif\u001B[39;00m x.args[\u001B[32m0\u001B[39m] == SSL_ERROR_EOF \u001B[38;5;129;01mand\u001B[39;00m \u001B[38;5;28mself\u001B[39m.suppress_ragged_eofs:\n", + "\u001B[31mKeyboardInterrupt\u001B[39m: " + ] + } + ], + "execution_count": 14 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-11-03T21:35:39.140343Z", + "start_time": "2025-11-03T21:35:39.134862Z" + } + }, + "cell_type": "code", + "source": "HORIZON", + "outputs": [ + { + "data": { + "text/plain": [ + "48" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 11 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 5.2 Chronos2 (Probabilistic Forecasts)" + ] + }, + { + "cell_type": "code", + "metadata": { + "ExecuteTime": { + "end_time": "2025-11-03T21:41:55.149090Z", + "start_time": "2025-11-03T21:41:24.860415Z" + } + }, + "source": [ + "print(\"=\" * 60)\n", + "print(\"CHRONOS2 MODEL\")\n", + "print(\"=\" * 60)\n", + "\n", + "# Quantile levels for probabilistic forecasting\n", + "QUANTILES = [0.1, 0.25, 0.5, 0.75, 0.9]\n", + "\n", + "# Linear trend dataset\n", + "print(\"\\n1. Linear Trend Dataset (single feature)\")\n", + "request_linear_c2 = Chronos2ForecastRequest(\n", + " x=linear_train,\n", + " horizon=HORIZON,\n", + " output_type=\"quantiles\",\n", + " quantiles=QUANTILES\n", + ")\n", + "\n", + "response_linear_c2 = client.forecast(ModelName.CHRONOS2, request_linear_c2)\n", + "print(response_linear_c2.point)\n", + "print(f\" Response shape: {response_linear_c2.quantiles.shape}\")\n", + "print(f\" Metadata: {response_linear_c2.metadata}\")\n", + "\n", + "# Evaluate point forecast (use median)\n", + "point_linear_c2 = response_linear_c2.quantiles[:, :, 2:3] # Median (0.5 quantile), keep 3D\n", + "mse_linear_c2 = mse(linear_test, point_linear_c2)\n", + "mase_linear_c2 = mase(linear_test, point_linear_c2, linear_train)\n", + "crps_linear_c2 = crps_from_quantiles(linear_test, response_linear_c2.quantiles, QUANTILES)\n", + "print(f\" MSE (median): {mse_linear_c2:.4f}\")\n", + "print(f\" MASE (median): {mase_linear_c2:.4f}\")\n", + "print(f\" CRPS: {crps_linear_c2:.4f}\")\n", + "\n", + "# Multi-series dataset\n", + "print(\"\\n2. Correlated Multi-Series Dataset (2 features)\")\n", + "request_multi_c2 = Chronos2ForecastRequest(\n", + " x=multi_train,\n", + " horizon=HORIZON,\n", + " output_type=\"quantiles\",\n", + " quantiles=QUANTILES\n", + ")\n", + "\n", + "response_multi_c2 = client.forecast(ModelName.CHRONOS2, request_multi_c2)\n", + "print(f\" Response shape: {response_multi_c2.quantiles.shape}\")\n", + "print(f\" Metadata: {response_multi_c2.metadata}\")\n", + "\n", + "# Evaluate point forecast (use median)\n", + "point_multi_c2 = response_multi_c2.quantiles[:, :, 2:3] # Median, keep 3D\n", + "mse_multi_c2 = mse(multi_test, point_multi_c2)\n", + "mase_multi_c2 = mase(multi_test, point_multi_c2, multi_train)\n", + "# Note: CRPS expects single feature, so we'll compute per feature\n", + "crps_multi_c2_f1 = crps_from_quantiles(multi_test[:, :, 0:1], response_multi_c2.quantiles, QUANTILES)\n", + "crps_multi_c2_f2 = crps_from_quantiles(multi_test[:, :, 1:2], response_multi_c2.quantiles, QUANTILES)\n", + "print(f\" MSE (median): {mse_multi_c2:.4f}\")\n", + "print(f\" MASE (median): {mase_multi_c2:.4f}\")\n", + "print(f\" CRPS (feature 1): {crps_multi_c2_f1:.4f}\")\n", + "print(f\" CRPS (feature 2): {crps_multi_c2_f2:.4f}\")\n", + "\n", + "print(\"\\n✓ Chronos2 forecasts complete\")" + ], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "============================================================\n", + "CHRONOS2 MODEL\n", + "============================================================\n", + "\n", + "1. Linear Trend Dataset (single feature)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Failed to parse error response: Expecting value: line 2 column 1 (char 1)\n", + "API error: status=502, no error_response\n" + ] + }, + { + "ename": "APIError", + "evalue": "Request failed with status 502 | status=502", + "output_type": "error", + "traceback": [ + "\u001B[31m---------------------------------------------------------------------------\u001B[39m", + "\u001B[31mAPIError\u001B[39m Traceback (most recent call last)", + "\u001B[36mCell\u001B[39m\u001B[36m \u001B[39m\u001B[32mIn[17]\u001B[39m\u001B[32m, line 17\u001B[39m\n\u001B[32m 9\u001B[39m \u001B[38;5;28mprint\u001B[39m(\u001B[33m\"\u001B[39m\u001B[38;5;130;01m\\n\u001B[39;00m\u001B[33m1. Linear Trend Dataset (single feature)\u001B[39m\u001B[33m\"\u001B[39m)\n\u001B[32m 10\u001B[39m request_linear_c2 = Chronos2ForecastRequest(\n\u001B[32m 11\u001B[39m x=linear_train,\n\u001B[32m 12\u001B[39m horizon=HORIZON,\n\u001B[32m 13\u001B[39m output_type=\u001B[33m\"\u001B[39m\u001B[33mquantiles\u001B[39m\u001B[33m\"\u001B[39m,\n\u001B[32m 14\u001B[39m quantiles=QUANTILES\n\u001B[32m 15\u001B[39m )\n\u001B[32m---> \u001B[39m\u001B[32m17\u001B[39m response_linear_c2 = \u001B[43mclient\u001B[49m\u001B[43m.\u001B[49m\u001B[43mforecast\u001B[49m\u001B[43m(\u001B[49m\u001B[43mModelName\u001B[49m\u001B[43m.\u001B[49m\u001B[43mCHRONOS2\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mrequest_linear_c2\u001B[49m\u001B[43m)\u001B[49m\n\u001B[32m 18\u001B[39m \u001B[38;5;28mprint\u001B[39m(response_linear_c2.point)\n\u001B[32m 19\u001B[39m \u001B[38;5;28mprint\u001B[39m(\u001B[33mf\u001B[39m\u001B[33m\"\u001B[39m\u001B[33m Response shape: \u001B[39m\u001B[38;5;132;01m{\u001B[39;00mresponse_linear_c2.quantiles.shape\u001B[38;5;132;01m}\u001B[39;00m\u001B[33m\"\u001B[39m)\n", + "\u001B[36mFile \u001B[39m\u001B[32m~/Documents/Personal/research/FAIM/faim-client/faim_sdk/client.py:296\u001B[39m, in \u001B[36mForecastClient.forecast\u001B[39m\u001B[34m(self, model, request)\u001B[39m\n\u001B[32m 289\u001B[39m \u001B[38;5;28;01mraise\u001B[39;00m ServiceUnavailableError(\n\u001B[32m 290\u001B[39m message=message,\n\u001B[32m 291\u001B[39m status_code=response.status_code,\n\u001B[32m 292\u001B[39m error_response=error_response,\n\u001B[32m 293\u001B[39m )\n\u001B[32m 294\u001B[39m \u001B[38;5;28;01melse\u001B[39;00m:\n\u001B[32m 295\u001B[39m \u001B[38;5;66;03m# Fallback for unmapped status codes\u001B[39;00m\n\u001B[32m--> \u001B[39m\u001B[32m296\u001B[39m \u001B[38;5;28;01mraise\u001B[39;00m APIError(\n\u001B[32m 297\u001B[39m message=message,\n\u001B[32m 298\u001B[39m status_code=response.status_code,\n\u001B[32m 299\u001B[39m error_response=error_response,\n\u001B[32m 300\u001B[39m )\n\u001B[32m 302\u001B[39m \u001B[38;5;66;03m# Deserialize successful response\u001B[39;00m\n\u001B[32m 303\u001B[39m \u001B[38;5;28;01mtry\u001B[39;00m:\n", + "\u001B[31mAPIError\u001B[39m: Request failed with status 502 | status=502" + ] + } + ], + "execution_count": 17 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-11-03T21:35:47.146150Z", + "start_time": "2025-11-03T21:35:47.129053Z" + } + }, + "cell_type": "code", + "source": "response_linear_c2", + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'response_linear_c2' is not defined", + "output_type": "error", + "traceback": [ + "\u001B[31m---------------------------------------------------------------------------\u001B[39m", + "\u001B[31mNameError\u001B[39m Traceback (most recent call last)", + "\u001B[36mCell\u001B[39m\u001B[36m \u001B[39m\u001B[32mIn[13]\u001B[39m\u001B[32m, line 1\u001B[39m\n\u001B[32m----> \u001B[39m\u001B[32m1\u001B[39m \u001B[43mresponse_linear_c2\u001B[49m\n", + "\u001B[31mNameError\u001B[39m: name 'response_linear_c2' is not defined" + ] + } + ], + "execution_count": 13 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 5.3 TiRex (Point Forecasts)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(\"=\" * 60)\n", + "print(\"TIREX MODEL\")\n", + "print(\"=\" * 60)\n", + "\n", + "# Linear trend dataset\n", + "print(\"\\n1. Linear Trend Dataset (single feature)\")\n", + "request_linear_tr = TiRexForecastRequest(\n", + " x=linear_train,\n", + " horizon=HORIZON,\n", + " output_type=\"point\"\n", + ")\n", + "\n", + "response_linear_tr = client.forecast(ModelName.TIREX, request_linear_tr)\n", + "print(f\" Response shape: {response_linear_tr.point.shape}\")\n", + "print(f\" Metadata: {response_linear_tr.metadata}\")\n", + "\n", + "# Evaluate\n", + "mse_linear_tr = mse(linear_test, response_linear_tr.point)\n", + "mase_linear_tr = mase(linear_test, response_linear_tr.point, linear_train)\n", + "print(f\" MSE: {mse_linear_tr:.4f}\")\n", + "print(f\" MASE: {mase_linear_tr:.4f}\")\n", + "\n", + "# Multi-series dataset\n", + "print(\"\\n2. Correlated Multi-Series Dataset (2 features)\")\n", + "request_multi_tr = TiRexForecastRequest(\n", + " x=multi_train,\n", + " horizon=HORIZON,\n", + " output_type=\"point\"\n", + ")\n", + "\n", + "response_multi_tr = client.forecast(ModelName.TIREX, request_multi_tr)\n", + "print(f\" Response shape: {response_multi_tr.point.shape}\")\n", + "print(f\" Metadata: {response_multi_tr.metadata}\")\n", + "\n", + "# Evaluate\n", + "mse_multi_tr = mse(multi_test, response_multi_tr.point)\n", + "mase_multi_tr = mase(multi_test, response_multi_tr.point, multi_train)\n", + "print(f\" MSE: {mse_multi_tr:.4f}\")\n", + "print(f\" MASE: {mase_multi_tr:.4f}\")\n", + "\n", + "print(\"\\n✓ TiRex forecasts complete\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 6. Model Comparison Summary" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Create comparison table\n", + "comparison_data = {\n", + " \"Model\": [\"FlowState\", \"Chronos2\", \"TiRex\"],\n", + " \"Linear_MSE\": [mse_linear_fs, mse_linear_c2, mse_linear_tr],\n", + " \"Linear_MASE\": [mase_linear_fs, mase_linear_c2, mase_linear_tr],\n", + " \"Linear_CRPS\": [\"-\", crps_linear_c2, \"-\"],\n", + " \"Multi_MSE\": [mse_multi_fs, mse_multi_c2, mse_multi_tr],\n", + " \"Multi_MASE\": [mase_multi_fs, mase_multi_c2, mase_multi_tr],\n", + "}\n", + "\n", + "comparison_df = pd.DataFrame(comparison_data)\n", + "\n", + "print(\"\\n\" + \"=\" * 80)\n", + "print(\"MODEL COMPARISON SUMMARY\")\n", + "print(\"=\" * 80)\n", + "print(\"\\nLinear Trend Dataset (Single Feature):\")\n", + "print(comparison_df[[\"Model\", \"Linear_MSE\", \"Linear_MASE\", \"Linear_CRPS\"]].to_string(index=False))\n", + "\n", + "print(\"\\n\\nCorrelated Multi-Series Dataset (2 Features):\")\n", + "print(comparison_df[[\"Model\", \"Multi_MSE\", \"Multi_MASE\"]].to_string(index=False))\n", + "\n", + "# Identify best models\n", + "print(\"\\n\\n\" + \"=\" * 80)\n", + "print(\"BEST MODELS BY METRIC\")\n", + "print(\"=\" * 80)\n", + "\n", + "# Linear dataset\n", + "best_linear_mse_idx = np.argmin([mse_linear_fs, mse_linear_c2, mse_linear_tr])\n", + "best_linear_mase_idx = np.argmin([mase_linear_fs, mase_linear_c2, mase_linear_tr])\n", + "models = [\"FlowState\", \"Chronos2\", \"TiRex\"]\n", + "\n", + "print(\"\\nLinear Trend Dataset:\")\n", + "print(f\" Best MSE: {models[best_linear_mse_idx]} ({[mse_linear_fs, mse_linear_c2, mse_linear_tr][best_linear_mse_idx]:.4f})\")\n", + "print(f\" Best MASE: {models[best_linear_mase_idx]} ({[mase_linear_fs, mase_linear_c2, mase_linear_tr][best_linear_mase_idx]:.4f})\")\n", + "\n", + "# Multi-series dataset\n", + "best_multi_mse_idx = np.argmin([mse_multi_fs, mse_multi_c2, mse_multi_tr])\n", + "best_multi_mase_idx = np.argmin([mase_multi_fs, mase_multi_c2, mase_multi_tr])\n", + "\n", + "print(\"\\nCorrelated Multi-Series Dataset:\")\n", + "print(f\" Best MSE: {models[best_multi_mse_idx]} ({[mse_multi_fs, mse_multi_c2, mse_multi_tr][best_multi_mse_idx]:.4f})\")\n", + "print(f\" Best MASE: {models[best_multi_mase_idx]} ({[mase_multi_fs, mase_multi_c2, mase_multi_tr][best_multi_mase_idx]:.4f})\")\n", + "\n", + "print(\"\\n\" + \"=\" * 80)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 7. Visualize Forecasts - Linear Trend Dataset" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Pick a sample to visualize (index 0)\n", + "sample_idx = 0\n", + "\n", + "fig, axes = plt.subplots(3, 1, figsize=(14, 12))\n", + "\n", + "# FlowState\n", + "axes[0].plot(np.arange(CONTEXT_LENGTH), linear_train[sample_idx, :, 0], \n", + " label=\"Training Data\", color=\"blue\", linewidth=2)\n", + "axes[0].plot(np.arange(CONTEXT_LENGTH, CONTEXT_LENGTH + HORIZON), linear_test[sample_idx, :, 0], \n", + " label=\"Ground Truth\", color=\"green\", linewidth=2, linestyle=\"--\")\n", + "axes[0].plot(np.arange(CONTEXT_LENGTH, CONTEXT_LENGTH + HORIZON), response_linear_fs.point[sample_idx, :, 0], \n", + " label=\"FlowState Forecast\", color=\"red\", linewidth=2, marker=\"o\", markersize=3)\n", + "axes[0].axvline(x=CONTEXT_LENGTH, color=\"gray\", linestyle=\":\", alpha=0.5)\n", + "axes[0].set_title(f\"FlowState - Linear Trend Forecast (MSE: {mse_linear_fs:.4f}, MASE: {mase_linear_fs:.4f})\", fontweight=\"bold\")\n", + "axes[0].set_xlabel(\"Time Step\")\n", + "axes[0].set_ylabel(\"Value\")\n", + "axes[0].legend(loc=\"best\")\n", + "axes[0].grid(True, alpha=0.3)\n", + "\n", + "# Chronos2 (with uncertainty bands)\n", + "axes[1].plot(np.arange(CONTEXT_LENGTH), linear_train[sample_idx, :, 0], \n", + " label=\"Training Data\", color=\"blue\", linewidth=2)\n", + "axes[1].plot(np.arange(CONTEXT_LENGTH, CONTEXT_LENGTH + HORIZON), linear_test[sample_idx, :, 0], \n", + " label=\"Ground Truth\", color=\"green\", linewidth=2, linestyle=\"--\")\n", + "axes[1].plot(np.arange(CONTEXT_LENGTH, CONTEXT_LENGTH + HORIZON), response_linear_c2.quantiles[sample_idx, :, 2], \n", + " label=\"Chronos2 Median\", color=\"red\", linewidth=2, marker=\"o\", markersize=3)\n", + "# Add uncertainty bands\n", + "axes[1].fill_between(\n", + " np.arange(CONTEXT_LENGTH, CONTEXT_LENGTH + HORIZON),\n", + " response_linear_c2.quantiles[sample_idx, :, 0], # 10th percentile\n", + " response_linear_c2.quantiles[sample_idx, :, 4], # 90th percentile\n", + " alpha=0.2, color=\"red\", label=\"10th-90th Percentile\"\n", + ")\n", + "axes[1].axvline(x=CONTEXT_LENGTH, color=\"gray\", linestyle=\":\", alpha=0.5)\n", + "axes[1].set_title(f\"Chronos2 - Probabilistic Forecast (MSE: {mse_linear_c2:.4f}, MASE: {mase_linear_c2:.4f}, CRPS: {crps_linear_c2:.4f})\", fontweight=\"bold\")\n", + "axes[1].set_xlabel(\"Time Step\")\n", + "axes[1].set_ylabel(\"Value\")\n", + "axes[1].legend(loc=\"best\")\n", + "axes[1].grid(True, alpha=0.3)\n", + "\n", + "# TiRex\n", + "axes[2].plot(np.arange(CONTEXT_LENGTH), linear_train[sample_idx, :, 0], \n", + " label=\"Training Data\", color=\"blue\", linewidth=2)\n", + "axes[2].plot(np.arange(CONTEXT_LENGTH, CONTEXT_LENGTH + HORIZON), linear_test[sample_idx, :, 0], \n", + " label=\"Ground Truth\", color=\"green\", linewidth=2, linestyle=\"--\")\n", + "axes[2].plot(np.arange(CONTEXT_LENGTH, CONTEXT_LENGTH + HORIZON), response_linear_tr.point[sample_idx, :, 0], \n", + " label=\"TiRex Forecast\", color=\"red\", linewidth=2, marker=\"o\", markersize=3)\n", + "axes[2].axvline(x=CONTEXT_LENGTH, color=\"gray\", linestyle=\":\", alpha=0.5)\n", + "axes[2].set_title(f\"TiRex - Linear Trend Forecast (MSE: {mse_linear_tr:.4f}, MASE: {mase_linear_tr:.4f})\", fontweight=\"bold\")\n", + "axes[2].set_xlabel(\"Time Step\")\n", + "axes[2].set_ylabel(\"Value\")\n", + "axes[2].legend(loc=\"best\")\n", + "axes[2].grid(True, alpha=0.3)\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "print(\"✓ Linear trend visualization complete\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 8. Visualize Forecasts - Multi-Series Dataset" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Pick a sample to visualize (index 0)\n", + "sample_idx = 0\n", + "\n", + "fig, axes = plt.subplots(3, 2, figsize=(16, 12))\n", + "\n", + "# FlowState - Feature 1 and 2\n", + "for feat_idx in range(2):\n", + " ax = axes[0, feat_idx]\n", + " ax.plot(np.arange(CONTEXT_LENGTH), multi_train[sample_idx, :, feat_idx], \n", + " label=\"Training Data\", color=\"blue\", linewidth=2)\n", + " ax.plot(np.arange(CONTEXT_LENGTH, CONTEXT_LENGTH + HORIZON), multi_test[sample_idx, :, feat_idx], \n", + " label=\"Ground Truth\", color=\"green\", linewidth=2, linestyle=\"--\")\n", + " ax.plot(np.arange(CONTEXT_LENGTH, CONTEXT_LENGTH + HORIZON), response_multi_fs.point[sample_idx, :, feat_idx], \n", + " label=\"FlowState Forecast\", color=\"red\", linewidth=2, marker=\"o\", markersize=3)\n", + " ax.axvline(x=CONTEXT_LENGTH, color=\"gray\", linestyle=\":\", alpha=0.5)\n", + " ax.set_title(f\"FlowState - Feature {feat_idx+1}\", fontweight=\"bold\")\n", + " ax.set_xlabel(\"Time Step\")\n", + " ax.set_ylabel(\"Value\")\n", + " ax.legend(loc=\"best\")\n", + " ax.grid(True, alpha=0.3)\n", + "\n", + "# Chronos2 - Feature 1 and 2\n", + "for feat_idx in range(2):\n", + " ax = axes[1, feat_idx]\n", + " ax.plot(np.arange(CONTEXT_LENGTH), multi_train[sample_idx, :, feat_idx], \n", + " label=\"Training Data\", color=\"blue\", linewidth=2)\n", + " ax.plot(np.arange(CONTEXT_LENGTH, CONTEXT_LENGTH + HORIZON), multi_test[sample_idx, :, feat_idx], \n", + " label=\"Ground Truth\", color=\"green\", linewidth=2, linestyle=\"--\")\n", + " ax.plot(np.arange(CONTEXT_LENGTH, CONTEXT_LENGTH + HORIZON), response_multi_c2.quantiles[sample_idx, :, 2], \n", + " label=\"Chronos2 Median\", color=\"red\", linewidth=2, marker=\"o\", markersize=3)\n", + " # Add uncertainty bands\n", + " ax.fill_between(\n", + " np.arange(CONTEXT_LENGTH, CONTEXT_LENGTH + HORIZON),\n", + " response_multi_c2.quantiles[sample_idx, :, 0],\n", + " response_multi_c2.quantiles[sample_idx, :, 4],\n", + " alpha=0.2, color=\"red\", label=\"10th-90th Percentile\"\n", + " )\n", + " ax.axvline(x=CONTEXT_LENGTH, color=\"gray\", linestyle=\":\", alpha=0.5)\n", + " ax.set_title(f\"Chronos2 - Feature {feat_idx+1}\", fontweight=\"bold\")\n", + " ax.set_xlabel(\"Time Step\")\n", + " ax.set_ylabel(\"Value\")\n", + " ax.legend(loc=\"best\")\n", + " ax.grid(True, alpha=0.3)\n", + "\n", + "# TiRex - Feature 1 and 2\n", + "for feat_idx in range(2):\n", + " ax = axes[2, feat_idx]\n", + " ax.plot(np.arange(CONTEXT_LENGTH), multi_train[sample_idx, :, feat_idx], \n", + " label=\"Training Data\", color=\"blue\", linewidth=2)\n", + " ax.plot(np.arange(CONTEXT_LENGTH, CONTEXT_LENGTH + HORIZON), multi_test[sample_idx, :, feat_idx], \n", + " label=\"Ground Truth\", color=\"green\", linewidth=2, linestyle=\"--\")\n", + " ax.plot(np.arange(CONTEXT_LENGTH, CONTEXT_LENGTH + HORIZON), response_multi_tr.point[sample_idx, :, feat_idx], \n", + " label=\"TiRex Forecast\", color=\"red\", linewidth=2, marker=\"o\", markersize=3)\n", + " ax.axvline(x=CONTEXT_LENGTH, color=\"gray\", linestyle=\":\", alpha=0.5)\n", + " ax.set_title(f\"TiRex - Feature {feat_idx+1}\", fontweight=\"bold\")\n", + " ax.set_xlabel(\"Time Step\")\n", + " ax.set_ylabel(\"Value\")\n", + " ax.legend(loc=\"best\")\n", + " ax.grid(True, alpha=0.3)\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "print(\"✓ Multi-series visualization complete\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 9. Per-Sample Error Analysis" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Calculate per-sample errors for linear dataset\n", + "mse_per_sample_fs = mse(linear_test, response_linear_fs.point, reduction='none')\n", + "mse_per_sample_c2 = mse(linear_test, point_linear_c2, reduction='none')\n", + "mse_per_sample_tr = mse(linear_test, response_linear_tr.point, reduction='none')\n", + "\n", + "# Visualize per-sample errors\n", + "fig, axes = plt.subplots(1, 2, figsize=(14, 5))\n", + "\n", + "# Bar plot\n", + "x = np.arange(BATCH_SIZE)\n", + "width = 0.25\n", + "axes[0].bar(x - width, mse_per_sample_fs, width, label='FlowState', alpha=0.8)\n", + "axes[0].bar(x, mse_per_sample_c2, width, label='Chronos2', alpha=0.8)\n", + "axes[0].bar(x + width, mse_per_sample_tr, width, label='TiRex', alpha=0.8)\n", + "axes[0].set_xlabel('Sample Index')\n", + "axes[0].set_ylabel('MSE')\n", + "axes[0].set_title('Per-Sample MSE Comparison (Linear Trend)', fontweight='bold')\n", + "axes[0].set_xticks(x)\n", + "axes[0].legend()\n", + "axes[0].grid(True, alpha=0.3, axis='y')\n", + "\n", + "# Box plot\n", + "axes[1].boxplot([mse_per_sample_fs, mse_per_sample_c2, mse_per_sample_tr],\n", + " labels=['FlowState', 'Chronos2', 'TiRex'])\n", + "axes[1].set_ylabel('MSE')\n", + "axes[1].set_title('MSE Distribution Across Samples', fontweight='bold')\n", + "axes[1].grid(True, alpha=0.3, axis='y')\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "print(\"\\nPer-Sample Statistics (Linear Trend):\")\n", + "print(f\"FlowState - Mean: {mse_per_sample_fs.mean():.4f}, Std: {mse_per_sample_fs.std():.4f}, Min: {mse_per_sample_fs.min():.4f}, Max: {mse_per_sample_fs.max():.4f}\")\n", + "print(f\"Chronos2 - Mean: {mse_per_sample_c2.mean():.4f}, Std: {mse_per_sample_c2.std():.4f}, Min: {mse_per_sample_c2.min():.4f}, Max: {mse_per_sample_c2.max():.4f}\")\n", + "print(f\"TiRex - Mean: {mse_per_sample_tr.mean():.4f}, Std: {mse_per_sample_tr.std():.4f}, Min: {mse_per_sample_tr.min():.4f}, Max: {mse_per_sample_tr.max():.4f}\")\n", + "\n", + "print(\"\\n✓ Per-sample error analysis complete\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 10. Key Insights and Conclusions" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(\"\\n\" + \"=\"*80)\n", + "print(\"KEY INSIGHTS\")\n", + "print(\"=\"*80)\n", + "\n", + "print(\"\\n1. Model Performance:\")\n", + "print(\" - All models successfully handled both single and multi-feature datasets\")\n", + "print(f\" - Best overall for linear trend: {models[best_linear_mse_idx]}\")\n", + "print(f\" - Best overall for multi-series: {models[best_multi_mse_idx]}\")\n", + "\n", + "print(\"\\n2. Probabilistic Forecasting:\")\n", + "print(f\" - Chronos2 provided uncertainty quantification with CRPS: {crps_linear_c2:.4f}\")\n", + "print(\" - Uncertainty bands captured ground truth well in most samples\")\n", + "\n", + "print(\"\\n3. Metrics Comparison:\")\n", + "print(\" - MSE: Measures average squared error (sensitive to outliers)\")\n", + "print(\" - MASE: Scale-independent, compares to naive baseline\")\n", + "print(\" - CRPS: Evaluates probabilistic forecast quality\")\n", + "\n", + "print(\"\\n4. Recommendations:\")\n", + "print(\" - Use FlowState for: Fast point forecasts with known patterns\")\n", + "print(\" - Use Chronos2 for: Uncertainty quantification and probabilistic forecasts\")\n", + "print(\" - Use TiRex for: Efficient transformer-based forecasting\")\n", + "\n", + "print(\"\\n\" + \"=\"*80)\n", + "print(\"✓ Model comparison complete!\")\n", + "print(\"=\"*80)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.11.0" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/faim_sdk/eval/__init__.py b/faim_sdk/eval/__init__.py new file mode 100644 index 0000000..6512f48 --- /dev/null +++ b/faim_sdk/eval/__init__.py @@ -0,0 +1,76 @@ +"""Evaluation tools for time-series forecasting. + +This subpackage provides metrics and visualization utilities for evaluating +forecast quality. All functions work seamlessly with FAIM SDK responses. + +Modules: + - metrics: MSE, MASE, and CRPS metrics for forecast evaluation + - visualization: plot_forecast for visualizing forecasts + +Quick Start - Metrics: + >>> from faim_sdk import ForecastClient, Chronos2ForecastRequest + >>> from faim_sdk.eval import mse, mase, crps_from_quantiles + >>> from faim_client.models import ModelName + >>> import numpy as np + >>> + >>> # Generate forecast + >>> client = ForecastClient(base_url="https://api.example.com") + >>> request = Chronos2ForecastRequest( + ... x=train_data, # (32, 100, 1) + ... horizon=24, + ... output_type="quantiles", + ... quantiles=[0.1, 0.5, 0.9] + ... ) + >>> response = client.forecast(ModelName.CHRONOS2, request) + >>> + >>> # Evaluate point forecast (use median) + >>> point_pred = response.quantiles[:, :, 1:2] # Keep 3D shape + >>> mse_score = mse(test_data, point_pred) + >>> mase_score = mase(test_data, point_pred, train_data) + >>> + >>> # Evaluate probabilistic forecast + >>> crps_score = crps_from_quantiles( + ... test_data, + ... response.quantiles, + ... quantile_levels=[0.1, 0.5, 0.9] + ... ) + +Quick Start - Visualization: + >>> from faim_sdk.eval import plot_forecast + >>> + >>> # Plot single sample (remember to index batch dimension!) + >>> fig, ax = plot_forecast( + ... train_data=train_data[0], # (100, 1) - 2D array + ... forecast=response.point[0], # (24, 1) - 2D array + ... test_data=test_data[0], # (24, 1) - 2D array + ... title="Forecast Visualization" + ... ) + >>> fig.savefig("forecast.png") + +Available Metrics: + - mse: Mean Squared Error (point forecasts) + - mase: Mean Absolute Scaled Error (scale-independent) + - crps_from_quantiles: Continuous Ranked Probability Score (probabilistic) + +Available Visualization: + - plot_forecast: Plot training data, forecast, and optional test data + +Installation: + For visualization support, install with the viz extra: + pip install faim-sdk[viz] + + Or install matplotlib separately: + pip install matplotlib +""" + +from .metrics import crps_from_quantiles, mase, mse +from .visualization import plot_forecast + +__all__ = [ + # Metrics + "mse", + "mase", + "crps_from_quantiles", + # Visualization + "plot_forecast", +] \ No newline at end of file diff --git a/faim_sdk/eval/metrics.py b/faim_sdk/eval/metrics.py new file mode 100644 index 0000000..9801043 --- /dev/null +++ b/faim_sdk/eval/metrics.py @@ -0,0 +1,566 @@ +"""Evaluation metrics for time-series forecasting. + +This module provides production-ready implementations of standard forecasting +evaluation metrics. All functions support batch processing and flexible +aggregation options. + +All metric functions expect 3D input arrays with shape: + (batch_size, horizon, features) + +Typical Usage: + >>> from faim_sdk import ForecastClient, Chronos2ForecastRequest + >>> from faim_sdk.eval import mse, mase, crps_from_quantiles + >>> from faim_client.models import ModelName + >>> import numpy as np + >>> + >>> # Generate forecast + >>> client = ForecastClient(base_url="https://api.example.com") + >>> request = Chronos2ForecastRequest( + ... x=train_data, # shape: (32, 100, 1) + ... horizon=24, + ... output_type="quantiles", + ... quantiles=[0.1, 0.5, 0.9] + ... ) + >>> response = client.forecast(ModelName.CHRONOS2, request) + >>> + >>> # Evaluate point forecasts (use median as point forecast) + >>> point_pred = response.quantiles[:, :, 1:2] # (32, 24, 1) - keep 3D shape + >>> mse_score = mse(test_data, point_pred, reduction='mean') + >>> mase_score = mase(test_data, point_pred, train_data, reduction='mean') + >>> + >>> # Evaluate probabilistic forecasts + >>> crps_score = crps_from_quantiles( + ... test_data, + ... response.quantiles, + ... quantile_levels=[0.1, 0.5, 0.9], + ... reduction='mean' + ... ) + +Available Metrics: + - mse: Mean Squared Error (point forecasts) + - mase: Mean Absolute Scaled Error (point forecasts, scale-independent) + - crps_from_quantiles: Continuous Ranked Probability Score (probabilistic forecasts) +""" + +from typing import Literal + +import numpy as np + +ReductionType = Literal["mean", "none"] + + +def mse( + y_true: np.ndarray, + y_pred: np.ndarray, + reduction: ReductionType = "mean", +) -> float | np.ndarray: + """Calculate Mean Squared Error between true and predicted values. + + MSE measures the average squared difference between predictions and ground truth. + Lower values indicate better forecast accuracy. + + Mathematical Formula: + MSE = (1/n) * Σ(y_true - y_pred)² + + where n is the total number of predictions (batch_size × horizon × features). + + Args: + y_true: Ground truth values. Shape: (batch_size, horizon, features). + y_pred: Predicted values. Shape: (batch_size, horizon, features). + reduction: How to aggregate results across the batch dimension. + - 'mean': Return single scalar averaged across all dimensions (default) + - 'none': Return per-sample metrics with shape (batch_size,) + + Returns: + MSE value(s). Returns float if reduction='mean', otherwise array of shape + (batch_size,) containing MSE for each sample in the batch. + + Raises: + TypeError: If inputs are not numpy arrays. + ValueError: If inputs have different shapes, wrong number of dimensions, + or are empty. + + Examples: + >>> import numpy as np + >>> from faim_sdk.eval import mse + >>> + >>> # Single feature, batch of 4 samples + >>> y_true = np.array([[[1.0], [2.0], [3.0]], + ... [[4.0], [5.0], [6.0]], + ... [[7.0], [8.0], [9.0]], + ... [[10.0], [11.0], [12.0]]]) # (4, 3, 1) + >>> y_pred = np.array([[[1.1], [2.1], [3.1]], + ... [[4.1], [5.1], [6.1]], + ... [[7.1], [8.1], [9.1]], + ... [[10.1], [11.1], [12.1]]]) # (4, 3, 1) + >>> + >>> # Overall MSE + >>> mse(y_true, y_pred, reduction='mean') + 0.010000000000000002 + >>> + >>> # Per-sample MSE + >>> mse(y_true, y_pred, reduction='none') + array([0.01, 0.01, 0.01, 0.01]) + >>> + >>> # Multi-feature example + >>> y_true = np.random.randn(32, 24, 5) # 32 samples, 24 steps, 5 features + >>> y_pred = y_true + np.random.randn(32, 24, 5) * 0.1 # Add small noise + >>> mse_score = mse(y_true, y_pred) # Returns scalar + >>> print(f"MSE: {mse_score:.4f}") + + Notes: + - MSE is sensitive to outliers due to squaring errors + - MSE units are squared units of the original data + - MSE is always non-negative (0 = perfect forecast) + - For scale-independent evaluation, consider using MASE instead + """ + # Type validation + if not isinstance(y_true, np.ndarray): + raise TypeError(f"y_true must be numpy.ndarray, got {type(y_true).__name__}") + if not isinstance(y_pred, np.ndarray): + raise TypeError(f"y_pred must be numpy.ndarray, got {type(y_pred).__name__}") + + # Shape validation + if y_true.ndim != 3: + raise ValueError( + f"y_true must be 3-dimensional (batch_size, horizon, features), got shape {y_true.shape}" + ) + if y_pred.ndim != 3: + raise ValueError( + f"y_pred must be 3-dimensional (batch_size, horizon, features), got shape {y_pred.shape}" + ) + if y_true.shape != y_pred.shape: + raise ValueError( + f"y_true and y_pred must have the same shape, got {y_true.shape} and {y_pred.shape}" + ) + + # Empty validation + if y_true.size == 0: + raise ValueError("y_true cannot be empty") + + # Calculate squared errors + squared_errors = (y_true - y_pred) ** 2 + + # Apply reduction + if reduction == "mean": + return float(np.mean(squared_errors)) + elif reduction == "none": + # Average over horizon and features, keep batch dimension + return np.mean(squared_errors, axis=(1, 2)) + else: + raise ValueError(f"reduction must be 'mean' or 'none', got '{reduction}'") + + +def mase( + y_true: np.ndarray, + y_pred: np.ndarray, + y_train: np.ndarray, + reduction: ReductionType = "mean", +) -> float | np.ndarray: + """Calculate Mean Absolute Scaled Error for forecast evaluation. + + MASE is a scale-independent metric that measures forecast accuracy relative + to a naive baseline forecast. It normalizes the forecast error by the average + error of a naive forecast on the training data. + + The naive baseline used here is the "last value" forecast: predicting each + training value as the previous training value. + + Mathematical Formula: + MASE = MAE(forecast) / MAE(naive baseline on training data) + + where: + - MAE(forecast) = (1/n) * Σ|y_true - y_pred| + - MAE(naive baseline) = (1/(T-1)) * Σ|y_train[t] - y_train[t-1]| + + Interpretation: + - MASE < 1: Forecast is better than naive baseline + - MASE = 1: Forecast is equivalent to naive baseline + - MASE > 1: Forecast is worse than naive baseline + + Args: + y_true: Ground truth values. Shape: (batch_size, horizon, features). + y_pred: Predicted values. Shape: (batch_size, horizon, features). + y_train: Historical training data used for baseline calculation. + Shape: (batch_size, train_length, features). + Should contain at least 2 time steps per sample. + reduction: How to aggregate results across the batch dimension. + - 'mean': Return single scalar averaged across batch (default) + - 'none': Return per-sample metrics with shape (batch_size,) + + Returns: + MASE value(s). Returns float if reduction='mean', otherwise array of shape + (batch_size,) containing MASE for each sample in the batch. + + Raises: + TypeError: If inputs are not numpy arrays. + ValueError: If inputs have incompatible shapes, wrong dimensions, + or training data is too short (< 2 time steps). + RuntimeWarning: If naive baseline MAE is zero (constant training series), + MASE will be infinite. + + Examples: + >>> import numpy as np + >>> from faim_sdk.eval import mase + >>> + >>> # Example with trend + >>> y_train = np.array([[[1.0], [2.0], [3.0], [4.0], [5.0]]]) # (1, 5, 1) + >>> y_true = np.array([[[6.0], [7.0], [8.0]]]) # (1, 3, 1) + >>> y_pred = np.array([[[6.1], [7.1], [8.1]]]) # (1, 3, 1) + >>> + >>> # Naive baseline MAE = mean(|1-2|, |2-3|, |3-4|, |4-5|) = 1.0 + >>> # Forecast MAE = mean(|6-6.1|, |7-7.1|, |8-8.1|) = 0.1 + >>> # MASE = 0.1 / 1.0 = 0.1 (excellent, much better than naive) + >>> mase(y_true, y_pred, y_train) + 0.1 + >>> + >>> # Batch example with multiple samples + >>> y_train = np.random.randn(32, 100, 5) # 32 samples, 100 train steps + >>> y_true = np.random.randn(32, 24, 5) # 24 forecast steps + >>> y_pred = np.random.randn(32, 24, 5) + >>> + >>> # Overall MASE + >>> mase_score = mase(y_true, y_pred, y_train, reduction='mean') + >>> print(f"MASE: {mase_score:.4f}") + >>> + >>> # Per-sample MASE + >>> mase_per_sample = mase(y_true, y_pred, y_train, reduction='none') + >>> print(f"MASE range: [{mase_per_sample.min():.2f}, {mase_per_sample.max():.2f}]") + + Notes: + - MASE is scale-independent, allowing comparison across different series + - MASE is recommended by Hyndman & Koehler (2006) for forecast evaluation + - Unlike MAPE, MASE works well with zero or near-zero values + - If training data is constant (naive MAE = 0), MASE will be infinite + - For seasonal data, consider using seasonal naive baseline instead + + References: + Hyndman, R. J., & Koehler, A. B. (2006). Another look at measures of + forecast accuracy. International Journal of Forecasting, 22(4), 679-688. + """ + # Type validation + if not isinstance(y_true, np.ndarray): + raise TypeError(f"y_true must be numpy.ndarray, got {type(y_true).__name__}") + if not isinstance(y_pred, np.ndarray): + raise TypeError(f"y_pred must be numpy.ndarray, got {type(y_pred).__name__}") + if not isinstance(y_train, np.ndarray): + raise TypeError(f"y_train must be numpy.ndarray, got {type(y_train).__name__}") + + # Shape validation + if y_true.ndim != 3: + raise ValueError( + f"y_true must be 3-dimensional (batch_size, horizon, features), got shape {y_true.shape}" + ) + if y_pred.ndim != 3: + raise ValueError( + f"y_pred must be 3-dimensional (batch_size, horizon, features), got shape {y_pred.shape}" + ) + if y_train.ndim != 3: + raise ValueError( + f"y_train must be 3-dimensional (batch_size, train_length, features), got shape {y_train.shape}" + ) + + if y_true.shape != y_pred.shape: + raise ValueError( + f"y_true and y_pred must have the same shape, got {y_true.shape} and {y_pred.shape}" + ) + + batch_size_true, _, features_true = y_true.shape + batch_size_train, train_length, features_train = y_train.shape + + if batch_size_true != batch_size_train: + raise ValueError( + f"Batch size mismatch: y_true has {batch_size_true} samples, " + f"y_train has {batch_size_train} samples" + ) + + if features_true != features_train: + raise ValueError( + f"Feature count mismatch: y_true has {features_true} features, " + f"y_train has {features_train} features" + ) + + # Training data length validation + if train_length < 2: + raise ValueError( + f"y_train must have at least 2 time steps for naive baseline, got {train_length}" + ) + + # Empty validation + if y_true.size == 0: + raise ValueError("y_true cannot be empty") + if y_train.size == 0: + raise ValueError("y_train cannot be empty") + + # Calculate forecast MAE + forecast_mae = np.abs(y_true - y_pred) + + # Calculate naive baseline MAE (last value forecast on training data) + # Naive forecast: y_train[t] predicts y_train[t-1] + naive_errors = np.abs(y_train[:, 1:, :] - y_train[:, :-1, :]) + naive_mae = np.mean(naive_errors, axis=1, keepdims=True) # Shape: (batch_size, 1, features) + + # Warn if naive MAE is zero (constant series) + if np.any(naive_mae == 0): + import warnings + + warnings.warn( + "Naive baseline MAE is zero for some samples (constant training series). " + "MASE will be infinite for these samples.", + RuntimeWarning, + stacklevel=2, + ) + + # Calculate MASE + # Avoid division by zero by using a small epsilon where naive_mae is 0 + epsilon = 1e-10 + mase_values = forecast_mae / np.maximum(naive_mae, epsilon) + + # Apply reduction + if reduction == "mean": + return float(np.mean(mase_values)) + elif reduction == "none": + # Average over horizon and features, keep batch dimension + return np.mean(mase_values, axis=(1, 2)) + else: + raise ValueError(f"reduction must be 'mean' or 'none', got '{reduction}'") + + +def crps_from_quantiles( + y_true: np.ndarray, + quantile_preds: np.ndarray, + quantile_levels: list[float], + reduction: ReductionType = "mean", +) -> float | np.ndarray: + """Calculate Continuous Ranked Probability Score from quantile predictions. + + CRPS is a proper scoring rule for evaluating probabilistic forecasts. + It generalizes the Mean Absolute Error (MAE) to probabilistic predictions + by measuring the integrated squared difference between the predicted and + true cumulative distribution functions. + + This implementation uses the quantile approximation method, which estimates + CRPS from a discrete set of quantile predictions. + + Mathematical Formula (Quantile Approximation): + CRPS ≈ Σ_i w_i * |y_true - q_i| * (2 * I(y_true < q_i) - 1 - α_i) + + where: + - q_i is the i-th quantile prediction at level α_i + - w_i is the weight for quantile i + - I(·) is the indicator function + + Simplified approximation used here: + CRPS ≈ Σ_i w_i * |y_true - q_i| + + where w_i = α_{i+1} - α_{i-1} for interior quantiles. + + Interpretation: + - CRPS = 0: Perfect probabilistic forecast + - Lower CRPS: Better forecast + - CRPS reduces to MAE when only median (0.5) quantile is provided + - CRPS penalizes both bias and miscalibration + + Args: + y_true: Ground truth values. Shape: (batch_size, horizon, features). + quantile_preds: Quantile predictions. Shape: (batch_size, horizon, num_quantiles). + Quantiles should be ordered from lowest to highest level. + quantile_levels: List of quantile levels corresponding to quantile_preds. + Must have length equal to num_quantiles dimension. + Values should be in [0, 1] and sorted in ascending order. + Example: [0.1, 0.5, 0.9] for 10th, 50th, and 90th percentiles. + reduction: How to aggregate results across the batch dimension. + - 'mean': Return single scalar averaged across batch (default) + - 'none': Return per-sample metrics with shape (batch_size,) + + Returns: + CRPS value(s). Returns float if reduction='mean', otherwise array of shape + (batch_size,) containing i for each sample in the batch. + + Raises: + TypeError: If inputs are not numpy arrays or quantile_levels is not a list. + ValueError: If inputs have incompatible shapes, quantile_levels are invalid, + or arrays are empty. + + Examples: + >>> import numpy as np + >>> from faim_sdk.eval import crps_from_quantiles + >>> + >>> # Example with known quantiles + >>> y_true = np.array([[[5.0], [6.0], [7.0]]]) # (1, 3, 1) + >>> # Quantile predictions: 10th, 50th, 90th percentiles + >>> quantile_preds = np.array([ + ... [[4.5, 5.0, 5.5], # t=0 + ... [5.5, 6.0, 6.5], # t=1 + ... [6.5, 7.0, 7.5]] # t=2 + ... ]) # (1, 3, 3) + >>> quantile_levels = [0.1, 0.5, 0.9] + >>> + >>> crps_score = crps_from_quantiles( + ... y_true, + ... quantile_preds, + ... quantile_levels, + ... reduction='mean' + ... ) + >>> print(f"CRPS: {crps_score:.4f}") + >>> + >>> # Typical usage with FAIM SDK response + >>> from faim_sdk import ForecastClient, Chronos2ForecastRequest + >>> from faim_client.models import ModelName + >>> + >>> client = ForecastClient(base_url="https://api.example.com") + >>> request = Chronos2ForecastRequest( + ... x=train_data, # (32, 100, 1) + ... horizon=24, + ... output_type="quantiles", + ... quantiles=[0.1, 0.25, 0.5, 0.75, 0.9] + ... ) + >>> response = client.forecast(ModelName.CHRONOS2, request) + >>> + >>> # Note: response.quantiles is (batch, horizon, num_quantiles) + >>> # but y_true is (batch, horizon, features) + >>> # For single-feature case, this works directly: + >>> crps = crps_from_quantiles( + ... test_data, # (32, 24, 1) + ... response.quantiles, # (32, 24, 5) + ... quantile_levels=[0.1, 0.25, 0.5, 0.75, 0.9] + ... ) + >>> + >>> # Per-sample CRPS for analysis + >>> crps_per_sample = crps_from_quantiles( + ... test_data, + ... response.quantiles, + ... quantile_levels=[0.1, 0.25, 0.5, 0.75, 0.9], + ... reduction='none' + ... ) + >>> print(f"Best sample CRPS: {crps_per_sample.min():.4f}") + >>> print(f"Worst sample CRPS: {crps_per_sample.max():.4f}") + + Notes: + - CRPS is a proper scoring rule (incentivizes honest probabilistic forecasts) + - More quantiles generally provide better CRPS approximation + - CRPS is in the same units as the original data + - For purely point forecasts, use MSE or MASE instead + - This approximation becomes more accurate with more quantiles + + References: + Gneiting, T., & Raftery, A. E. (2007). Strictly proper scoring rules, + prediction, and estimation. Journal of the American Statistical + Association, 102(477), 359-378. + """ + # Type validation + if not isinstance(y_true, np.ndarray): + raise TypeError(f"y_true must be numpy.ndarray, got {type(y_true).__name__}") + if not isinstance(quantile_preds, np.ndarray): + raise TypeError(f"quantile_preds must be numpy.ndarray, got {type(quantile_preds).__name__}") + if not isinstance(quantile_levels, list): + raise TypeError(f"quantile_levels must be a list, got {type(quantile_levels).__name__}") + + # Shape validation + if y_true.ndim != 3: + raise ValueError( + f"y_true must be 3-dimensional (batch_size, horizon, features), got shape {y_true.shape}" + ) + if quantile_preds.ndim != 3: + raise ValueError( + f"quantile_preds must be 3-dimensional (batch_size, horizon, num_quantiles), " + f"got shape {quantile_preds.shape}" + ) + + batch_size_true, horizon_true, features = y_true.shape + batch_size_pred, horizon_pred, num_quantiles = quantile_preds.shape + + if batch_size_true != batch_size_pred: + raise ValueError( + f"Batch size mismatch: y_true has {batch_size_true} samples, " + f"quantile_preds has {batch_size_pred} samples" + ) + if horizon_true != horizon_pred: + raise ValueError( + f"Horizon mismatch: y_true has {horizon_true} steps, " + f"quantile_preds has {horizon_pred} steps" + ) + + # Quantile levels validation + if len(quantile_levels) != num_quantiles: + raise ValueError( + f"quantile_levels length ({len(quantile_levels)}) must match " + f"num_quantiles dimension ({num_quantiles})" + ) + + if not all(0.0 <= q <= 1.0 for q in quantile_levels): + raise ValueError(f"quantile_levels must be in [0.0, 1.0], got {quantile_levels}") + + if quantile_levels != sorted(quantile_levels): + raise ValueError( + f"quantile_levels must be sorted in ascending order, got {quantile_levels}" + ) + + # Empty validation + if y_true.size == 0: + raise ValueError("y_true cannot be empty") + if quantile_preds.size == 0: + raise ValueError("quantile_preds cannot be empty") + + # For multi-feature forecasts, we need to ensure compatibility + # Typically, quantile forecasts are per-feature, so we expect: + # - If features == 1 and num_quantiles > 1: standard quantile forecast + # - If features == num_quantiles: each quantile corresponds to a feature (unusual) + # We'll handle the standard case where features == 1 or we average across features + + if features != 1 and features != num_quantiles: + raise ValueError( + f"For CRPS calculation, y_true features ({features}) should be 1 " + f"or match num_quantiles ({num_quantiles}). " + f"For multi-feature forecasts with quantiles, compute CRPS per feature separately." + ) + + # Calculate weights for quantile approximation + # Weights are the differences between adjacent quantile levels + quantile_array = np.array(quantile_levels) + weights = np.zeros(num_quantiles) + + # Interior quantiles get weight (α_{i+1} - α_{i-1}) / 2 + if num_quantiles == 1: + weights[0] = 1.0 + elif num_quantiles == 2: + weights[0] = quantile_array[1] - quantile_array[0] + weights[1] = quantile_array[1] - quantile_array[0] + else: + # First quantile + weights[0] = quantile_array[1] - quantile_array[0] + # Interior quantiles + for i in range(1, num_quantiles - 1): + weights[i] = (quantile_array[i + 1] - quantile_array[i - 1]) / 2.0 + # Last quantile + weights[-1] = quantile_array[-1] - quantile_array[-2] + + # Normalize weights to sum to 1 + weights = weights / weights.sum() + + # Reshape for broadcasting: (1, 1, num_quantiles) + weights_broadcast = weights.reshape(1, 1, -1) + + # For standard case where features=1, expand y_true to match quantile dimension + if features == 1: + # Expand y_true from (batch, horizon, 1) to (batch, horizon, num_quantiles) + y_true_expanded = np.repeat(y_true, num_quantiles, axis=2) + else: + # features == num_quantiles case + y_true_expanded = y_true + + # Calculate weighted absolute errors + absolute_errors = np.abs(y_true_expanded - quantile_preds) + weighted_errors = absolute_errors * weights_broadcast + + # Sum over quantiles to get CRPS per (batch, horizon) point + crps_values = np.sum(weighted_errors, axis=2) # Shape: (batch_size, horizon) + + # Apply reduction + if reduction == "mean": + return float(np.mean(crps_values)) + elif reduction == "none": + # Average over horizon, keep batch dimension + return np.mean(crps_values, axis=1) + else: + raise ValueError(f"reduction must be 'mean' or 'none', got '{reduction}'") \ No newline at end of file diff --git a/faim_sdk/eval/py.typed b/faim_sdk/eval/py.typed new file mode 100644 index 0000000..e69de29 diff --git a/faim_sdk/eval/visualization.py b/faim_sdk/eval/visualization.py new file mode 100644 index 0000000..cd2f01a --- /dev/null +++ b/faim_sdk/eval/visualization.py @@ -0,0 +1,400 @@ +"""Visualization utilities for time-series forecasts. + +This module provides production-ready plotting functions for visualizing +forecasting results. All functions use matplotlib for maximum compatibility. + +To use visualization features, install with the viz extra: + pip install faim-sdk[viz] + +Typical Usage: + >>> from faim_sdk import ForecastClient, Chronos2ForecastRequest + >>> from faim_sdk.eval import plot_forecast + >>> from faim_client.models import ModelName + >>> import numpy as np + >>> + >>> # Generate forecast + >>> client = ForecastClient(base_url="https://api.example.com") + >>> request = Chronos2ForecastRequest( + ... x=train_data, # shape: (32, 100, 1) + ... horizon=24, + ... output_type="point" + ... ) + >>> response = client.forecast(ModelName.CHRONOS2, request) + >>> + >>> # Plot single sample from batch (omit batch dimension as documented) + >>> fig, ax = plot_forecast( + ... train_data=train_data[0], # (100, 1) - 2D array + ... forecast=response.point[0], # (24, 1) - 2D array + ... test_data=test_data[0], # (24, 1) - 2D array (optional) + ... title="Forecast for Sample 1" + ... ) + >>> fig.savefig("forecast.png") + +Available Functions: + - plot_forecast: Plot training data, forecast, and optional test data +""" + +from typing import Sequence + +import numpy as np + +# matplotlib is an optional dependency +try: + import matplotlib.pyplot as plt + from matplotlib.figure import Figure + from matplotlib.axes import Axes + + MATPLOTLIB_AVAILABLE = True +except ImportError: + MATPLOTLIB_AVAILABLE = False + Figure = None + Axes = None + + +def plot_forecast( + train_data: np.ndarray, + forecast: np.ndarray, + test_data: np.ndarray | None = None, + features_on_same_plot: bool = True, + feature_names: Sequence[str] | None = None, + title: str | None = None, + figsize: tuple[float, float] | None = None, + save_path: str | None = None, +) -> tuple[Figure, Axes | np.ndarray]: + """Plot time-series forecast with training data and optional test data. + + Creates a visualization showing: + - Historical training data (solid line) + - Forecast predictions (dashed line) + - Optional test/ground truth data (solid line, different color) + + **IMPORTANT**: All input arrays must be 2D (omit batch dimension). + Input shapes: (sequence_length, features) + + Args: + train_data: Historical training data. Shape: (train_length, features). + Must be 2D array (batch dimension omitted). + forecast: Forecast predictions. Shape: (horizon, features). + Must be 2D array (batch dimension omitted). + test_data: Optional ground truth test data. Shape: (horizon, features). + If provided, must match forecast shape. + features_on_same_plot: How to handle multiple features. + - True: Plot all features on a single figure with unique colors (default) + - False: Create subplots, one per feature + feature_names: Optional list of feature names for legend. + Length must match number of features. + If None, features are named "Feature 1", "Feature 2", etc. + title: Optional plot title. If None, uses "Time Series Forecast". + figsize: Optional figure size (width, height) in inches. + If None, uses matplotlib defaults or (12, 6) for subplots. + save_path: Optional file path to save the figure. + Supports common formats: .png, .pdf, .svg, .jpg + + Returns: + Tuple of (Figure, Axes). For features_on_same_plot=True, Axes is a single + Axes object. For features_on_same_plot=False, Axes is a numpy array of + Axes objects (one per subplot). + + Raises: + ImportError: If matplotlib is not installed. Install with: pip install faim-sdk[viz] + TypeError: If inputs are not numpy arrays. + ValueError: If inputs have wrong dimensions, incompatible shapes, + are empty, or have too many features for single-plot visualization. + + Examples: + >>> import numpy as np + >>> from faim_sdk.eval import plot_forecast + >>> + >>> # Single feature example + >>> train = np.random.randn(100, 1) # 100 time steps, 1 feature + >>> forecast = np.random.randn(24, 1) # 24 forecast steps + >>> test = np.random.randn(24, 1) # Ground truth + >>> + >>> fig, ax = plot_forecast(train, forecast, test, title="Single Feature") + >>> fig.savefig("single_feature.png") + >>> + >>> # Multi-feature on same plot + >>> train = np.random.randn(100, 3) # 3 features + >>> forecast = np.random.randn(24, 3) + >>> test = np.random.randn(24, 3) + >>> + >>> fig, ax = plot_forecast( + ... train, + ... forecast, + ... test, + ... features_on_same_plot=True, + ... feature_names=["Temperature", "Humidity", "Pressure"], + ... title="Weather Forecast" + ... ) + >>> + >>> # Multi-feature with subplots + >>> fig, axes = plot_forecast( + ... train, + ... forecast, + ... test, + ... features_on_same_plot=False, + ... feature_names=["Temperature", "Humidity", "Pressure"], + ... figsize=(12, 8) + ... ) + >>> # axes is array of 3 Axes objects + >>> fig.savefig("weather_subplots.png") + >>> + >>> # Usage with FAIM SDK (remember to index batch dimension) + >>> from faim_sdk import ForecastClient, Chronos2ForecastRequest + >>> from faim_client.models import ModelName + >>> + >>> client = ForecastClient(base_url="https://api.example.com") + >>> request = Chronos2ForecastRequest( + ... x=train_batch, # (32, 100, 1) + ... horizon=24, + ... output_type="point" + ... ) + >>> response = client.forecast(ModelName.CHRONOS2, request) + >>> + >>> # Plot first sample from batch + >>> fig, ax = plot_forecast( + ... train_data=train_batch[0], # (100, 1) - Remove batch dim! + ... forecast=response.point[0], # (24, 1) + ... test_data=test_batch[0], # (24, 1) + ... ) + >>> + >>> # Plot multiple samples in a loop + >>> for i in range(5): + ... fig, ax = plot_forecast( + ... train_batch[i], + ... response.point[i], + ... test_batch[i], + ... title=f"Sample {i+1}", + ... save_path=f"forecast_sample_{i+1}.png" + ... ) + + Notes: + - Always pass 2D arrays (omit batch dimension when indexing SDK responses) + - Maximum 10 features allowed when features_on_same_plot=True + - For more than 10 features, use features_on_same_plot=False + - Each feature gets a unique color automatically + - Training data shown in solid lines, forecasts in dashed lines + - Vertical line marks the train/forecast boundary + - Legend automatically includes all features and data types + + Warnings: + If features_on_same_plot=True and number of features > 10, raises ValueError + to prevent cluttered visualizations. + """ + # Check matplotlib availability + if not MATPLOTLIB_AVAILABLE: + raise ImportError( + "matplotlib is required for visualization. " + "Install with: pip install faim-sdk[viz] or pip install matplotlib" + ) + + # Type validation + if not isinstance(train_data, np.ndarray): + raise TypeError(f"train_data must be numpy.ndarray, got {type(train_data).__name__}") + if not isinstance(forecast, np.ndarray): + raise TypeError(f"forecast must be numpy.ndarray, got {type(forecast).__name__}") + if test_data is not None and not isinstance(test_data, np.ndarray): + raise TypeError(f"test_data must be numpy.ndarray or None, got {type(test_data).__name__}") + + # Shape validation + if train_data.ndim != 2: + raise ValueError( + f"train_data must be 2-dimensional (sequence_length, features), got shape {train_data.shape}. " + f"Did you forget to index the batch dimension? Use train_data[i] to select a single sample." + ) + if forecast.ndim != 2: + raise ValueError( + f"forecast must be 2-dimensional (horizon, features), got shape {forecast.shape}. " + f"Did you forget to index the batch dimension? Use forecast[i] to select a single sample." + ) + if test_data is not None and test_data.ndim != 2: + raise ValueError( + f"test_data must be 2-dimensional (horizon, features), got shape {test_data.shape}. " + f"Did you forget to index the batch dimension? Use test_data[i] to select a single sample." + ) + + # Empty validation + if train_data.size == 0: + raise ValueError("train_data cannot be empty") + if forecast.size == 0: + raise ValueError("forecast cannot be empty") + + # Extract dimensions + train_length, train_features = train_data.shape + horizon, forecast_features = forecast.shape + + # Feature count validation + if train_features != forecast_features: + raise ValueError( + f"Feature count mismatch: train_data has {train_features} features, " + f"forecast has {forecast_features} features" + ) + + num_features = train_features + + # Validate test_data if provided + if test_data is not None: + test_horizon, test_features = test_data.shape + if test_horizon != horizon: + raise ValueError( + f"Horizon mismatch: forecast has {horizon} steps, " + f"test_data has {test_horizon} steps" + ) + if test_features != num_features: + raise ValueError( + f"Feature count mismatch: forecast has {num_features} features, " + f"test_data has {test_features} features" + ) + + # Validate feature count for single plot + if features_on_same_plot and num_features > 10: + raise ValueError( + f"Cannot plot {num_features} features on same plot (maximum 10). " + f"Use features_on_same_plot=False to create subplots instead." + ) + + # Generate feature names if not provided + if feature_names is None: + if num_features == 1: + feature_names = ["Series"] + else: + feature_names = [f"Feature {i+1}" for i in range(num_features)] + else: + if len(feature_names) != num_features: + raise ValueError( + f"feature_names length ({len(feature_names)}) must match " + f"number of features ({num_features})" + ) + + # Create time indices + train_indices = np.arange(train_length) + forecast_indices = np.arange(train_length, train_length + horizon) + + # Set up figure + if features_on_same_plot: + # Single plot for all features + if figsize is None: + fig, ax = plt.subplots(figsize=(10, 6)) + else: + fig, ax = plt.subplots(figsize=figsize) + axes = ax # Return single Axes object + else: + # Subplots for each feature + if figsize is None: + figsize = (12, 3 * num_features) + fig, axes_array = plt.subplots(num_features, 1, figsize=figsize, squeeze=False) + axes = axes_array.flatten() # Return array of Axes objects + + # Define color palette (matplotlib default colors) + colors = plt.cm.tab10(np.linspace(0, 1, 10)) # 10 distinct colors + + # Plot data + if features_on_same_plot: + # Plot all features on same axes + for i in range(num_features): + color = colors[i % 10] + + # Training data + ax.plot( + train_indices, + train_data[:, i], + label=f"{feature_names[i]} (train)", + color=color, + linewidth=2, + alpha=0.8, + ) + + # Forecast + ax.plot( + forecast_indices, + forecast[:, i], + label=f"{feature_names[i]} (forecast)", + color=color, + linewidth=2, + linestyle="--", + alpha=0.8, + ) + + # Test data (if provided) + if test_data is not None: + ax.plot( + forecast_indices, + test_data[:, i], + label=f"{feature_names[i]} (actual)", + color=color, + linewidth=2, + linestyle=":", + alpha=0.6, + ) + + # Add vertical line at train/forecast boundary + ax.axvline(x=train_length, color="gray", linestyle="-", linewidth=1, alpha=0.5) + + # Labels and legend + ax.set_xlabel("Time Step", fontsize=12) + ax.set_ylabel("Value", fontsize=12) + ax.set_title(title if title else "Time Series Forecast", fontsize=14, fontweight="bold") + ax.legend(loc="best", fontsize=10) + ax.grid(True, alpha=0.3) + + else: + # Plot each feature on separate subplot + for i in range(num_features): + ax_i = axes[i] + color = colors[i % 10] + + # Training data + ax_i.plot( + train_indices, + train_data[:, i], + label="Training", + color=color, + linewidth=2, + alpha=0.8, + ) + + # Forecast + ax_i.plot( + forecast_indices, + forecast[:, i], + label="Forecast", + color=color, + linewidth=2, + linestyle="--", + alpha=0.8, + ) + + # Test data (if provided) + if test_data is not None: + ax_i.plot( + forecast_indices, + test_data[:, i], + label="Actual", + color=color, + linewidth=2, + linestyle=":", + alpha=0.6, + ) + + # Add vertical line at train/forecast boundary + ax_i.axvline(x=train_length, color="gray", linestyle="-", linewidth=1, alpha=0.5) + + # Labels and legend + ax_i.set_xlabel("Time Step", fontsize=11) + ax_i.set_ylabel("Value", fontsize=11) + ax_i.set_title(feature_names[i], fontsize=12, fontweight="bold") + ax_i.legend(loc="best", fontsize=9) + ax_i.grid(True, alpha=0.3) + + # Overall title + if title: + fig.suptitle(title, fontsize=14, fontweight="bold", y=0.995) + + # Tight layout + fig.tight_layout() + + # Save if path provided + if save_path is not None: + fig.savefig(save_path, dpi=300, bbox_inches="tight") + + return fig, axes \ No newline at end of file diff --git a/tests/unit/test_eval_metrics.py b/tests/unit/test_eval_metrics.py new file mode 100644 index 0000000..91c9cd0 --- /dev/null +++ b/tests/unit/test_eval_metrics.py @@ -0,0 +1,388 @@ +w"""Unit tests for faim_sdk.eval.metrics module. + +Tests for MSE, MASE, and CRPS metrics with comprehensive coverage +of functionality, edge cases, and error handling. +""" + +import numpy as np +import pytest + +from faim_sdk.eval.metrics import crps_from_quantiles, mase, mse + + +class TestMSE: + """Tests for Mean Squared Error (MSE) metric.""" + + def test_mse_perfect_prediction(self): + """Test MSE returns 0 for perfect predictions.""" + y_true = np.array([[[1.0], [2.0], [3.0]]]) + y_pred = np.array([[[1.0], [2.0], [3.0]]]) + + result = mse(y_true, y_pred, reduction="mean") + assert result == 0.0 + + def test_mse_known_values(self): + """Test MSE with known input/output values.""" + y_true = np.array([[[1.0], [2.0], [3.0]]]) + y_pred = np.array([[[2.0], [3.0], [4.0]]]) + + # Expected: ((1-2)^2 + (2-3)^2 + (3-4)^2) / 3 = 3/3 = 1.0 + result = mse(y_true, y_pred, reduction="mean") + assert result == 1.0 + + def test_mse_reduction_none(self): + """Test MSE with reduction='none' returns per-sample metrics.""" + y_true = np.array([ + [[1.0], [2.0]], + [[3.0], [4.0]], + [[5.0], [6.0]] + ]) + y_pred = np.array([ + [[2.0], [3.0]], # Errors: 1, 1 -> MSE = 1.0 + [[3.0], [4.0]], # Errors: 0, 0 -> MSE = 0.0 + [[6.0], [8.0]] # Errors: 1, 2 -> MSE = (1+4)/2 = 2.5 + ]) + + result = mse(y_true, y_pred, reduction="none") + + assert result.shape == (3,) + np.testing.assert_array_almost_equal(result, [1.0, 0.0, 2.5]) + + def test_mse_multi_feature(self): + """Test MSE with multiple features.""" + y_true = np.array([[[1.0, 2.0, 3.0]]]) # (1, 1, 3) + y_pred = np.array([[[2.0, 2.0, 2.0]]]) + + # Errors: (1-2)^2=1, (2-2)^2=0, (3-2)^2=1 + # MSE = (1 + 0 + 1) / 3 = 0.667 + result = mse(y_true, y_pred, reduction="mean") + assert pytest.approx(result, rel=1e-6) == 2.0 / 3.0 + + def test_mse_large_batch(self): + """Test MSE with realistic batch size.""" + batch_size = 32 + horizon = 24 + features = 5 + + y_true = np.random.randn(batch_size, horizon, features) + y_pred = y_true + np.random.randn(batch_size, horizon, features) * 0.1 + + result = mse(y_true, y_pred, reduction="mean") + assert isinstance(result, float) + assert result > 0 + + def test_mse_wrong_shape_error(self): + """Test MSE raises error for mismatched shapes.""" + y_true = np.array([[[1.0], [2.0]]]) + y_pred = np.array([[[1.0]]]) # Wrong horizon + + with pytest.raises(ValueError, match="must have the same shape"): + mse(y_true, y_pred) + + def test_mse_wrong_dimensions_error(self): + """Test MSE raises error for wrong number of dimensions.""" + y_true = np.array([[1.0, 2.0]]) # 2D instead of 3D + y_pred = np.array([[1.0, 2.0]]) + + with pytest.raises(ValueError, match="must be 3-dimensional"): + mse(y_true, y_pred) + + def test_mse_type_error(self): + """Test MSE raises error for non-numpy inputs.""" + y_true = [[1.0, 2.0]] # Python list + y_pred = np.array([[[1.0], [2.0]]]) + + with pytest.raises(TypeError, match="must be numpy.ndarray"): + mse(y_true, y_pred) + + def test_mse_empty_array_error(self): + """Test MSE raises error for empty arrays.""" + y_true = np.array([]).reshape(1, 0, 1) + y_pred = np.array([]).reshape(1, 0, 1) + + with pytest.raises(ValueError, match="cannot be empty"): + mse(y_true, y_pred) + + def test_mse_invalid_reduction_error(self): + """Test MSE raises error for invalid reduction parameter.""" + y_true = np.array([[[1.0]]]) + y_pred = np.array([[[1.0]]]) + + with pytest.raises(ValueError, match="reduction must be 'mean' or 'none'"): + mse(y_true, y_pred, reduction="invalid") + + +class TestMASE: + """Tests for Mean Absolute Scaled Error (MASE) metric.""" + + def test_mase_perfect_prediction(self): + """Test MASE returns 0 for perfect predictions.""" + y_train = np.array([[[1.0], [2.0], [3.0], [4.0]]]) + y_true = np.array([[[5.0], [6.0]]]) + y_pred = np.array([[[5.0], [6.0]]]) + + result = mase(y_true, y_pred, y_train, reduction="mean") + assert result == 0.0 + + def test_mase_known_values(self): + """Test MASE with known input/output values.""" + # Training: [1, 2, 3, 4, 5] -> naive MAE = mean(|1|, |1|, |1|, |1|) = 1.0 + y_train = np.array([[[1.0], [2.0], [3.0], [4.0], [5.0]]]) + + # Test: true=[6, 7, 8], pred=[6.1, 7.1, 8.1] + # Forecast MAE = mean(|0.1|, |0.1|, |0.1|) = 0.1 + # MASE = 0.1 / 1.0 = 0.1 + y_true = np.array([[[6.0], [7.0], [8.0]]]) + y_pred = np.array([[[6.1], [7.1], [8.1]]]) + + result = mase(y_true, y_pred, y_train, reduction="mean") + assert pytest.approx(result, rel=1e-6) == 0.1 + + def test_mase_worse_than_naive(self): + """Test MASE > 1 when forecast is worse than naive baseline.""" + # Training: constant changes of 1 + y_train = np.array([[[1.0], [2.0], [3.0], [4.0]]]) + + # Bad forecast: errors of 2 + y_true = np.array([[[5.0], [6.0]]]) + y_pred = np.array([[[7.0], [8.0]]]) + + # Naive MAE = 1.0, Forecast MAE = 2.0, MASE = 2.0 + result = mase(y_true, y_pred, y_train, reduction="mean") + assert result == 2.0 + + def test_mase_reduction_none(self): + """Test MASE with reduction='none' returns per-sample metrics.""" + y_train = np.array([ + [[1.0], [2.0], [3.0]], + [[2.0], [4.0], [6.0]], + [[5.0], [5.0], [5.0]] + ]) + y_true = np.array([ + [[4.0]], + [[8.0]], + [[5.0]] + ]) + y_pred = np.array([ + [[4.5]], # Error: 0.5, Naive MAE: 1.0 -> MASE: 0.5 + [[9.0]], # Error: 1.0, Naive MAE: 2.0 -> MASE: 0.5 + [[6.0]] # Error: 1.0, Naive MAE: 0.0 -> MASE: inf (constant) + ]) + + result = mase(y_true, y_pred, y_train, reduction="none") + + assert result.shape == (3,) + # Third sample has constant training series, so MASE will be very high + assert result[0] == pytest.approx(0.5, rel=1e-6) + assert result[1] == pytest.approx(0.5, rel=1e-6) + # Third element will be inf or very large due to constant series + + def test_mase_multi_feature(self): + """Test MASE with multiple features.""" + y_train = np.array([[[1.0, 10.0], [2.0, 20.0], [3.0, 30.0]]]) + y_true = np.array([[[4.0, 40.0]]]) + y_pred = np.array([[[4.1, 40.5]]]) + + result = mase(y_true, y_pred, y_train, reduction="mean") + assert isinstance(result, float) + assert result > 0 + + def test_mase_constant_training_warning(self): + """Test MASE warns about constant training series.""" + y_train = np.array([[[5.0], [5.0], [5.0]]]) # Constant + y_true = np.array([[[5.0]]]) + y_pred = np.array([[[6.0]]]) + + with pytest.warns(RuntimeWarning, match="Naive baseline MAE is zero"): + result = mase(y_true, y_pred, y_train, reduction="mean") + # Should return large value due to epsilon + assert result > 0 + + def test_mase_shape_mismatch_error(self): + """Test MASE raises error for mismatched shapes.""" + y_train = np.array([[[1.0], [2.0]]]) + y_true = np.array([[[3.0]], [[4.0]]]) # Wrong batch size + y_pred = np.array([[[3.0]]]) + + with pytest.raises(ValueError, match="Batch size mismatch"): + mase(y_true, y_pred, y_train) + + def test_mase_feature_mismatch_error(self): + """Test MASE raises error for mismatched features.""" + y_train = np.array([[[1.0, 2.0], [3.0, 4.0]]]) + y_true = np.array([[[5.0]]]) # Wrong features + y_pred = np.array([[[5.0]]]) + + with pytest.raises(ValueError, match="Feature count mismatch"): + mase(y_true, y_pred, y_train) + + def test_mase_short_training_error(self): + """Test MASE raises error for training data that's too short.""" + y_train = np.array([[[1.0]]]) # Only 1 time step + y_true = np.array([[[2.0]]]) + y_pred = np.array([[[2.0]]]) + + with pytest.raises(ValueError, match="must have at least 2 time steps"): + mase(y_true, y_pred, y_train) + + def test_mase_type_error(self): + """Test MASE raises error for non-numpy inputs.""" + y_train = [[1.0, 2.0]] + y_true = np.array([[[3.0]]]) + y_pred = np.array([[[3.0]]]) + + with pytest.raises(TypeError, match="must be numpy.ndarray"): + mase(y_true, y_pred, y_train) + + +class TestCRPS: + """Tests for Continuous Ranked Probability Score (CRPS) metric.""" + + def test_crps_perfect_prediction(self): + """Test CRPS returns 0 for perfect predictions.""" + y_true = np.array([[[5.0]]]) + quantile_preds = np.array([[[4.5, 5.0, 5.5]]]) # 10th, 50th, 90th + quantile_levels = [0.1, 0.5, 0.9] + + result = crps_from_quantiles(y_true, quantile_preds, quantile_levels, reduction="mean") + assert result == 0.0 + + def test_crps_known_values(self): + """Test CRPS with known input/output values.""" + y_true = np.array([[[5.0]]]) + quantile_preds = np.array([[[4.0, 5.0, 6.0]]]) + quantile_levels = [0.1, 0.5, 0.9] + + # Weights calculation: + # w[0] = 0.5 - 0.1 = 0.4 + # w[1] = (0.9 - 0.1) / 2 = 0.4 + # w[2] = 0.9 - 0.5 = 0.4 + # Normalized: all 0.4 / 1.2 = 1/3 + + # Errors: |5-4| = 1, |5-5| = 0, |5-6| = 1 + # CRPS = (1/3) * 1 + (1/3) * 0 + (1/3) * 1 = 2/3 + result = crps_from_quantiles(y_true, quantile_preds, quantile_levels, reduction="mean") + assert pytest.approx(result, rel=1e-6) == 2.0 / 3.0 + + def test_crps_single_quantile_equals_mae(self): + """Test CRPS with single quantile equals MAE.""" + y_true = np.array([[[5.0], [6.0]]]) + quantile_preds = np.array([[[5.5], [6.5]]]) + quantile_levels = [0.5] + + # Should equal MAE: (|5-5.5| + |6-6.5|) / 2 = 0.5 + result = crps_from_quantiles(y_true, quantile_preds, quantile_levels, reduction="mean") + assert pytest.approx(result, rel=1e-6) == 0.5 + + def test_crps_reduction_none(self): + """Test CRPS with reduction='none' returns per-sample metrics.""" + y_true = np.array([ + [[5.0]], + [[6.0]] + ]) + quantile_preds = np.array([ + [[5.0]], # Perfect prediction + [[7.0]] # Error of 1 + ]) + quantile_levels = [0.5] + + result = crps_from_quantiles(y_true, quantile_preds, quantile_levels, reduction="none") + + assert result.shape == (2,) + assert result[0] == 0.0 + assert result[1] == 1.0 + + def test_crps_multiple_quantiles(self): + """Test CRPS with many quantiles.""" + y_true = np.array([[[50.0]]]) + quantile_preds = np.array([[[40.0, 45.0, 50.0, 55.0, 60.0]]]) + quantile_levels = [0.05, 0.25, 0.5, 0.75, 0.95] + + result = crps_from_quantiles(y_true, quantile_preds, quantile_levels, reduction="mean") + + # Median is perfect, so CRPS should be positive but not too large + assert isinstance(result, float) + assert result > 0 + assert result < 20 # Reasonable bound + + def test_crps_batch_processing(self): + """Test CRPS with realistic batch size.""" + batch_size = 32 + horizon = 24 + num_quantiles = 9 + + y_true = np.random.randn(batch_size, horizon, 1) * 10 + 50 + quantile_preds = np.random.randn(batch_size, horizon, num_quantiles) * 10 + 50 + quantile_levels = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9] + + result = crps_from_quantiles(y_true, quantile_preds, quantile_levels, reduction="mean") + + assert isinstance(result, float) + assert result > 0 + + def test_crps_shape_mismatch_error(self): + """Test CRPS raises error for mismatched shapes.""" + y_true = np.array([[[5.0]]]) + quantile_preds = np.array([[[4.0, 5.0]]]) # Wrong horizon + quantile_levels = [0.1, 0.5] + + with pytest.raises(ValueError, match="Batch size mismatch"): + crps_from_quantiles( + y_true, + np.array([[[4.0, 5.0]], [[4.0, 5.0]]]), # Wrong batch + quantile_levels + ) + + def test_crps_quantile_length_mismatch_error(self): + """Test CRPS raises error when quantile_levels length doesn't match.""" + y_true = np.array([[[5.0]]]) + quantile_preds = np.array([[[4.0, 5.0, 6.0]]]) + quantile_levels = [0.1, 0.9] # Only 2, but preds has 3 + + with pytest.raises(ValueError, match="quantile_levels length.*must match"): + crps_from_quantiles(y_true, quantile_preds, quantile_levels) + + def test_crps_invalid_quantile_levels_error(self): + """Test CRPS raises error for invalid quantile levels.""" + y_true = np.array([[[5.0]]]) + quantile_preds = np.array([[[4.0, 5.0]]]) + quantile_levels = [0.1, 1.5] # 1.5 is invalid + + with pytest.raises(ValueError, match="quantile_levels must be in"): + crps_from_quantiles(y_true, quantile_preds, quantile_levels) + + def test_crps_unsorted_quantile_levels_error(self): + """Test CRPS raises error for unsorted quantile levels.""" + y_true = np.array([[[5.0]]]) + quantile_preds = np.array([[[4.0, 5.0]]]) + quantile_levels = [0.9, 0.1] # Not sorted + + with pytest.raises(ValueError, match="must be sorted in ascending order"): + crps_from_quantiles(y_true, quantile_preds, quantile_levels) + + def test_crps_multi_feature_error(self): + """Test CRPS raises error for multi-feature with wrong dimensions.""" + y_true = np.array([[[5.0, 6.0, 7.0]]]) # 3 features + quantile_preds = np.array([[[4.0, 5.0]]]) # 2 quantiles + quantile_levels = [0.1, 0.9] + + with pytest.raises(ValueError, match="features.*should be 1 or match num_quantiles"): + crps_from_quantiles(y_true, quantile_preds, quantile_levels) + + def test_crps_type_error_quantile_levels(self): + """Test CRPS raises error for wrong type of quantile_levels.""" + y_true = np.array([[[5.0]]]) + quantile_preds = np.array([[[4.0, 5.0]]]) + quantile_levels = np.array([0.1, 0.9]) # Should be list, not array + + with pytest.raises(TypeError, match="quantile_levels must be a list"): + crps_from_quantiles(y_true, quantile_preds, quantile_levels) + + def test_crps_empty_array_error(self): + """Test CRPS raises error for empty arrays.""" + y_true = np.array([]).reshape(1, 0, 1) + quantile_preds = np.array([]).reshape(1, 0, 3) + quantile_levels = [0.1, 0.5, 0.9] + + with pytest.raises(ValueError, match="cannot be empty"): + crps_from_quantiles(y_true, quantile_preds, quantile_levels) \ No newline at end of file diff --git a/tests/unit/test_eval_visualization.py b/tests/unit/test_eval_visualization.py new file mode 100644 index 0000000..53a5d1c --- /dev/null +++ b/tests/unit/test_eval_visualization.py @@ -0,0 +1,393 @@ +"""Unit tests for faim_sdk.eval.visualization module. + +Tests for plot_forecast with comprehensive coverage of functionality, +edge cases, and error handling. Uses matplotlib mocking where appropriate. +""" + +import numpy as np +import pytest + + +class TestPlotForecast: + """Tests for plot_forecast visualization function.""" + + @pytest.fixture(autouse=True) + def setup_matplotlib(self): + """Ensure matplotlib is available for tests.""" + try: + import matplotlib + matplotlib.use('Agg') # Use non-interactive backend for testing + except ImportError: + pytest.skip("matplotlib not available") + + def test_plot_forecast_basic(self): + """Test basic plot_forecast functionality.""" + from faim_sdk.eval import plot_forecast + + train_data = np.random.randn(100, 1) + forecast = np.random.randn(24, 1) + + fig, ax = plot_forecast(train_data, forecast) + + assert fig is not None + assert ax is not None + assert len(ax.lines) >= 2 # At least train and forecast lines + + def test_plot_forecast_with_test_data(self): + """Test plot_forecast with optional test data.""" + from faim_sdk.eval import plot_forecast + + train_data = np.random.randn(100, 1) + forecast = np.random.randn(24, 1) + test_data = np.random.randn(24, 1) + + fig, ax = plot_forecast(train_data, forecast, test_data) + + assert fig is not None + assert len(ax.lines) >= 3 # Train, forecast, and test lines + + def test_plot_forecast_single_feature_with_title(self): + """Test plot_forecast with custom title.""" + from faim_sdk.eval import plot_forecast + + train_data = np.random.randn(100, 1) + forecast = np.random.randn(24, 1) + + fig, ax = plot_forecast(train_data, forecast, title="Test Forecast") + + assert ax.get_title() == "Test Forecast" + + def test_plot_forecast_multi_feature_same_plot(self): + """Test plot_forecast with multiple features on same plot.""" + from faim_sdk.eval import plot_forecast + + train_data = np.random.randn(100, 3) + forecast = np.random.randn(24, 3) + test_data = np.random.randn(24, 3) + + fig, ax = plot_forecast( + train_data, + forecast, + test_data, + features_on_same_plot=True, + feature_names=["Feature A", "Feature B", "Feature C"] + ) + + assert fig is not None + # Should have 3 features × 3 lines (train, forecast, test) = 9 lines + vertical line + assert len(ax.lines) >= 9 + + def test_plot_forecast_multi_feature_subplots(self): + """Test plot_forecast with multiple features as subplots.""" + from faim_sdk.eval import plot_forecast + + train_data = np.random.randn(100, 3) + forecast = np.random.randn(24, 3) + + fig, axes = plot_forecast( + train_data, + forecast, + features_on_same_plot=False, + feature_names=["Temp", "Humidity", "Pressure"] + ) + + assert fig is not None + assert len(axes) == 3 # One subplot per feature + assert axes[0].get_title() == "Temp" + assert axes[1].get_title() == "Humidity" + assert axes[2].get_title() == "Pressure" + + def test_plot_forecast_custom_figsize(self): + """Test plot_forecast with custom figure size.""" + from faim_sdk.eval import plot_forecast + + train_data = np.random.randn(100, 1) + forecast = np.random.randn(24, 1) + + fig, ax = plot_forecast(train_data, forecast, figsize=(15, 8)) + + assert fig.get_figwidth() == 15 + assert fig.get_figheight() == 8 + + def test_plot_forecast_save_path(self, tmp_path): + """Test plot_forecast saves to file.""" + from faim_sdk.eval import plot_forecast + + train_data = np.random.randn(100, 1) + forecast = np.random.randn(24, 1) + + save_path = tmp_path / "forecast.png" + fig, ax = plot_forecast(train_data, forecast, save_path=str(save_path)) + + assert save_path.exists() + assert save_path.stat().st_size > 0 + + def test_plot_forecast_default_feature_names(self): + """Test plot_forecast generates default feature names.""" + from faim_sdk.eval import plot_forecast + + train_data = np.random.randn(100, 3) + forecast = np.random.randn(24, 3) + + fig, axes = plot_forecast( + train_data, + forecast, + features_on_same_plot=False + ) + + # Should use default names: Feature 1, Feature 2, Feature 3 + assert axes[0].get_title() == "Feature 1" + assert axes[1].get_title() == "Feature 2" + assert axes[2].get_title() == "Feature 3" + + def test_plot_forecast_single_feature_default_name(self): + """Test plot_forecast uses 'Series' for single feature.""" + from faim_sdk.eval import plot_forecast + + train_data = np.random.randn(100, 1) + forecast = np.random.randn(24, 1) + + fig, axes = plot_forecast( + train_data, + forecast, + features_on_same_plot=False + ) + + # Should use 'Series' for single feature + assert axes[0].get_title() == "Series" + + def test_plot_forecast_wrong_dimensions_train_error(self): + """Test plot_forecast raises error for wrong train_data dimensions.""" + from faim_sdk.eval import plot_forecast + + train_data = np.random.randn(32, 100, 1) # 3D instead of 2D + forecast = np.random.randn(24, 1) + + with pytest.raises(ValueError, match="train_data must be 2-dimensional"): + plot_forecast(train_data, forecast) + + def test_plot_forecast_wrong_dimensions_forecast_error(self): + """Test plot_forecast raises error for wrong forecast dimensions.""" + from faim_sdk.eval import plot_forecast + + train_data = np.random.randn(100, 1) + forecast = np.random.randn(32, 24, 1) # 3D instead of 2D + + with pytest.raises(ValueError, match="forecast must be 2-dimensional"): + plot_forecast(train_data, forecast) + + def test_plot_forecast_wrong_dimensions_test_error(self): + """Test plot_forecast raises error for wrong test_data dimensions.""" + from faim_sdk.eval import plot_forecast + + train_data = np.random.randn(100, 1) + forecast = np.random.randn(24, 1) + test_data = np.random.randn(32, 24, 1) # 3D instead of 2D + + with pytest.raises(ValueError, match="test_data must be 2-dimensional"): + plot_forecast(train_data, forecast, test_data) + + def test_plot_forecast_feature_mismatch_error(self): + """Test plot_forecast raises error for mismatched features.""" + from faim_sdk.eval import plot_forecast + + train_data = np.random.randn(100, 3) + forecast = np.random.randn(24, 2) # Wrong features + + with pytest.raises(ValueError, match="Feature count mismatch"): + plot_forecast(train_data, forecast) + + def test_plot_forecast_horizon_mismatch_error(self): + """Test plot_forecast raises error for mismatched horizons.""" + from faim_sdk.eval import plot_forecast + + train_data = np.random.randn(100, 1) + forecast = np.random.randn(24, 1) + test_data = np.random.randn(12, 1) # Wrong horizon + + with pytest.raises(ValueError, match="Horizon mismatch"): + plot_forecast(train_data, forecast, test_data) + + def test_plot_forecast_too_many_features_error(self): + """Test plot_forecast raises error for too many features on same plot.""" + from faim_sdk.eval import plot_forecast + + train_data = np.random.randn(100, 11) # 11 features + forecast = np.random.randn(24, 11) + + with pytest.raises(ValueError, match="Cannot plot 11 features on same plot"): + plot_forecast(train_data, forecast, features_on_same_plot=True) + + def test_plot_forecast_wrong_feature_names_length_error(self): + """Test plot_forecast raises error for wrong feature_names length.""" + from faim_sdk.eval import plot_forecast + + train_data = np.random.randn(100, 3) + forecast = np.random.randn(24, 3) + + with pytest.raises(ValueError, match="feature_names length.*must match"): + plot_forecast( + train_data, + forecast, + feature_names=["A", "B"] # Only 2, but 3 features + ) + + def test_plot_forecast_type_error_train(self): + """Test plot_forecast raises error for non-numpy train_data.""" + from faim_sdk.eval import plot_forecast + + train_data = [[1.0, 2.0]] # Python list + forecast = np.random.randn(24, 1) + + with pytest.raises(TypeError, match="train_data must be numpy.ndarray"): + plot_forecast(train_data, forecast) + + def test_plot_forecast_type_error_forecast(self): + """Test plot_forecast raises error for non-numpy forecast.""" + from faim_sdk.eval import plot_forecast + + train_data = np.random.randn(100, 1) + forecast = [[1.0, 2.0]] # Python list + + with pytest.raises(TypeError, match="forecast must be numpy.ndarray"): + plot_forecast(train_data, forecast) + + def test_plot_forecast_type_error_test(self): + """Test plot_forecast raises error for non-numpy test_data.""" + from faim_sdk.eval import plot_forecast + + train_data = np.random.randn(100, 1) + forecast = np.random.randn(24, 1) + test_data = [[1.0, 2.0]] # Python list + + with pytest.raises(TypeError, match="test_data must be numpy.ndarray or None"): + plot_forecast(train_data, forecast, test_data) + + def test_plot_forecast_empty_train_error(self): + """Test plot_forecast raises error for empty train_data.""" + from faim_sdk.eval import plot_forecast + + train_data = np.array([]).reshape(0, 1) + forecast = np.random.randn(24, 1) + + with pytest.raises(ValueError, match="train_data cannot be empty"): + plot_forecast(train_data, forecast) + + def test_plot_forecast_empty_forecast_error(self): + """Test plot_forecast raises error for empty forecast.""" + from faim_sdk.eval import plot_forecast + + train_data = np.random.randn(100, 1) + forecast = np.array([]).reshape(0, 1) + + with pytest.raises(ValueError, match="forecast cannot be empty"): + plot_forecast(train_data, forecast) + + def test_plot_forecast_helpful_error_message_batch_dim(self): + """Test plot_forecast provides helpful error for batch dimension.""" + from faim_sdk.eval import plot_forecast + + train_data = np.random.randn(32, 100, 1) # User forgot to index [i] + forecast = np.random.randn(24, 1) + + with pytest.raises(ValueError, match="Did you forget to index the batch dimension"): + plot_forecast(train_data, forecast) + + def test_plot_forecast_matplotlib_not_available_error(self, monkeypatch): + """Test plot_forecast raises error when matplotlib not available.""" + # This test simulates matplotlib not being installed + import sys + + # Remove matplotlib from modules + matplotlib_modules = [key for key in sys.modules if key.startswith('matplotlib')] + for mod in matplotlib_modules: + monkeypatch.delitem(sys.modules, mod, raising=False) + + # Mock import to fail + import builtins + original_import = builtins.__import__ + + def mock_import(name, *args, **kwargs): + if name.startswith('matplotlib'): + raise ImportError("No module named 'matplotlib'") + return original_import(name, *args, **kwargs) + + monkeypatch.setattr(builtins, '__import__', mock_import) + + # Force reload of visualization module + import importlib + import faim_sdk.eval + importlib.reload(faim_sdk.eval.visualization) + + from faim_sdk.eval.visualization import plot_forecast + + train_data = np.random.randn(100, 1) + forecast = np.random.randn(24, 1) + + with pytest.raises(ImportError, match="matplotlib is required"): + plot_forecast(train_data, forecast) + + def test_plot_forecast_legend_present(self): + """Test plot_forecast includes legend.""" + from faim_sdk.eval import plot_forecast + + train_data = np.random.randn(100, 1) + forecast = np.random.randn(24, 1) + + fig, ax = plot_forecast(train_data, forecast) + + legend = ax.get_legend() + assert legend is not None + assert len(legend.get_texts()) >= 2 # At least train and forecast + + def test_plot_forecast_grid_present(self): + """Test plot_forecast includes grid.""" + from faim_sdk.eval import plot_forecast + + train_data = np.random.randn(100, 1) + forecast = np.random.randn(24, 1) + + fig, ax = plot_forecast(train_data, forecast) + + # Check if grid is enabled + assert ax.xaxis.grid or ax.yaxis.grid + + def test_plot_forecast_vertical_line_at_boundary(self): + """Test plot_forecast includes vertical line at train/forecast boundary.""" + from faim_sdk.eval import plot_forecast + + train_data = np.random.randn(100, 1) + forecast = np.random.randn(24, 1) + + fig, ax = plot_forecast(train_data, forecast) + + # Check for vertical lines (boundary marker) + vertical_lines = [line for line in ax.lines if line.get_linestyle() == '-'] + # Should have at least one vertical line for the boundary + # (Plus the actual data lines) + assert len(ax.lines) >= 2 + + def test_plot_forecast_realistic_sdk_usage(self): + """Test plot_forecast with realistic SDK response format.""" + from faim_sdk.eval import plot_forecast + + # Simulate SDK response + batch_size = 32 + train_length = 100 + horizon = 24 + features = 1 + + train_batch = np.random.randn(batch_size, train_length, features) + forecast_batch = np.random.randn(batch_size, horizon, features) + test_batch = np.random.randn(batch_size, horizon, features) + + # Plot single sample (index batch dimension) + fig, ax = plot_forecast( + train_data=train_batch[0], # (100, 1) + forecast=forecast_batch[0], # (24, 1) + test_data=test_batch[0], # (24, 1) + title="Sample 1 Forecast" + ) + + assert fig is not None + assert ax.get_title() == "Sample 1 Forecast" \ No newline at end of file diff --git a/uv.lock b/uv.lock new file mode 100644 index 0000000..313db96 --- /dev/null +++ b/uv.lock @@ -0,0 +1,2059 @@ +version = 1 +revision = 3 +requires-python = ">=3.12" +resolution-markers = [ + "python_full_version >= '3.14'", + "python_full_version < '3.14'", +] + +[manifest] + +[manifest.dependency-groups] +dev = [ + { name = "jupyterlab", specifier = ">=4.4.10" }, + { name = "matplotlib", specifier = ">=3.10.7" }, + { name = "pandas", specifier = ">=2.3.3" }, + { name = "pyarrow", specifier = ">=22.0.0" }, + { name = "statsmodels", specifier = ">=0.14.5" }, +] + +[[package]] +name = "anyio" +version = "4.11.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "idna" }, + { name = "sniffio" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c6/78/7d432127c41b50bccba979505f272c16cbcadcc33645d5fa3a738110ae75/anyio-4.11.0.tar.gz", hash = "sha256:82a8d0b81e318cc5ce71a5f1f8b5c4e63619620b63141ef8c995fa0db95a57c4", size = 219094, upload-time = "2025-09-23T09:19:12.58Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/15/b3/9b1a8074496371342ec1e796a96f99c82c945a339cd81a8e73de28b4cf9e/anyio-4.11.0-py3-none-any.whl", hash = "sha256:0287e96f4d26d4149305414d4e3bc32f0dcd0862365a4bddea19d7a1ec38c4fc", size = 109097, upload-time = "2025-09-23T09:19:10.601Z" }, +] + +[[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 = "argon2-cffi" +version = "25.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "argon2-cffi-bindings" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/0e/89/ce5af8a7d472a67cc819d5d998aa8c82c5d860608c4db9f46f1162d7dab9/argon2_cffi-25.1.0.tar.gz", hash = "sha256:694ae5cc8a42f4c4e2bf2ca0e64e51e23a040c6a517a85074683d3959e1346c1", size = 45706, upload-time = "2025-06-03T06:55:32.073Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4f/d3/a8b22fa575b297cd6e3e3b0155c7e25db170edf1c74783d6a31a2490b8d9/argon2_cffi-25.1.0-py3-none-any.whl", hash = "sha256:fdc8b074db390fccb6eb4a3604ae7231f219aa669a2652e0f20e16ba513d5741", size = 14657, upload-time = "2025-06-03T06:55:30.804Z" }, +] + +[[package]] +name = "argon2-cffi-bindings" +version = "25.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/5c/2d/db8af0df73c1cf454f71b2bbe5e356b8c1f8041c979f505b3d3186e520a9/argon2_cffi_bindings-25.1.0.tar.gz", hash = "sha256:b957f3e6ea4d55d820e40ff76f450952807013d361a65d7f28acc0acbf29229d", size = 1783441, upload-time = "2025-07-30T10:02:05.147Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/60/97/3c0a35f46e52108d4707c44b95cfe2afcafc50800b5450c197454569b776/argon2_cffi_bindings-25.1.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:3d3f05610594151994ca9ccb3c771115bdb4daef161976a266f0dd8aa9996b8f", size = 54393, upload-time = "2025-07-30T10:01:40.97Z" }, + { url = "https://files.pythonhosted.org/packages/9d/f4/98bbd6ee89febd4f212696f13c03ca302b8552e7dbf9c8efa11ea4a388c3/argon2_cffi_bindings-25.1.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:8b8efee945193e667a396cbc7b4fb7d357297d6234d30a489905d96caabde56b", size = 29328, upload-time = "2025-07-30T10:01:41.916Z" }, + { url = "https://files.pythonhosted.org/packages/43/24/90a01c0ef12ac91a6be05969f29944643bc1e5e461155ae6559befa8f00b/argon2_cffi_bindings-25.1.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:3c6702abc36bf3ccba3f802b799505def420a1b7039862014a65db3205967f5a", size = 31269, upload-time = "2025-07-30T10:01:42.716Z" }, + { url = "https://files.pythonhosted.org/packages/d4/d3/942aa10782b2697eee7af5e12eeff5ebb325ccfb86dd8abda54174e377e4/argon2_cffi_bindings-25.1.0-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a1c70058c6ab1e352304ac7e3b52554daadacd8d453c1752e547c76e9c99ac44", size = 86558, upload-time = "2025-07-30T10:01:43.943Z" }, + { url = "https://files.pythonhosted.org/packages/0d/82/b484f702fec5536e71836fc2dbc8c5267b3f6e78d2d539b4eaa6f0db8bf8/argon2_cffi_bindings-25.1.0-cp314-cp314t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e2fd3bfbff3c5d74fef31a722f729bf93500910db650c925c2d6ef879a7e51cb", size = 92364, upload-time = "2025-07-30T10:01:44.887Z" }, + { url = "https://files.pythonhosted.org/packages/c9/c1/a606ff83b3f1735f3759ad0f2cd9e038a0ad11a3de3b6c673aa41c24bb7b/argon2_cffi_bindings-25.1.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c4f9665de60b1b0e99bcd6be4f17d90339698ce954cfd8d9cf4f91c995165a92", size = 85637, upload-time = "2025-07-30T10:01:46.225Z" }, + { url = "https://files.pythonhosted.org/packages/44/b4/678503f12aceb0262f84fa201f6027ed77d71c5019ae03b399b97caa2f19/argon2_cffi_bindings-25.1.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ba92837e4a9aa6a508c8d2d7883ed5a8f6c308c89a4790e1e447a220deb79a85", size = 91934, upload-time = "2025-07-30T10:01:47.203Z" }, + { url = "https://files.pythonhosted.org/packages/f0/c7/f36bd08ef9bd9f0a9cff9428406651f5937ce27b6c5b07b92d41f91ae541/argon2_cffi_bindings-25.1.0-cp314-cp314t-win32.whl", hash = "sha256:84a461d4d84ae1295871329b346a97f68eade8c53b6ed9a7ca2d7467f3c8ff6f", size = 28158, upload-time = "2025-07-30T10:01:48.341Z" }, + { url = "https://files.pythonhosted.org/packages/b3/80/0106a7448abb24a2c467bf7d527fe5413b7fdfa4ad6d6a96a43a62ef3988/argon2_cffi_bindings-25.1.0-cp314-cp314t-win_amd64.whl", hash = "sha256:b55aec3565b65f56455eebc9b9f34130440404f27fe21c3b375bf1ea4d8fbae6", size = 32597, upload-time = "2025-07-30T10:01:49.112Z" }, + { url = "https://files.pythonhosted.org/packages/05/b8/d663c9caea07e9180b2cb662772865230715cbd573ba3b5e81793d580316/argon2_cffi_bindings-25.1.0-cp314-cp314t-win_arm64.whl", hash = "sha256:87c33a52407e4c41f3b70a9c2d3f6056d88b10dad7695be708c5021673f55623", size = 28231, upload-time = "2025-07-30T10:01:49.92Z" }, + { url = "https://files.pythonhosted.org/packages/1d/57/96b8b9f93166147826da5f90376e784a10582dd39a393c99bb62cfcf52f0/argon2_cffi_bindings-25.1.0-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:aecba1723ae35330a008418a91ea6cfcedf6d31e5fbaa056a166462ff066d500", size = 54121, upload-time = "2025-07-30T10:01:50.815Z" }, + { url = "https://files.pythonhosted.org/packages/0a/08/a9bebdb2e0e602dde230bdde8021b29f71f7841bd54801bcfd514acb5dcf/argon2_cffi_bindings-25.1.0-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:2630b6240b495dfab90aebe159ff784d08ea999aa4b0d17efa734055a07d2f44", size = 29177, upload-time = "2025-07-30T10:01:51.681Z" }, + { url = "https://files.pythonhosted.org/packages/b6/02/d297943bcacf05e4f2a94ab6f462831dc20158614e5d067c35d4e63b9acb/argon2_cffi_bindings-25.1.0-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:7aef0c91e2c0fbca6fc68e7555aa60ef7008a739cbe045541e438373bc54d2b0", size = 31090, upload-time = "2025-07-30T10:01:53.184Z" }, + { url = "https://files.pythonhosted.org/packages/c1/93/44365f3d75053e53893ec6d733e4a5e3147502663554b4d864587c7828a7/argon2_cffi_bindings-25.1.0-cp39-abi3-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1e021e87faa76ae0d413b619fe2b65ab9a037f24c60a1e6cc43457ae20de6dc6", size = 81246, upload-time = "2025-07-30T10:01:54.145Z" }, + { url = "https://files.pythonhosted.org/packages/09/52/94108adfdd6e2ddf58be64f959a0b9c7d4ef2fa71086c38356d22dc501ea/argon2_cffi_bindings-25.1.0-cp39-abi3-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d3e924cfc503018a714f94a49a149fdc0b644eaead5d1f089330399134fa028a", size = 87126, upload-time = "2025-07-30T10:01:55.074Z" }, + { url = "https://files.pythonhosted.org/packages/72/70/7a2993a12b0ffa2a9271259b79cc616e2389ed1a4d93842fac5a1f923ffd/argon2_cffi_bindings-25.1.0-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:c87b72589133f0346a1cb8d5ecca4b933e3c9b64656c9d175270a000e73b288d", size = 80343, upload-time = "2025-07-30T10:01:56.007Z" }, + { url = "https://files.pythonhosted.org/packages/78/9a/4e5157d893ffc712b74dbd868c7f62365618266982b64accab26bab01edc/argon2_cffi_bindings-25.1.0-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:1db89609c06afa1a214a69a462ea741cf735b29a57530478c06eb81dd403de99", size = 86777, upload-time = "2025-07-30T10:01:56.943Z" }, + { url = "https://files.pythonhosted.org/packages/74/cd/15777dfde1c29d96de7f18edf4cc94c385646852e7c7b0320aa91ccca583/argon2_cffi_bindings-25.1.0-cp39-abi3-win32.whl", hash = "sha256:473bcb5f82924b1becbb637b63303ec8d10e84c8d241119419897a26116515d2", size = 27180, upload-time = "2025-07-30T10:01:57.759Z" }, + { url = "https://files.pythonhosted.org/packages/e2/c6/a759ece8f1829d1f162261226fbfd2c6832b3ff7657384045286d2afa384/argon2_cffi_bindings-25.1.0-cp39-abi3-win_amd64.whl", hash = "sha256:a98cd7d17e9f7ce244c0803cad3c23a7d379c301ba618a5fa76a67d116618b98", size = 31715, upload-time = "2025-07-30T10:01:58.56Z" }, + { url = "https://files.pythonhosted.org/packages/42/b9/f8d6fa329ab25128b7e98fd83a3cb34d9db5b059a9847eddb840a0af45dd/argon2_cffi_bindings-25.1.0-cp39-abi3-win_arm64.whl", hash = "sha256:b0fdbcf513833809c882823f98dc2f931cf659d9a1429616ac3adebb49f5db94", size = 27149, upload-time = "2025-07-30T10:01:59.329Z" }, +] + +[[package]] +name = "arrow" +version = "1.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "python-dateutil" }, + { name = "tzdata" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b9/33/032cdc44182491aa708d06a68b62434140d8c50820a087fac7af37703357/arrow-1.4.0.tar.gz", hash = "sha256:ed0cc050e98001b8779e84d461b0098c4ac597e88704a655582b21d116e526d7", size = 152931, upload-time = "2025-10-18T17:46:46.761Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ed/c9/d7977eaacb9df673210491da99e6a247e93df98c715fc43fd136ce1d3d33/arrow-1.4.0-py3-none-any.whl", hash = "sha256:749f0769958ebdc79c173ff0b0670d59051a535fa26e8eba02953dc19eb43205", size = 68797, upload-time = "2025-10-18T17:46:45.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 = "async-lru" +version = "2.0.5" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b2/4d/71ec4d3939dc755264f680f6c2b4906423a304c3d18e96853f0a595dfe97/async_lru-2.0.5.tar.gz", hash = "sha256:481d52ccdd27275f42c43a928b4a50c3bfb2d67af4e78b170e3e0bb39c66e5bb", size = 10380, upload-time = "2025-03-16T17:25:36.919Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/03/49/d10027df9fce941cb8184e78a02857af36360d33e1721df81c5ed2179a1a/async_lru-2.0.5-py3-none-any.whl", hash = "sha256:ab95404d8d2605310d345932697371a5f40def0487c03d6d0ad9138de52c9943", size = 6069, upload-time = "2025-03-16T17:25:35.422Z" }, +] + +[[package]] +name = "attrs" +version = "25.4.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6b/5c/685e6633917e101e5dcb62b9dd76946cbb57c26e133bae9e0cd36033c0a9/attrs-25.4.0.tar.gz", hash = "sha256:16d5969b87f0859ef33a48b35d55ac1be6e42ae49d5e853b597db70c35c57e11", size = 934251, upload-time = "2025-10-06T13:54:44.725Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3a/2a/7cc015f5b9f5db42b7d48157e23356022889fc354a2813c15934b7cb5c0e/attrs-25.4.0-py3-none-any.whl", hash = "sha256:adcf7e2a1fb3b36ac48d97835bb6d8ade15b8dcce26aba8bf1d14847b57a3373", size = 67615, upload-time = "2025-10-06T13:54:43.17Z" }, +] + +[[package]] +name = "babel" +version = "2.17.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7d/6b/d52e42361e1aa00709585ecc30b3f9684b3ab62530771402248b1b1d6240/babel-2.17.0.tar.gz", hash = "sha256:0c54cffb19f690cdcc52a3b50bcbf71e07a808d1c80d549f2459b9d2cf0afb9d", size = 9951852, upload-time = "2025-02-01T15:17:41.026Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b7/b8/3fe70c75fe32afc4bb507f75563d39bc5642255d1d94f1f23604725780bf/babel-2.17.0-py3-none-any.whl", hash = "sha256:4d0b53093fdfb4b21c92b5213dba5a1b23885afa8383709427046b21c366e5f2", size = 10182537, upload-time = "2025-02-01T15:17:37.39Z" }, +] + +[[package]] +name = "beautifulsoup4" +version = "4.14.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "soupsieve" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/77/e9/df2358efd7659577435e2177bfa69cba6c33216681af51a707193dec162a/beautifulsoup4-4.14.2.tar.gz", hash = "sha256:2a98ab9f944a11acee9cc848508ec28d9228abfd522ef0fad6a02a72e0ded69e", size = 625822, upload-time = "2025-09-29T10:05:42.613Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/94/fe/3aed5d0be4d404d12d36ab97e2f1791424d9ca39c2f754a6285d59a3b01d/beautifulsoup4-4.14.2-py3-none-any.whl", hash = "sha256:5ef6fa3a8cbece8488d66985560f97ed091e22bbc4e9c2338508a9d5de6d4515", size = 106392, upload-time = "2025-09-29T10:05:43.771Z" }, +] + +[[package]] +name = "bleach" +version = "6.3.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "webencodings" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/07/18/3c8523962314be6bf4c8989c79ad9531c825210dd13a8669f6b84336e8bd/bleach-6.3.0.tar.gz", hash = "sha256:6f3b91b1c0a02bb9a78b5a454c92506aa0fdf197e1d5e114d2e00c6f64306d22", size = 203533, upload-time = "2025-10-27T17:57:39.211Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cd/3a/577b549de0cc09d95f11087ee63c739bba856cd3952697eec4c4bb91350a/bleach-6.3.0-py3-none-any.whl", hash = "sha256:fe10ec77c93ddf3d13a73b035abaac7a9f5e436513864ccdad516693213c65d6", size = 164437, upload-time = "2025-10-27T17:57:37.538Z" }, +] + +[package.optional-dependencies] +css = [ + { name = "tinycss2" }, +] + +[[package]] +name = "certifi" +version = "2025.10.5" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/4c/5b/b6ce21586237c77ce67d01dc5507039d444b630dd76611bbca2d8e5dcd91/certifi-2025.10.5.tar.gz", hash = "sha256:47c09d31ccf2acf0be3f701ea53595ee7e0b8fa08801c6624be771df09ae7b43", size = 164519, upload-time = "2025-10-05T04:12:15.808Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e4/37/af0d2ef3967ac0d6113837b44a4f0bfe1328c2b9763bd5b1744520e5cfed/certifi-2025.10.5-py3-none-any.whl", hash = "sha256:0f212c2744a9bb6de0c56639a6f68afe01ecd92d91f14ae897c4fe7bbeeef0de", size = 163286, upload-time = "2025-10-05T04:12:14.03Z" }, +] + +[[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 = "charset-normalizer" +version = "3.4.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/13/69/33ddede1939fdd074bce5434295f38fae7136463422fe4fd3e0e89b98062/charset_normalizer-3.4.4.tar.gz", hash = "sha256:94537985111c35f28720e43603b8e7b43a6ecfb2ce1d3058bbe955b73404e21a", size = 129418, upload-time = "2025-10-14T04:42:32.879Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f3/85/1637cd4af66fa687396e757dec650f28025f2a2f5a5531a3208dc0ec43f2/charset_normalizer-3.4.4-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:0a98e6759f854bd25a58a73fa88833fba3b7c491169f86ce1180c948ab3fd394", size = 208425, upload-time = "2025-10-14T04:40:53.353Z" }, + { url = "https://files.pythonhosted.org/packages/9d/6a/04130023fef2a0d9c62d0bae2649b69f7b7d8d24ea5536feef50551029df/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b5b290ccc2a263e8d185130284f8501e3e36c5e02750fc6b6bdeb2e9e96f1e25", size = 148162, upload-time = "2025-10-14T04:40:54.558Z" }, + { url = "https://files.pythonhosted.org/packages/78/29/62328d79aa60da22c9e0b9a66539feae06ca0f5a4171ac4f7dc285b83688/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:74bb723680f9f7a6234dcf67aea57e708ec1fbdf5699fb91dfd6f511b0a320ef", size = 144558, upload-time = "2025-10-14T04:40:55.677Z" }, + { url = "https://files.pythonhosted.org/packages/86/bb/b32194a4bf15b88403537c2e120b817c61cd4ecffa9b6876e941c3ee38fe/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f1e34719c6ed0b92f418c7c780480b26b5d9c50349e9a9af7d76bf757530350d", size = 161497, upload-time = "2025-10-14T04:40:57.217Z" }, + { url = "https://files.pythonhosted.org/packages/19/89/a54c82b253d5b9b111dc74aca196ba5ccfcca8242d0fb64146d4d3183ff1/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2437418e20515acec67d86e12bf70056a33abdacb5cb1655042f6538d6b085a8", size = 159240, upload-time = "2025-10-14T04:40:58.358Z" }, + { url = "https://files.pythonhosted.org/packages/c0/10/d20b513afe03acc89ec33948320a5544d31f21b05368436d580dec4e234d/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:11d694519d7f29d6cd09f6ac70028dba10f92f6cdd059096db198c283794ac86", size = 153471, upload-time = "2025-10-14T04:40:59.468Z" }, + { url = "https://files.pythonhosted.org/packages/61/fa/fbf177b55bdd727010f9c0a3c49eefa1d10f960e5f09d1d887bf93c2e698/charset_normalizer-3.4.4-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ac1c4a689edcc530fc9d9aa11f5774b9e2f33f9a0c6a57864e90908f5208d30a", size = 150864, upload-time = "2025-10-14T04:41:00.623Z" }, + { url = "https://files.pythonhosted.org/packages/05/12/9fbc6a4d39c0198adeebbde20b619790e9236557ca59fc40e0e3cebe6f40/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:21d142cc6c0ec30d2efee5068ca36c128a30b0f2c53c1c07bd78cb6bc1d3be5f", size = 150647, upload-time = "2025-10-14T04:41:01.754Z" }, + { url = "https://files.pythonhosted.org/packages/ad/1f/6a9a593d52e3e8c5d2b167daf8c6b968808efb57ef4c210acb907c365bc4/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:5dbe56a36425d26d6cfb40ce79c314a2e4dd6211d51d6d2191c00bed34f354cc", size = 145110, upload-time = "2025-10-14T04:41:03.231Z" }, + { url = "https://files.pythonhosted.org/packages/30/42/9a52c609e72471b0fc54386dc63c3781a387bb4fe61c20231a4ebcd58bdd/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:5bfbb1b9acf3334612667b61bd3002196fe2a1eb4dd74d247e0f2a4d50ec9bbf", size = 162839, upload-time = "2025-10-14T04:41:04.715Z" }, + { url = "https://files.pythonhosted.org/packages/c4/5b/c0682bbf9f11597073052628ddd38344a3d673fda35a36773f7d19344b23/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:d055ec1e26e441f6187acf818b73564e6e6282709e9bcb5b63f5b23068356a15", size = 150667, upload-time = "2025-10-14T04:41:05.827Z" }, + { url = "https://files.pythonhosted.org/packages/e4/24/a41afeab6f990cf2daf6cb8c67419b63b48cf518e4f56022230840c9bfb2/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:af2d8c67d8e573d6de5bc30cdb27e9b95e49115cd9baad5ddbd1a6207aaa82a9", size = 160535, upload-time = "2025-10-14T04:41:06.938Z" }, + { url = "https://files.pythonhosted.org/packages/2a/e5/6a4ce77ed243c4a50a1fecca6aaaab419628c818a49434be428fe24c9957/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:780236ac706e66881f3b7f2f32dfe90507a09e67d1d454c762cf642e6e1586e0", size = 154816, upload-time = "2025-10-14T04:41:08.101Z" }, + { url = "https://files.pythonhosted.org/packages/a8/ef/89297262b8092b312d29cdb2517cb1237e51db8ecef2e9af5edbe7b683b1/charset_normalizer-3.4.4-cp312-cp312-win32.whl", hash = "sha256:5833d2c39d8896e4e19b689ffc198f08ea58116bee26dea51e362ecc7cd3ed26", size = 99694, upload-time = "2025-10-14T04:41:09.23Z" }, + { url = "https://files.pythonhosted.org/packages/3d/2d/1e5ed9dd3b3803994c155cd9aacb60c82c331bad84daf75bcb9c91b3295e/charset_normalizer-3.4.4-cp312-cp312-win_amd64.whl", hash = "sha256:a79cfe37875f822425b89a82333404539ae63dbdddf97f84dcbc3d339aae9525", size = 107131, upload-time = "2025-10-14T04:41:10.467Z" }, + { url = "https://files.pythonhosted.org/packages/d0/d9/0ed4c7098a861482a7b6a95603edce4c0d9db2311af23da1fb2b75ec26fc/charset_normalizer-3.4.4-cp312-cp312-win_arm64.whl", hash = "sha256:376bec83a63b8021bb5c8ea75e21c4ccb86e7e45ca4eb81146091b56599b80c3", size = 100390, upload-time = "2025-10-14T04:41:11.915Z" }, + { url = "https://files.pythonhosted.org/packages/97/45/4b3a1239bbacd321068ea6e7ac28875b03ab8bc0aa0966452db17cd36714/charset_normalizer-3.4.4-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:e1f185f86a6f3403aa2420e815904c67b2f9ebc443f045edd0de921108345794", size = 208091, upload-time = "2025-10-14T04:41:13.346Z" }, + { url = "https://files.pythonhosted.org/packages/7d/62/73a6d7450829655a35bb88a88fca7d736f9882a27eacdca2c6d505b57e2e/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b39f987ae8ccdf0d2642338faf2abb1862340facc796048b604ef14919e55ed", size = 147936, upload-time = "2025-10-14T04:41:14.461Z" }, + { url = "https://files.pythonhosted.org/packages/89/c5/adb8c8b3d6625bef6d88b251bbb0d95f8205831b987631ab0c8bb5d937c2/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3162d5d8ce1bb98dd51af660f2121c55d0fa541b46dff7bb9b9f86ea1d87de72", size = 144180, upload-time = "2025-10-14T04:41:15.588Z" }, + { url = "https://files.pythonhosted.org/packages/91/ed/9706e4070682d1cc219050b6048bfd293ccf67b3d4f5a4f39207453d4b99/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:81d5eb2a312700f4ecaa977a8235b634ce853200e828fbadf3a9c50bab278328", size = 161346, upload-time = "2025-10-14T04:41:16.738Z" }, + { url = "https://files.pythonhosted.org/packages/d5/0d/031f0d95e4972901a2f6f09ef055751805ff541511dc1252ba3ca1f80cf5/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5bd2293095d766545ec1a8f612559f6b40abc0eb18bb2f5d1171872d34036ede", size = 158874, upload-time = "2025-10-14T04:41:17.923Z" }, + { url = "https://files.pythonhosted.org/packages/f5/83/6ab5883f57c9c801ce5e5677242328aa45592be8a00644310a008d04f922/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a8a8b89589086a25749f471e6a900d3f662d1d3b6e2e59dcecf787b1cc3a1894", size = 153076, upload-time = "2025-10-14T04:41:19.106Z" }, + { url = "https://files.pythonhosted.org/packages/75/1e/5ff781ddf5260e387d6419959ee89ef13878229732732ee73cdae01800f2/charset_normalizer-3.4.4-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bc7637e2f80d8530ee4a78e878bce464f70087ce73cf7c1caf142416923b98f1", size = 150601, upload-time = "2025-10-14T04:41:20.245Z" }, + { url = "https://files.pythonhosted.org/packages/d7/57/71be810965493d3510a6ca79b90c19e48696fb1ff964da319334b12677f0/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f8bf04158c6b607d747e93949aa60618b61312fe647a6369f88ce2ff16043490", size = 150376, upload-time = "2025-10-14T04:41:21.398Z" }, + { url = "https://files.pythonhosted.org/packages/e5/d5/c3d057a78c181d007014feb7e9f2e65905a6c4ef182c0ddf0de2924edd65/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:554af85e960429cf30784dd47447d5125aaa3b99a6f0683589dbd27e2f45da44", size = 144825, upload-time = "2025-10-14T04:41:22.583Z" }, + { url = "https://files.pythonhosted.org/packages/e6/8c/d0406294828d4976f275ffbe66f00266c4b3136b7506941d87c00cab5272/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:74018750915ee7ad843a774364e13a3db91682f26142baddf775342c3f5b1133", size = 162583, upload-time = "2025-10-14T04:41:23.754Z" }, + { url = "https://files.pythonhosted.org/packages/d7/24/e2aa1f18c8f15c4c0e932d9287b8609dd30ad56dbe41d926bd846e22fb8d/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:c0463276121fdee9c49b98908b3a89c39be45d86d1dbaa22957e38f6321d4ce3", size = 150366, upload-time = "2025-10-14T04:41:25.27Z" }, + { url = "https://files.pythonhosted.org/packages/e4/5b/1e6160c7739aad1e2df054300cc618b06bf784a7a164b0f238360721ab86/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:362d61fd13843997c1c446760ef36f240cf81d3ebf74ac62652aebaf7838561e", size = 160300, upload-time = "2025-10-14T04:41:26.725Z" }, + { url = "https://files.pythonhosted.org/packages/7a/10/f882167cd207fbdd743e55534d5d9620e095089d176d55cb22d5322f2afd/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9a26f18905b8dd5d685d6d07b0cdf98a79f3c7a918906af7cc143ea2e164c8bc", size = 154465, upload-time = "2025-10-14T04:41:28.322Z" }, + { url = "https://files.pythonhosted.org/packages/89/66/c7a9e1b7429be72123441bfdbaf2bc13faab3f90b933f664db506dea5915/charset_normalizer-3.4.4-cp313-cp313-win32.whl", hash = "sha256:9b35f4c90079ff2e2edc5b26c0c77925e5d2d255c42c74fdb70fb49b172726ac", size = 99404, upload-time = "2025-10-14T04:41:29.95Z" }, + { url = "https://files.pythonhosted.org/packages/c4/26/b9924fa27db384bdcd97ab83b4f0a8058d96ad9626ead570674d5e737d90/charset_normalizer-3.4.4-cp313-cp313-win_amd64.whl", hash = "sha256:b435cba5f4f750aa6c0a0d92c541fb79f69a387c91e61f1795227e4ed9cece14", size = 107092, upload-time = "2025-10-14T04:41:31.188Z" }, + { url = "https://files.pythonhosted.org/packages/af/8f/3ed4bfa0c0c72a7ca17f0380cd9e4dd842b09f664e780c13cff1dcf2ef1b/charset_normalizer-3.4.4-cp313-cp313-win_arm64.whl", hash = "sha256:542d2cee80be6f80247095cc36c418f7bddd14f4a6de45af91dfad36d817bba2", size = 100408, upload-time = "2025-10-14T04:41:32.624Z" }, + { url = "https://files.pythonhosted.org/packages/2a/35/7051599bd493e62411d6ede36fd5af83a38f37c4767b92884df7301db25d/charset_normalizer-3.4.4-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:da3326d9e65ef63a817ecbcc0df6e94463713b754fe293eaa03da99befb9a5bd", size = 207746, upload-time = "2025-10-14T04:41:33.773Z" }, + { url = "https://files.pythonhosted.org/packages/10/9a/97c8d48ef10d6cd4fcead2415523221624bf58bcf68a802721a6bc807c8f/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8af65f14dc14a79b924524b1e7fffe304517b2bff5a58bf64f30b98bbc5079eb", size = 147889, upload-time = "2025-10-14T04:41:34.897Z" }, + { url = "https://files.pythonhosted.org/packages/10/bf/979224a919a1b606c82bd2c5fa49b5c6d5727aa47b4312bb27b1734f53cd/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:74664978bb272435107de04e36db5a9735e78232b85b77d45cfb38f758efd33e", size = 143641, upload-time = "2025-10-14T04:41:36.116Z" }, + { url = "https://files.pythonhosted.org/packages/ba/33/0ad65587441fc730dc7bd90e9716b30b4702dc7b617e6ba4997dc8651495/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:752944c7ffbfdd10c074dc58ec2d5a8a4cd9493b314d367c14d24c17684ddd14", size = 160779, upload-time = "2025-10-14T04:41:37.229Z" }, + { url = "https://files.pythonhosted.org/packages/67/ed/331d6b249259ee71ddea93f6f2f0a56cfebd46938bde6fcc6f7b9a3d0e09/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d1f13550535ad8cff21b8d757a3257963e951d96e20ec82ab44bc64aeb62a191", size = 159035, upload-time = "2025-10-14T04:41:38.368Z" }, + { url = "https://files.pythonhosted.org/packages/67/ff/f6b948ca32e4f2a4576aa129d8bed61f2e0543bf9f5f2b7fc3758ed005c9/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ecaae4149d99b1c9e7b88bb03e3221956f68fd6d50be2ef061b2381b61d20838", size = 152542, upload-time = "2025-10-14T04:41:39.862Z" }, + { url = "https://files.pythonhosted.org/packages/16/85/276033dcbcc369eb176594de22728541a925b2632f9716428c851b149e83/charset_normalizer-3.4.4-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:cb6254dc36b47a990e59e1068afacdcd02958bdcce30bb50cc1700a8b9d624a6", size = 149524, upload-time = "2025-10-14T04:41:41.319Z" }, + { url = "https://files.pythonhosted.org/packages/9e/f2/6a2a1f722b6aba37050e626530a46a68f74e63683947a8acff92569f979a/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c8ae8a0f02f57a6e61203a31428fa1d677cbe50c93622b4149d5c0f319c1d19e", size = 150395, upload-time = "2025-10-14T04:41:42.539Z" }, + { url = "https://files.pythonhosted.org/packages/60/bb/2186cb2f2bbaea6338cad15ce23a67f9b0672929744381e28b0592676824/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:47cc91b2f4dd2833fddaedd2893006b0106129d4b94fdb6af1f4ce5a9965577c", size = 143680, upload-time = "2025-10-14T04:41:43.661Z" }, + { url = "https://files.pythonhosted.org/packages/7d/a5/bf6f13b772fbb2a90360eb620d52ed8f796f3c5caee8398c3b2eb7b1c60d/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:82004af6c302b5d3ab2cfc4cc5f29db16123b1a8417f2e25f9066f91d4411090", size = 162045, upload-time = "2025-10-14T04:41:44.821Z" }, + { url = "https://files.pythonhosted.org/packages/df/c5/d1be898bf0dc3ef9030c3825e5d3b83f2c528d207d246cbabe245966808d/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:2b7d8f6c26245217bd2ad053761201e9f9680f8ce52f0fcd8d0755aeae5b2152", size = 149687, upload-time = "2025-10-14T04:41:46.442Z" }, + { url = "https://files.pythonhosted.org/packages/a5/42/90c1f7b9341eef50c8a1cb3f098ac43b0508413f33affd762855f67a410e/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:799a7a5e4fb2d5898c60b640fd4981d6a25f1c11790935a44ce38c54e985f828", size = 160014, upload-time = "2025-10-14T04:41:47.631Z" }, + { url = "https://files.pythonhosted.org/packages/76/be/4d3ee471e8145d12795ab655ece37baed0929462a86e72372fd25859047c/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:99ae2cffebb06e6c22bdc25801d7b30f503cc87dbd283479e7b606f70aff57ec", size = 154044, upload-time = "2025-10-14T04:41:48.81Z" }, + { url = "https://files.pythonhosted.org/packages/b0/6f/8f7af07237c34a1defe7defc565a9bc1807762f672c0fde711a4b22bf9c0/charset_normalizer-3.4.4-cp314-cp314-win32.whl", hash = "sha256:f9d332f8c2a2fcbffe1378594431458ddbef721c1769d78e2cbc06280d8155f9", size = 99940, upload-time = "2025-10-14T04:41:49.946Z" }, + { url = "https://files.pythonhosted.org/packages/4b/51/8ade005e5ca5b0d80fb4aff72a3775b325bdc3d27408c8113811a7cbe640/charset_normalizer-3.4.4-cp314-cp314-win_amd64.whl", hash = "sha256:8a6562c3700cce886c5be75ade4a5db4214fda19fede41d9792d100288d8f94c", size = 107104, upload-time = "2025-10-14T04:41:51.051Z" }, + { url = "https://files.pythonhosted.org/packages/da/5f/6b8f83a55bb8278772c5ae54a577f3099025f9ade59d0136ac24a0df4bde/charset_normalizer-3.4.4-cp314-cp314-win_arm64.whl", hash = "sha256:de00632ca48df9daf77a2c65a484531649261ec9f25489917f09e455cb09ddb2", size = 100743, upload-time = "2025-10-14T04:41:52.122Z" }, + { url = "https://files.pythonhosted.org/packages/0a/4c/925909008ed5a988ccbb72dcc897407e5d6d3bd72410d69e051fc0c14647/charset_normalizer-3.4.4-py3-none-any.whl", hash = "sha256:7a32c560861a02ff789ad905a2fe94e3f840803362c84fecf1851cb4cf3dc37f", size = 53402, upload-time = "2025-10-14T04:42:31.76Z" }, +] + +[[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 = "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 = "defusedxml" +version = "0.7.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0f/d5/c66da9b79e5bdb124974bfe172b4daf3c984ebd9c2a06e2b8a4dc7331c72/defusedxml-0.7.1.tar.gz", hash = "sha256:1bb3032db185915b62d7c6209c5a8792be6a32ab2fedacc84e01b52c51aa3e69", size = 75520, upload-time = "2021-03-08T10:59:26.269Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/07/6c/aa3f2f849e01cb6a001cd8554a88d4c77c5c1a31c95bdf1cf9301e6d9ef4/defusedxml-0.7.1-py2.py3-none-any.whl", hash = "sha256:a352e7e428770286cc899e2542b6cdaedb2b4953ff269a210103ec58f6198a61", size = 25604, upload-time = "2021-03-08T10:59:24.45Z" }, +] + +[[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 = "fastjsonschema" +version = "2.21.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/20/b5/23b216d9d985a956623b6bd12d4086b60f0059b27799f23016af04a74ea1/fastjsonschema-2.21.2.tar.gz", hash = "sha256:b1eb43748041c880796cd077f1a07c3d94e93ae84bba5ed36800a33554ae05de", size = 374130, upload-time = "2025-08-14T18:49:36.666Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cb/a8/20d0723294217e47de6d9e2e40fd4a9d2f7c4b6ef974babd482a59743694/fastjsonschema-2.21.2-py3-none-any.whl", hash = "sha256:1c797122d0a86c5cace2e54bf4e819c36223b552017172f32c5c024a6b77e463", size = 24024, upload-time = "2025-08-14T18:49:34.776Z" }, +] + +[[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 = "fqdn" +version = "1.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/30/3e/a80a8c077fd798951169626cde3e239adeba7dab75deb3555716415bd9b0/fqdn-1.5.1.tar.gz", hash = "sha256:105ed3677e767fb5ca086a0c1f4bb66ebc3c100be518f0e0d755d9eae164d89f", size = 6015, upload-time = "2021-03-11T07:16:29.08Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cf/58/8acf1b3e91c58313ce5cb67df61001fc9dcd21be4fadb76c1a2d540e09ed/fqdn-1.5.1-py3-none-any.whl", hash = "sha256:3a179af3761e4df6eb2e026ff9e1a3033d3587bf980a0b1b2e1e5d08d7358014", size = 9121, upload-time = "2021-03-11T07:16:28.351Z" }, +] + +[[package]] +name = "h11" +version = "0.16.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" }, +] + +[[package]] +name = "httpcore" +version = "1.0.9" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "h11" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" }, +] + +[[package]] +name = "httpx" +version = "0.28.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "certifi" }, + { name = "httpcore" }, + { name = "idna" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" }, +] + +[[package]] +name = "idna" +version = "3.11" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6f/6d/0703ccc57f3a7233505399edb88de3cbd678da106337b9fcde432b65ed60/idna-3.11.tar.gz", hash = "sha256:795dafcc9c04ed0c1fb032c2aa73654d8e8c5023a7df64a53f39190ada629902", size = 194582, upload-time = "2025-10-12T14:55:20.501Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0e/61/66938bbb5fc52dbdf84594873d5b51fb1f7c7794e9c0f5bd885f30bc507b/idna-3.11-py3-none-any.whl", hash = "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea", size = 71008, upload-time = "2025-10-12T14:55:18.883Z" }, +] + +[[package]] +name = "ipykernel" +version = "7.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "appnope", marker = "sys_platform == 'darwin'" }, + { name = "comm" }, + { name = "debugpy" }, + { name = "ipython" }, + { name = "jupyter-client" }, + { name = "jupyter-core" }, + { name = "matplotlib-inline" }, + { name = "nest-asyncio" }, + { name = "packaging" }, + { name = "psutil" }, + { name = "pyzmq" }, + { name = "tornado" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b9/a4/4948be6eb88628505b83a1f2f40d90254cab66abf2043b3c40fa07dfce0f/ipykernel-7.1.0.tar.gz", hash = "sha256:58a3fc88533d5930c3546dc7eac66c6d288acde4f801e2001e65edc5dc9cf0db", size = 174579, upload-time = "2025-10-27T09:46:39.471Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a3/17/20c2552266728ceba271967b87919664ecc0e33efca29c3efc6baf88c5f9/ipykernel-7.1.0-py3-none-any.whl", hash = "sha256:763b5ec6c5b7776f6a8d7ce09b267693b4e5ce75cb50ae696aaefb3c85e1ea4c", size = 117968, upload-time = "2025-10-27T09:46:37.805Z" }, +] + +[[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 = "isoduration" +version = "20.11.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "arrow" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/7c/1a/3c8edc664e06e6bd06cce40c6b22da5f1429aa4224d0c590f3be21c91ead/isoduration-20.11.0.tar.gz", hash = "sha256:ac2f9015137935279eac671f94f89eb00584f940f5dc49462a0c4ee692ba1bd9", size = 11649, upload-time = "2020-11-01T11:00:00.312Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7b/55/e5326141505c5d5e34c5e0935d2908a74e4561eca44108fbfb9c13d2911a/isoduration-20.11.0-py3-none-any.whl", hash = "sha256:b2904c2a4228c3d44f409c8ae8e2370eb21a26f7ac2ec5446df141dde3452042", size = 11321, upload-time = "2020-11-01T10:59:58.02Z" }, +] + +[[package]] +name = "jedi" +version = "0.19.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "parso" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/72/3a/79a912fbd4d8dd6fbb02bf69afd3bb72cf0c729bb3063c6f4498603db17a/jedi-0.19.2.tar.gz", hash = "sha256:4770dc3de41bde3966b02eb84fbcf557fb33cce26ad23da12c742fb50ecb11f0", size = 1231287, upload-time = "2024-11-11T01:41:42.873Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c0/5a/9cac0c82afec3d09ccd97c8b6502d48f165f9124db81b4bcb90b4af974ee/jedi-0.19.2-py2.py3-none-any.whl", hash = "sha256:a8ef22bde8490f57fe5c7681a3c83cb58874daf72b4784de3cce5b6ef6edb5b9", size = 1572278, upload-time = "2024-11-11T01:41:40.175Z" }, +] + +[[package]] +name = "jinja2" +version = "3.1.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markupsafe" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d", size = 245115, upload-time = "2025-03-05T20:05:02.478Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899, upload-time = "2025-03-05T20:05:00.369Z" }, +] + +[[package]] +name = "json5" +version = "0.12.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/12/ae/929aee9619e9eba9015207a9d2c1c54db18311da7eb4dcf6d41ad6f0eb67/json5-0.12.1.tar.gz", hash = "sha256:b2743e77b3242f8d03c143dd975a6ec7c52e2f2afe76ed934e53503dd4ad4990", size = 52191, upload-time = "2025-08-12T19:47:42.583Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/85/e2/05328bd2621be49a6fed9e3030b1e51a2d04537d3f816d211b9cc53c5262/json5-0.12.1-py3-none-any.whl", hash = "sha256:d9c9b3bc34a5f54d43c35e11ef7cb87d8bdd098c6ace87117a7b7e83e705c1d5", size = 36119, upload-time = "2025-08-12T19:47:41.131Z" }, +] + +[[package]] +name = "jsonpointer" +version = "3.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6a/0a/eebeb1fa92507ea94016a2a790b93c2ae41a7e18778f85471dc54475ed25/jsonpointer-3.0.0.tar.gz", hash = "sha256:2b2d729f2091522d61c3b31f82e11870f60b68f43fbc705cb76bf4b832af59ef", size = 9114, upload-time = "2024-06-10T19:24:42.462Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/71/92/5e77f98553e9e75130c78900d000368476aed74276eb8ae8796f65f00918/jsonpointer-3.0.0-py2.py3-none-any.whl", hash = "sha256:13e088adc14fca8b6aa8177c044e12701e6ad4b28ff10e65f2267a90109c9942", size = 7595, upload-time = "2024-06-10T19:24:40.698Z" }, +] + +[[package]] +name = "jsonschema" +version = "4.25.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "attrs" }, + { name = "jsonschema-specifications" }, + { name = "referencing" }, + { name = "rpds-py" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/74/69/f7185de793a29082a9f3c7728268ffb31cb5095131a9c139a74078e27336/jsonschema-4.25.1.tar.gz", hash = "sha256:e4a9655ce0da0c0b67a085847e00a3a51449e1157f4f75e9fb5aa545e122eb85", size = 357342, upload-time = "2025-08-18T17:03:50.038Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bf/9c/8c95d856233c1f82500c2450b8c68576b4cf1c871db3afac5c34ff84e6fd/jsonschema-4.25.1-py3-none-any.whl", hash = "sha256:3fba0169e345c7175110351d456342c364814cfcf3b964ba4587f22915230a63", size = 90040, upload-time = "2025-08-18T17:03:48.373Z" }, +] + +[package.optional-dependencies] +format-nongpl = [ + { name = "fqdn" }, + { name = "idna" }, + { name = "isoduration" }, + { name = "jsonpointer" }, + { name = "rfc3339-validator" }, + { name = "rfc3986-validator" }, + { name = "rfc3987-syntax" }, + { name = "uri-template" }, + { name = "webcolors" }, +] + +[[package]] +name = "jsonschema-specifications" +version = "2025.9.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "referencing" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/19/74/a633ee74eb36c44aa6d1095e7cc5569bebf04342ee146178e2d36600708b/jsonschema_specifications-2025.9.1.tar.gz", hash = "sha256:b540987f239e745613c7a9176f3edb72b832a4ac465cf02712288397832b5e8d", size = 32855, upload-time = "2025-09-08T01:34:59.186Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/41/45/1a4ed80516f02155c51f51e8cedb3c1902296743db0bbc66608a0db2814f/jsonschema_specifications-2025.9.1-py3-none-any.whl", hash = "sha256:98802fee3a11ee76ecaca44429fda8a41bff98b00a0f2838151b113f210cc6fe", size = 18437, upload-time = "2025-09-08T01:34:57.871Z" }, +] + +[[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.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "platformdirs" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/02/49/9d1284d0dc65e2c757b74c6687b6d319b02f822ad039e5c512df9194d9dd/jupyter_core-5.9.1.tar.gz", hash = "sha256:4d09aaff303b9566c3ce657f580bd089ff5c91f5f89cf7d8846c3cdf465b5508", size = 89814, upload-time = "2025-10-16T19:19:18.444Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e7/e7/80988e32bf6f73919a113473a604f5a8f09094de312b9d52b79c2df7612b/jupyter_core-5.9.1-py3-none-any.whl", hash = "sha256:ebf87fdc6073d142e114c72c9e29a9d7ca03fad818c5d300ce2adc1fb0743407", size = 29032, upload-time = "2025-10-16T19:19:16.783Z" }, +] + +[[package]] +name = "jupyter-events" +version = "0.12.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jsonschema", extra = ["format-nongpl"] }, + { name = "packaging" }, + { name = "python-json-logger" }, + { name = "pyyaml" }, + { name = "referencing" }, + { name = "rfc3339-validator" }, + { name = "rfc3986-validator" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9d/c3/306d090461e4cf3cd91eceaff84bede12a8e52cd821c2d20c9a4fd728385/jupyter_events-0.12.0.tar.gz", hash = "sha256:fc3fce98865f6784c9cd0a56a20644fc6098f21c8c33834a8d9fe383c17e554b", size = 62196, upload-time = "2025-02-03T17:23:41.485Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e2/48/577993f1f99c552f18a0428731a755e06171f9902fa118c379eb7c04ea22/jupyter_events-0.12.0-py3-none-any.whl", hash = "sha256:6464b2fa5ad10451c3d35fabc75eab39556ae1e2853ad0c0cc31b656731a97fb", size = 19430, upload-time = "2025-02-03T17:23:38.643Z" }, +] + +[[package]] +name = "jupyter-lsp" +version = "2.3.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-server" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/eb/5a/9066c9f8e94ee517133cd98dba393459a16cd48bba71a82f16a65415206c/jupyter_lsp-2.3.0.tar.gz", hash = "sha256:458aa59339dc868fb784d73364f17dbce8836e906cd75fd471a325cba02e0245", size = 54823, upload-time = "2025-08-27T17:47:34.671Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1a/60/1f6cee0c46263de1173894f0fafcb3475ded276c472c14d25e0280c18d6d/jupyter_lsp-2.3.0-py3-none-any.whl", hash = "sha256:e914a3cb2addf48b1c7710914771aaf1819d46b2e5a79b0f917b5478ec93f34f", size = 76687, upload-time = "2025-08-27T17:47:33.15Z" }, +] + +[[package]] +name = "jupyter-server" +version = "2.17.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "argon2-cffi" }, + { name = "jinja2" }, + { name = "jupyter-client" }, + { name = "jupyter-core" }, + { name = "jupyter-events" }, + { name = "jupyter-server-terminals" }, + { name = "nbconvert" }, + { name = "nbformat" }, + { name = "packaging" }, + { name = "prometheus-client" }, + { name = "pywinpty", marker = "os_name == 'nt'" }, + { name = "pyzmq" }, + { name = "send2trash" }, + { name = "terminado" }, + { name = "tornado" }, + { name = "traitlets" }, + { name = "websocket-client" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/5b/ac/e040ec363d7b6b1f11304cc9f209dac4517ece5d5e01821366b924a64a50/jupyter_server-2.17.0.tar.gz", hash = "sha256:c38ea898566964c888b4772ae1ed58eca84592e88251d2cfc4d171f81f7e99d5", size = 731949, upload-time = "2025-08-21T14:42:54.042Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/92/80/a24767e6ca280f5a49525d987bf3e4d7552bf67c8be07e8ccf20271f8568/jupyter_server-2.17.0-py3-none-any.whl", hash = "sha256:e8cb9c7db4251f51ed307e329b81b72ccf2056ff82d50524debde1ee1870e13f", size = 388221, upload-time = "2025-08-21T14:42:52.034Z" }, +] + +[[package]] +name = "jupyter-server-terminals" +version = "0.5.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pywinpty", marker = "os_name == 'nt'" }, + { name = "terminado" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/fc/d5/562469734f476159e99a55426d697cbf8e7eb5efe89fb0e0b4f83a3d3459/jupyter_server_terminals-0.5.3.tar.gz", hash = "sha256:5ae0295167220e9ace0edcfdb212afd2b01ee8d179fe6f23c899590e9b8a5269", size = 31430, upload-time = "2024-03-12T14:37:03.049Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/07/2d/2b32cdbe8d2a602f697a649798554e4f072115438e92249624e532e8aca6/jupyter_server_terminals-0.5.3-py3-none-any.whl", hash = "sha256:41ee0d7dc0ebf2809c668e0fc726dfaf258fcd3e769568996ca731b6194ae9aa", size = 13656, upload-time = "2024-03-12T14:37:00.708Z" }, +] + +[[package]] +name = "jupyterlab" +version = "4.4.10" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "async-lru" }, + { name = "httpx" }, + { name = "ipykernel" }, + { name = "jinja2" }, + { name = "jupyter-core" }, + { name = "jupyter-lsp" }, + { name = "jupyter-server" }, + { name = "jupyterlab-server" }, + { name = "notebook-shim" }, + { name = "packaging" }, + { name = "setuptools" }, + { name = "tornado" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6a/5d/75c42a48ff5fc826a7dff3fe4004cda47c54f9d981c351efacfbc9139d3c/jupyterlab-4.4.10.tar.gz", hash = "sha256:521c017508af4e1d6d9d8a9d90f47a11c61197ad63b2178342489de42540a615", size = 22969303, upload-time = "2025-10-22T14:50:58.768Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f7/46/1eaa5db8d54a594bdade67afbcae42e9a2da676628be3eb39f36dcff6390/jupyterlab-4.4.10-py3-none-any.whl", hash = "sha256:65939ab4c8dcd0c42185c2d0d1a9d60b254dc8c46fc4fdb286b63c51e9358e07", size = 12293385, upload-time = "2025-10-22T14:50:54.075Z" }, +] + +[[package]] +name = "jupyterlab-pygments" +version = "0.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/90/51/9187be60d989df97f5f0aba133fa54e7300f17616e065d1ada7d7646b6d6/jupyterlab_pygments-0.3.0.tar.gz", hash = "sha256:721aca4d9029252b11cfa9d185e5b5af4d54772bb8072f9b7036f4170054d35d", size = 512900, upload-time = "2023-11-23T09:26:37.44Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b1/dd/ead9d8ea85bf202d90cc513b533f9c363121c7792674f78e0d8a854b63b4/jupyterlab_pygments-0.3.0-py3-none-any.whl", hash = "sha256:841a89020971da1d8693f1a99997aefc5dc424bb1b251fd6322462a1b8842780", size = 15884, upload-time = "2023-11-23T09:26:34.325Z" }, +] + +[[package]] +name = "jupyterlab-server" +version = "2.28.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "babel" }, + { name = "jinja2" }, + { name = "json5" }, + { name = "jsonschema" }, + { name = "jupyter-server" }, + { name = "packaging" }, + { name = "requests" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/d6/2c/90153f189e421e93c4bb4f9e3f59802a1f01abd2ac5cf40b152d7f735232/jupyterlab_server-2.28.0.tar.gz", hash = "sha256:35baa81898b15f93573e2deca50d11ac0ae407ebb688299d3a5213265033712c", size = 76996, upload-time = "2025-10-22T13:59:18.37Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e0/07/a000fe835f76b7e1143242ab1122e6362ef1c03f23f83a045c38859c2ae0/jupyterlab_server-2.28.0-py3-none-any.whl", hash = "sha256:e4355b148fdcf34d312bbbc80f22467d6d20460e8b8736bf235577dd18506968", size = 59830, upload-time = "2025-10-22T13:59:16.767Z" }, +] + +[[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 = "lark" +version = "1.3.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/da/34/28fff3ab31ccff1fd4f6c7c7b0ceb2b6968d8ea4950663eadcb5720591a0/lark-1.3.1.tar.gz", hash = "sha256:b426a7a6d6d53189d318f2b6236ab5d6429eaf09259f1ca33eb716eed10d2905", size = 382732, upload-time = "2025-10-27T18:25:56.653Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/82/3d/14ce75ef66813643812f3093ab17e46d3a206942ce7376d31ec2d36229e7/lark-1.3.1-py3-none-any.whl", hash = "sha256:c629b661023a014c37da873b4ff58a817398d12635d3bbb2c5a03be7fe5d1e12", size = 113151, upload-time = "2025-10-27T18:25:54.882Z" }, +] + +[[package]] +name = "markupsafe" +version = "3.0.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7e/99/7690b6d4034fffd95959cbe0c02de8deb3098cc577c67bb6a24fe5d7caa7/markupsafe-3.0.3.tar.gz", hash = "sha256:722695808f4b6457b320fdc131280796bdceb04ab50fe1795cd540799ebe1698", size = 80313, upload-time = "2025-09-27T18:37:40.426Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5a/72/147da192e38635ada20e0a2e1a51cf8823d2119ce8883f7053879c2199b5/markupsafe-3.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d53197da72cc091b024dd97249dfc7794d6a56530370992a5e1a08983ad9230e", size = 11615, upload-time = "2025-09-27T18:36:30.854Z" }, + { url = "https://files.pythonhosted.org/packages/9a/81/7e4e08678a1f98521201c3079f77db69fb552acd56067661f8c2f534a718/markupsafe-3.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1872df69a4de6aead3491198eaf13810b565bdbeec3ae2dc8780f14458ec73ce", size = 12020, upload-time = "2025-09-27T18:36:31.971Z" }, + { url = "https://files.pythonhosted.org/packages/1e/2c/799f4742efc39633a1b54a92eec4082e4f815314869865d876824c257c1e/markupsafe-3.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3a7e8ae81ae39e62a41ec302f972ba6ae23a5c5396c8e60113e9066ef893da0d", size = 24332, upload-time = "2025-09-27T18:36:32.813Z" }, + { url = "https://files.pythonhosted.org/packages/3c/2e/8d0c2ab90a8c1d9a24f0399058ab8519a3279d1bd4289511d74e909f060e/markupsafe-3.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d6dd0be5b5b189d31db7cda48b91d7e0a9795f31430b7f271219ab30f1d3ac9d", size = 22947, upload-time = "2025-09-27T18:36:33.86Z" }, + { url = "https://files.pythonhosted.org/packages/2c/54/887f3092a85238093a0b2154bd629c89444f395618842e8b0c41783898ea/markupsafe-3.0.3-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:94c6f0bb423f739146aec64595853541634bde58b2135f27f61c1ffd1cd4d16a", size = 21962, upload-time = "2025-09-27T18:36:35.099Z" }, + { url = "https://files.pythonhosted.org/packages/c9/2f/336b8c7b6f4a4d95e91119dc8521402461b74a485558d8f238a68312f11c/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:be8813b57049a7dc738189df53d69395eba14fb99345e0a5994914a3864c8a4b", size = 23760, upload-time = "2025-09-27T18:36:36.001Z" }, + { url = "https://files.pythonhosted.org/packages/32/43/67935f2b7e4982ffb50a4d169b724d74b62a3964bc1a9a527f5ac4f1ee2b/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:83891d0e9fb81a825d9a6d61e3f07550ca70a076484292a70fde82c4b807286f", size = 21529, upload-time = "2025-09-27T18:36:36.906Z" }, + { url = "https://files.pythonhosted.org/packages/89/e0/4486f11e51bbba8b0c041098859e869e304d1c261e59244baa3d295d47b7/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:77f0643abe7495da77fb436f50f8dab76dbc6e5fd25d39589a0f1fe6548bfa2b", size = 23015, upload-time = "2025-09-27T18:36:37.868Z" }, + { url = "https://files.pythonhosted.org/packages/2f/e1/78ee7a023dac597a5825441ebd17170785a9dab23de95d2c7508ade94e0e/markupsafe-3.0.3-cp312-cp312-win32.whl", hash = "sha256:d88b440e37a16e651bda4c7c2b930eb586fd15ca7406cb39e211fcff3bf3017d", size = 14540, upload-time = "2025-09-27T18:36:38.761Z" }, + { url = "https://files.pythonhosted.org/packages/aa/5b/bec5aa9bbbb2c946ca2733ef9c4ca91c91b6a24580193e891b5f7dbe8e1e/markupsafe-3.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:26a5784ded40c9e318cfc2bdb30fe164bdb8665ded9cd64d500a34fb42067b1c", size = 15105, upload-time = "2025-09-27T18:36:39.701Z" }, + { url = "https://files.pythonhosted.org/packages/e5/f1/216fc1bbfd74011693a4fd837e7026152e89c4bcf3e77b6692fba9923123/markupsafe-3.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:35add3b638a5d900e807944a078b51922212fb3dedb01633a8defc4b01a3c85f", size = 13906, upload-time = "2025-09-27T18:36:40.689Z" }, + { url = "https://files.pythonhosted.org/packages/38/2f/907b9c7bbba283e68f20259574b13d005c121a0fa4c175f9bed27c4597ff/markupsafe-3.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e1cf1972137e83c5d4c136c43ced9ac51d0e124706ee1c8aa8532c1287fa8795", size = 11622, upload-time = "2025-09-27T18:36:41.777Z" }, + { url = "https://files.pythonhosted.org/packages/9c/d9/5f7756922cdd676869eca1c4e3c0cd0df60ed30199ffd775e319089cb3ed/markupsafe-3.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:116bb52f642a37c115f517494ea5feb03889e04df47eeff5b130b1808ce7c219", size = 12029, upload-time = "2025-09-27T18:36:43.257Z" }, + { url = "https://files.pythonhosted.org/packages/00/07/575a68c754943058c78f30db02ee03a64b3c638586fba6a6dd56830b30a3/markupsafe-3.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:133a43e73a802c5562be9bbcd03d090aa5a1fe899db609c29e8c8d815c5f6de6", size = 24374, upload-time = "2025-09-27T18:36:44.508Z" }, + { url = "https://files.pythonhosted.org/packages/a9/21/9b05698b46f218fc0e118e1f8168395c65c8a2c750ae2bab54fc4bd4e0e8/markupsafe-3.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ccfcd093f13f0f0b7fdd0f198b90053bf7b2f02a3927a30e63f3ccc9df56b676", size = 22980, upload-time = "2025-09-27T18:36:45.385Z" }, + { url = "https://files.pythonhosted.org/packages/7f/71/544260864f893f18b6827315b988c146b559391e6e7e8f7252839b1b846a/markupsafe-3.0.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:509fa21c6deb7a7a273d629cf5ec029bc209d1a51178615ddf718f5918992ab9", size = 21990, upload-time = "2025-09-27T18:36:46.916Z" }, + { url = "https://files.pythonhosted.org/packages/c2/28/b50fc2f74d1ad761af2f5dcce7492648b983d00a65b8c0e0cb457c82ebbe/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a4afe79fb3de0b7097d81da19090f4df4f8d3a2b3adaa8764138aac2e44f3af1", size = 23784, upload-time = "2025-09-27T18:36:47.884Z" }, + { url = "https://files.pythonhosted.org/packages/ed/76/104b2aa106a208da8b17a2fb72e033a5a9d7073c68f7e508b94916ed47a9/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:795e7751525cae078558e679d646ae45574b47ed6e7771863fcc079a6171a0fc", size = 21588, upload-time = "2025-09-27T18:36:48.82Z" }, + { url = "https://files.pythonhosted.org/packages/b5/99/16a5eb2d140087ebd97180d95249b00a03aa87e29cc224056274f2e45fd6/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8485f406a96febb5140bfeca44a73e3ce5116b2501ac54fe953e488fb1d03b12", size = 23041, upload-time = "2025-09-27T18:36:49.797Z" }, + { url = "https://files.pythonhosted.org/packages/19/bc/e7140ed90c5d61d77cea142eed9f9c303f4c4806f60a1044c13e3f1471d0/markupsafe-3.0.3-cp313-cp313-win32.whl", hash = "sha256:bdd37121970bfd8be76c5fb069c7751683bdf373db1ed6c010162b2a130248ed", size = 14543, upload-time = "2025-09-27T18:36:51.584Z" }, + { url = "https://files.pythonhosted.org/packages/05/73/c4abe620b841b6b791f2edc248f556900667a5a1cf023a6646967ae98335/markupsafe-3.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:9a1abfdc021a164803f4d485104931fb8f8c1efd55bc6b748d2f5774e78b62c5", size = 15113, upload-time = "2025-09-27T18:36:52.537Z" }, + { url = "https://files.pythonhosted.org/packages/f0/3a/fa34a0f7cfef23cf9500d68cb7c32dd64ffd58a12b09225fb03dd37d5b80/markupsafe-3.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:7e68f88e5b8799aa49c85cd116c932a1ac15caaa3f5db09087854d218359e485", size = 13911, upload-time = "2025-09-27T18:36:53.513Z" }, + { url = "https://files.pythonhosted.org/packages/e4/d7/e05cd7efe43a88a17a37b3ae96e79a19e846f3f456fe79c57ca61356ef01/markupsafe-3.0.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:218551f6df4868a8d527e3062d0fb968682fe92054e89978594c28e642c43a73", size = 11658, upload-time = "2025-09-27T18:36:54.819Z" }, + { url = "https://files.pythonhosted.org/packages/99/9e/e412117548182ce2148bdeacdda3bb494260c0b0184360fe0d56389b523b/markupsafe-3.0.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3524b778fe5cfb3452a09d31e7b5adefeea8c5be1d43c4f810ba09f2ceb29d37", size = 12066, upload-time = "2025-09-27T18:36:55.714Z" }, + { url = "https://files.pythonhosted.org/packages/bc/e6/fa0ffcda717ef64a5108eaa7b4f5ed28d56122c9a6d70ab8b72f9f715c80/markupsafe-3.0.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4e885a3d1efa2eadc93c894a21770e4bc67899e3543680313b09f139e149ab19", size = 25639, upload-time = "2025-09-27T18:36:56.908Z" }, + { url = "https://files.pythonhosted.org/packages/96/ec/2102e881fe9d25fc16cb4b25d5f5cde50970967ffa5dddafdb771237062d/markupsafe-3.0.3-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8709b08f4a89aa7586de0aadc8da56180242ee0ada3999749b183aa23df95025", size = 23569, upload-time = "2025-09-27T18:36:57.913Z" }, + { url = "https://files.pythonhosted.org/packages/4b/30/6f2fce1f1f205fc9323255b216ca8a235b15860c34b6798f810f05828e32/markupsafe-3.0.3-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b8512a91625c9b3da6f127803b166b629725e68af71f8184ae7e7d54686a56d6", size = 23284, upload-time = "2025-09-27T18:36:58.833Z" }, + { url = "https://files.pythonhosted.org/packages/58/47/4a0ccea4ab9f5dcb6f79c0236d954acb382202721e704223a8aafa38b5c8/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9b79b7a16f7fedff2495d684f2b59b0457c3b493778c9eed31111be64d58279f", size = 24801, upload-time = "2025-09-27T18:36:59.739Z" }, + { url = "https://files.pythonhosted.org/packages/6a/70/3780e9b72180b6fecb83a4814d84c3bf4b4ae4bf0b19c27196104149734c/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:12c63dfb4a98206f045aa9563db46507995f7ef6d83b2f68eda65c307c6829eb", size = 22769, upload-time = "2025-09-27T18:37:00.719Z" }, + { url = "https://files.pythonhosted.org/packages/98/c5/c03c7f4125180fc215220c035beac6b9cb684bc7a067c84fc69414d315f5/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8f71bc33915be5186016f675cd83a1e08523649b0e33efdb898db577ef5bb009", size = 23642, upload-time = "2025-09-27T18:37:01.673Z" }, + { url = "https://files.pythonhosted.org/packages/80/d6/2d1b89f6ca4bff1036499b1e29a1d02d282259f3681540e16563f27ebc23/markupsafe-3.0.3-cp313-cp313t-win32.whl", hash = "sha256:69c0b73548bc525c8cb9a251cddf1931d1db4d2258e9599c28c07ef3580ef354", size = 14612, upload-time = "2025-09-27T18:37:02.639Z" }, + { url = "https://files.pythonhosted.org/packages/2b/98/e48a4bfba0a0ffcf9925fe2d69240bfaa19c6f7507b8cd09c70684a53c1e/markupsafe-3.0.3-cp313-cp313t-win_amd64.whl", hash = "sha256:1b4b79e8ebf6b55351f0d91fe80f893b4743f104bff22e90697db1590e47a218", size = 15200, upload-time = "2025-09-27T18:37:03.582Z" }, + { url = "https://files.pythonhosted.org/packages/0e/72/e3cc540f351f316e9ed0f092757459afbc595824ca724cbc5a5d4263713f/markupsafe-3.0.3-cp313-cp313t-win_arm64.whl", hash = "sha256:ad2cf8aa28b8c020ab2fc8287b0f823d0a7d8630784c31e9ee5edea20f406287", size = 13973, upload-time = "2025-09-27T18:37:04.929Z" }, + { url = "https://files.pythonhosted.org/packages/33/8a/8e42d4838cd89b7dde187011e97fe6c3af66d8c044997d2183fbd6d31352/markupsafe-3.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:eaa9599de571d72e2daf60164784109f19978b327a3910d3e9de8c97b5b70cfe", size = 11619, upload-time = "2025-09-27T18:37:06.342Z" }, + { url = "https://files.pythonhosted.org/packages/b5/64/7660f8a4a8e53c924d0fa05dc3a55c9cee10bbd82b11c5afb27d44b096ce/markupsafe-3.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c47a551199eb8eb2121d4f0f15ae0f923d31350ab9280078d1e5f12b249e0026", size = 12029, upload-time = "2025-09-27T18:37:07.213Z" }, + { url = "https://files.pythonhosted.org/packages/da/ef/e648bfd021127bef5fa12e1720ffed0c6cbb8310c8d9bea7266337ff06de/markupsafe-3.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f34c41761022dd093b4b6896d4810782ffbabe30f2d443ff5f083e0cbbb8c737", size = 24408, upload-time = "2025-09-27T18:37:09.572Z" }, + { url = "https://files.pythonhosted.org/packages/41/3c/a36c2450754618e62008bf7435ccb0f88053e07592e6028a34776213d877/markupsafe-3.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:457a69a9577064c05a97c41f4e65148652db078a3a509039e64d3467b9e7ef97", size = 23005, upload-time = "2025-09-27T18:37:10.58Z" }, + { url = "https://files.pythonhosted.org/packages/bc/20/b7fdf89a8456b099837cd1dc21974632a02a999ec9bf7ca3e490aacd98e7/markupsafe-3.0.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e8afc3f2ccfa24215f8cb28dcf43f0113ac3c37c2f0f0806d8c70e4228c5cf4d", size = 22048, upload-time = "2025-09-27T18:37:11.547Z" }, + { url = "https://files.pythonhosted.org/packages/9a/a7/591f592afdc734f47db08a75793a55d7fbcc6902a723ae4cfbab61010cc5/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:ec15a59cf5af7be74194f7ab02d0f59a62bdcf1a537677ce67a2537c9b87fcda", size = 23821, upload-time = "2025-09-27T18:37:12.48Z" }, + { url = "https://files.pythonhosted.org/packages/7d/33/45b24e4f44195b26521bc6f1a82197118f74df348556594bd2262bda1038/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:0eb9ff8191e8498cca014656ae6b8d61f39da5f95b488805da4bb029cccbfbaf", size = 21606, upload-time = "2025-09-27T18:37:13.485Z" }, + { url = "https://files.pythonhosted.org/packages/ff/0e/53dfaca23a69fbfbbf17a4b64072090e70717344c52eaaaa9c5ddff1e5f0/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:2713baf880df847f2bece4230d4d094280f4e67b1e813eec43b4c0e144a34ffe", size = 23043, upload-time = "2025-09-27T18:37:14.408Z" }, + { url = "https://files.pythonhosted.org/packages/46/11/f333a06fc16236d5238bfe74daccbca41459dcd8d1fa952e8fbd5dccfb70/markupsafe-3.0.3-cp314-cp314-win32.whl", hash = "sha256:729586769a26dbceff69f7a7dbbf59ab6572b99d94576a5592625d5b411576b9", size = 14747, upload-time = "2025-09-27T18:37:15.36Z" }, + { url = "https://files.pythonhosted.org/packages/28/52/182836104b33b444e400b14f797212f720cbc9ed6ba34c800639d154e821/markupsafe-3.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:bdc919ead48f234740ad807933cdf545180bfbe9342c2bb451556db2ed958581", size = 15341, upload-time = "2025-09-27T18:37:16.496Z" }, + { url = "https://files.pythonhosted.org/packages/6f/18/acf23e91bd94fd7b3031558b1f013adfa21a8e407a3fdb32745538730382/markupsafe-3.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:5a7d5dc5140555cf21a6fefbdbf8723f06fcd2f63ef108f2854de715e4422cb4", size = 14073, upload-time = "2025-09-27T18:37:17.476Z" }, + { url = "https://files.pythonhosted.org/packages/3c/f0/57689aa4076e1b43b15fdfa646b04653969d50cf30c32a102762be2485da/markupsafe-3.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:1353ef0c1b138e1907ae78e2f6c63ff67501122006b0f9abad68fda5f4ffc6ab", size = 11661, upload-time = "2025-09-27T18:37:18.453Z" }, + { url = "https://files.pythonhosted.org/packages/89/c3/2e67a7ca217c6912985ec766c6393b636fb0c2344443ff9d91404dc4c79f/markupsafe-3.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1085e7fbddd3be5f89cc898938f42c0b3c711fdcb37d75221de2666af647c175", size = 12069, upload-time = "2025-09-27T18:37:19.332Z" }, + { url = "https://files.pythonhosted.org/packages/f0/00/be561dce4e6ca66b15276e184ce4b8aec61fe83662cce2f7d72bd3249d28/markupsafe-3.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1b52b4fb9df4eb9ae465f8d0c228a00624de2334f216f178a995ccdcf82c4634", size = 25670, upload-time = "2025-09-27T18:37:20.245Z" }, + { url = "https://files.pythonhosted.org/packages/50/09/c419f6f5a92e5fadde27efd190eca90f05e1261b10dbd8cbcb39cd8ea1dc/markupsafe-3.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fed51ac40f757d41b7c48425901843666a6677e3e8eb0abcff09e4ba6e664f50", size = 23598, upload-time = "2025-09-27T18:37:21.177Z" }, + { url = "https://files.pythonhosted.org/packages/22/44/a0681611106e0b2921b3033fc19bc53323e0b50bc70cffdd19f7d679bb66/markupsafe-3.0.3-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f190daf01f13c72eac4efd5c430a8de82489d9cff23c364c3ea822545032993e", size = 23261, upload-time = "2025-09-27T18:37:22.167Z" }, + { url = "https://files.pythonhosted.org/packages/5f/57/1b0b3f100259dc9fffe780cfb60d4be71375510e435efec3d116b6436d43/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e56b7d45a839a697b5eb268c82a71bd8c7f6c94d6fd50c3d577fa39a9f1409f5", size = 24835, upload-time = "2025-09-27T18:37:23.296Z" }, + { url = "https://files.pythonhosted.org/packages/26/6a/4bf6d0c97c4920f1597cc14dd720705eca0bf7c787aebc6bb4d1bead5388/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:f3e98bb3798ead92273dc0e5fd0f31ade220f59a266ffd8a4f6065e0a3ce0523", size = 22733, upload-time = "2025-09-27T18:37:24.237Z" }, + { url = "https://files.pythonhosted.org/packages/14/c7/ca723101509b518797fedc2fdf79ba57f886b4aca8a7d31857ba3ee8281f/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5678211cb9333a6468fb8d8be0305520aa073f50d17f089b5b4b477ea6e67fdc", size = 23672, upload-time = "2025-09-27T18:37:25.271Z" }, + { url = "https://files.pythonhosted.org/packages/fb/df/5bd7a48c256faecd1d36edc13133e51397e41b73bb77e1a69deab746ebac/markupsafe-3.0.3-cp314-cp314t-win32.whl", hash = "sha256:915c04ba3851909ce68ccc2b8e2cd691618c4dc4c4232fb7982bca3f41fd8c3d", size = 14819, upload-time = "2025-09-27T18:37:26.285Z" }, + { url = "https://files.pythonhosted.org/packages/1a/8a/0402ba61a2f16038b48b39bccca271134be00c5c9f0f623208399333c448/markupsafe-3.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4faffd047e07c38848ce017e8725090413cd80cbc23d86e55c587bf979e579c9", size = 15426, upload-time = "2025-09-27T18:37:27.316Z" }, + { url = "https://files.pythonhosted.org/packages/70/bc/6f1c2f612465f5fa89b95bead1f44dcb607670fd42891d8fdcd5d039f4f4/markupsafe-3.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:32001d6a8fc98c8cb5c947787c5d08b0a50663d139f1305bac5885d98d9b40fa", size = 14146, upload-time = "2025-09-27T18:37:28.327Z" }, +] + +[[package]] +name = "matplotlib" +version = "3.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.2.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c7/74/97e72a36efd4ae2bccb3463284300f8953f199b5ffbc04cbbb0ec78f74b1/matplotlib_inline-0.2.1.tar.gz", hash = "sha256:e1ee949c340d771fc39e241ea75683deb94762c8fa5f2927ec57c83c4dffa9fe", size = 8110, upload-time = "2025-10-23T09:00:22.126Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/af/33/ee4519fa02ed11a94aef9559552f3b17bb863f2ecfe1a35dc7f548cde231/matplotlib_inline-0.2.1-py3-none-any.whl", hash = "sha256:d56ce5156ba6085e00a9d54fead6ed29a9c47e215cd1bba2e976ef39f5710a76", size = 9516, upload-time = "2025-10-23T09:00:20.675Z" }, +] + +[[package]] +name = "mistune" +version = "3.1.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d7/02/a7fb8b21d4d55ac93cdcde9d3638da5dd0ebdd3a4fed76c7725e10b81cbe/mistune-3.1.4.tar.gz", hash = "sha256:b5a7f801d389f724ec702840c11d8fc48f2b33519102fc7ee739e8177b672164", size = 94588, upload-time = "2025-08-29T07:20:43.594Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7a/f0/8282d9641415e9e33df173516226b404d367a0fc55e1a60424a152913abc/mistune-3.1.4-py3-none-any.whl", hash = "sha256:93691da911e5d9d2e23bc54472892aff676df27a75274962ff9edc210364266d", size = 53481, upload-time = "2025-08-29T07:20:42.218Z" }, +] + +[[package]] +name = "nbclient" +version = "0.10.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-client" }, + { name = "jupyter-core" }, + { name = "nbformat" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/87/66/7ffd18d58eae90d5721f9f39212327695b749e23ad44b3881744eaf4d9e8/nbclient-0.10.2.tar.gz", hash = "sha256:90b7fc6b810630db87a6d0c2250b1f0ab4cf4d3c27a299b0cde78a4ed3fd9193", size = 62424, upload-time = "2024-12-19T10:32:27.164Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/34/6d/e7fa07f03a4a7b221d94b4d586edb754a9b0dc3c9e2c93353e9fa4e0d117/nbclient-0.10.2-py3-none-any.whl", hash = "sha256:4ffee11e788b4a27fabeb7955547e4318a5298f34342a4bfd01f2e1faaeadc3d", size = 25434, upload-time = "2024-12-19T10:32:24.139Z" }, +] + +[[package]] +name = "nbconvert" +version = "7.16.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "beautifulsoup4" }, + { name = "bleach", extra = ["css"] }, + { name = "defusedxml" }, + { name = "jinja2" }, + { name = "jupyter-core" }, + { name = "jupyterlab-pygments" }, + { name = "markupsafe" }, + { name = "mistune" }, + { name = "nbclient" }, + { name = "nbformat" }, + { name = "packaging" }, + { name = "pandocfilters" }, + { name = "pygments" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a3/59/f28e15fc47ffb73af68a8d9b47367a8630d76e97ae85ad18271b9db96fdf/nbconvert-7.16.6.tar.gz", hash = "sha256:576a7e37c6480da7b8465eefa66c17844243816ce1ccc372633c6b71c3c0f582", size = 857715, upload-time = "2025-01-28T09:29:14.724Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cc/9a/cd673b2f773a12c992f41309ef81b99da1690426bd2f96957a7ade0d3ed7/nbconvert-7.16.6-py3-none-any.whl", hash = "sha256:1375a7b67e0c2883678c48e506dc320febb57685e5ee67faa51b18a90f3a712b", size = 258525, upload-time = "2025-01-28T09:29:12.551Z" }, +] + +[[package]] +name = "nbformat" +version = "5.10.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "fastjsonschema" }, + { name = "jsonschema" }, + { name = "jupyter-core" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6d/fd/91545e604bc3dad7dca9ed03284086039b294c6b3d75c0d2fa45f9e9caf3/nbformat-5.10.4.tar.gz", hash = "sha256:322168b14f937a5d11362988ecac2a4952d3d8e3a2cbeb2319584631226d5b3a", size = 142749, upload-time = "2024-04-04T11:20:37.371Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a9/82/0340caa499416c78e5d8f5f05947ae4bc3cba53c9f038ab6e9ed964e22f1/nbformat-5.10.4-py3-none-any.whl", hash = "sha256:3b48d6c8fbca4b299bf3982ea7db1af21580e4fec269ad087b9e81588891200b", size = 78454, upload-time = "2024-04-04T11:20:34.895Z" }, +] + +[[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 = "notebook-shim" +version = "0.2.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-server" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/54/d2/92fa3243712b9a3e8bafaf60aac366da1cada3639ca767ff4b5b3654ec28/notebook_shim-0.2.4.tar.gz", hash = "sha256:b4b2cfa1b65d98307ca24361f5b30fe785b53c3fd07b7a47e89acb5e6ac638cb", size = 13167, upload-time = "2024-02-14T23:35:18.353Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f9/33/bd5b9137445ea4b680023eb0469b2bb969d61303dedb2aac6560ff3d14a1/notebook_shim-0.2.4-py3-none-any.whl", hash = "sha256:411a5be4e9dc882a074ccbcae671eda64cceb068767e9a3419096986560e1cef", size = 13307, upload-time = "2024-02-14T23:35:16.286Z" }, +] + +[[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 = "pandocfilters" +version = "1.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/70/6f/3dd4940bbe001c06a65f88e36bad298bc7a0de5036115639926b0c5c0458/pandocfilters-1.5.1.tar.gz", hash = "sha256:002b4a555ee4ebc03f8b66307e287fa492e4a77b4ea14d3f934328297bb4939e", size = 8454, upload-time = "2024-01-18T20:08:13.726Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ef/af/4fbc8cab944db5d21b7e2a5b8e9211a03a79852b1157e2c102fcc61ac440/pandocfilters-1.5.1-py2.py3-none-any.whl", hash = "sha256:93be382804a9cdb0a7267585f157e5d1731bbe5545a85b268d6f5fe6232de2bc", size = 8663, upload-time = "2024-01-18T20:08:11.28Z" }, +] + +[[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 = "patsy" +version = "1.0.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/be/44/ed13eccdd0519eff265f44b670d46fbb0ec813e2274932dc1c0e48520f7d/patsy-1.0.2.tar.gz", hash = "sha256:cdc995455f6233e90e22de72c37fcadb344e7586fb83f06696f54d92f8ce74c0", size = 399942, upload-time = "2025-10-20T16:17:37.535Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f1/70/ba4b949bdc0490ab78d545459acd7702b211dfccf7eb89bbc1060f52818d/patsy-1.0.2-py2.py3-none-any.whl", hash = "sha256:37bfddbc58fcf0362febb5f54f10743f8b21dd2aa73dec7e7ef59d1b02ae668a", size = 233301, upload-time = "2025-10-20T16:17:36.563Z" }, +] + +[[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 = "prometheus-client" +version = "0.23.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/23/53/3edb5d68ecf6b38fcbcc1ad28391117d2a322d9a1a3eff04bfdb184d8c3b/prometheus_client-0.23.1.tar.gz", hash = "sha256:6ae8f9081eaaaf153a2e959d2e6c4f4fb57b12ef76c8c7980202f1e57b48b2ce", size = 80481, upload-time = "2025-09-18T20:47:25.043Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b8/db/14bafcb4af2139e046d03fd00dea7873e48eafe18b7d2797e73d6681f210/prometheus_client-0.23.1-py3-none-any.whl", hash = "sha256:dd1913e6e76b59cfe44e7a4b83e01afc9873c1bdfd2ed8739f1e76aeca115f99", size = 61145, upload-time = "2025-09-18T20:47:23.875Z" }, +] + +[[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.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e1/88/bdd0a41e5857d5d703287598cbf08dad90aed56774ea52ae071bae9071b6/psutil-7.1.3.tar.gz", hash = "sha256:6c86281738d77335af7aec228328e944b30930899ea760ecf33a4dba66be5e74", size = 489059, upload-time = "2025-11-02T12:25:54.619Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bd/93/0c49e776b8734fef56ec9c5c57f923922f2cf0497d62e0f419465f28f3d0/psutil-7.1.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0005da714eee687b4b8decd3d6cc7c6db36215c9e74e5ad2264b90c3df7d92dc", size = 239751, upload-time = "2025-11-02T12:25:58.161Z" }, + { url = "https://files.pythonhosted.org/packages/6f/8d/b31e39c769e70780f007969815195a55c81a63efebdd4dbe9e7a113adb2f/psutil-7.1.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:19644c85dcb987e35eeeaefdc3915d059dac7bd1167cdcdbf27e0ce2df0c08c0", size = 240368, upload-time = "2025-11-02T12:26:00.491Z" }, + { url = "https://files.pythonhosted.org/packages/62/61/23fd4acc3c9eebbf6b6c78bcd89e5d020cfde4acf0a9233e9d4e3fa698b4/psutil-7.1.3-cp313-cp313t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:95ef04cf2e5ba0ab9eaafc4a11eaae91b44f4ef5541acd2ee91d9108d00d59a7", size = 287134, upload-time = "2025-11-02T12:26:02.613Z" }, + { url = "https://files.pythonhosted.org/packages/30/1c/f921a009ea9ceb51aa355cb0cc118f68d354db36eae18174bab63affb3e6/psutil-7.1.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1068c303be3a72f8e18e412c5b2a8f6d31750fb152f9cb106b54090296c9d251", size = 289904, upload-time = "2025-11-02T12:26:05.207Z" }, + { url = "https://files.pythonhosted.org/packages/a6/82/62d68066e13e46a5116df187d319d1724b3f437ddd0f958756fc052677f4/psutil-7.1.3-cp313-cp313t-win_amd64.whl", hash = "sha256:18349c5c24b06ac5612c0428ec2a0331c26443d259e2a0144a9b24b4395b58fa", size = 249642, upload-time = "2025-11-02T12:26:07.447Z" }, + { url = "https://files.pythonhosted.org/packages/df/ad/c1cd5fe965c14a0392112f68362cfceb5230819dbb5b1888950d18a11d9f/psutil-7.1.3-cp313-cp313t-win_arm64.whl", hash = "sha256:c525ffa774fe4496282fb0b1187725793de3e7c6b29e41562733cae9ada151ee", size = 245518, upload-time = "2025-11-02T12:26:09.719Z" }, + { url = "https://files.pythonhosted.org/packages/2e/bb/6670bded3e3236eb4287c7bcdc167e9fae6e1e9286e437f7111caed2f909/psutil-7.1.3-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:b403da1df4d6d43973dc004d19cee3b848e998ae3154cc8097d139b77156c353", size = 239843, upload-time = "2025-11-02T12:26:11.968Z" }, + { url = "https://files.pythonhosted.org/packages/b8/66/853d50e75a38c9a7370ddbeefabdd3d3116b9c31ef94dc92c6729bc36bec/psutil-7.1.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ad81425efc5e75da3f39b3e636293360ad8d0b49bed7df824c79764fb4ba9b8b", size = 240369, upload-time = "2025-11-02T12:26:14.358Z" }, + { url = "https://files.pythonhosted.org/packages/41/bd/313aba97cb5bfb26916dc29cf0646cbe4dd6a89ca69e8c6edce654876d39/psutil-7.1.3-cp314-cp314t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8f33a3702e167783a9213db10ad29650ebf383946e91bc77f28a5eb083496bc9", size = 288210, upload-time = "2025-11-02T12:26:16.699Z" }, + { url = "https://files.pythonhosted.org/packages/c2/fa/76e3c06e760927a0cfb5705eb38164254de34e9bd86db656d4dbaa228b04/psutil-7.1.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fac9cd332c67f4422504297889da5ab7e05fd11e3c4392140f7370f4208ded1f", size = 291182, upload-time = "2025-11-02T12:26:18.848Z" }, + { url = "https://files.pythonhosted.org/packages/0f/1d/5774a91607035ee5078b8fd747686ebec28a962f178712de100d00b78a32/psutil-7.1.3-cp314-cp314t-win_amd64.whl", hash = "sha256:3792983e23b69843aea49c8f5b8f115572c5ab64c153bada5270086a2123c7e7", size = 250466, upload-time = "2025-11-02T12:26:21.183Z" }, + { url = "https://files.pythonhosted.org/packages/00/ca/e426584bacb43a5cb1ac91fae1937f478cd8fbe5e4ff96574e698a2c77cd/psutil-7.1.3-cp314-cp314t-win_arm64.whl", hash = "sha256:31d77fcedb7529f27bb3a0472bea9334349f9a04160e8e6e5020f22c59893264", size = 245756, upload-time = "2025-11-02T12:26:23.148Z" }, + { url = "https://files.pythonhosted.org/packages/ef/94/46b9154a800253e7ecff5aaacdf8ebf43db99de4a2dfa18575b02548654e/psutil-7.1.3-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:2bdbcd0e58ca14996a42adf3621a6244f1bb2e2e528886959c72cf1e326677ab", size = 238359, upload-time = "2025-11-02T12:26:25.284Z" }, + { url = "https://files.pythonhosted.org/packages/68/3a/9f93cff5c025029a36d9a92fef47220ab4692ee7f2be0fba9f92813d0cb8/psutil-7.1.3-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:bc31fa00f1fbc3c3802141eede66f3a2d51d89716a194bf2cd6fc68310a19880", size = 239171, upload-time = "2025-11-02T12:26:27.23Z" }, + { url = "https://files.pythonhosted.org/packages/ce/b1/5f49af514f76431ba4eea935b8ad3725cdeb397e9245ab919dbc1d1dc20f/psutil-7.1.3-cp36-abi3-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3bb428f9f05c1225a558f53e30ccbad9930b11c3fc206836242de1091d3e7dd3", size = 263261, upload-time = "2025-11-02T12:26:29.48Z" }, + { url = "https://files.pythonhosted.org/packages/e0/95/992c8816a74016eb095e73585d747e0a8ea21a061ed3689474fabb29a395/psutil-7.1.3-cp36-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:56d974e02ca2c8eb4812c3f76c30e28836fffc311d55d979f1465c1feeb2b68b", size = 264635, upload-time = "2025-11-02T12:26:31.74Z" }, + { url = "https://files.pythonhosted.org/packages/55/4c/c3ed1a622b6ae2fd3c945a366e64eb35247a31e4db16cf5095e269e8eb3c/psutil-7.1.3-cp37-abi3-win_amd64.whl", hash = "sha256:f39c2c19fe824b47484b96f9692932248a54c43799a84282cfe58d05a6449efd", size = 247633, upload-time = "2025-11-02T12:26:33.887Z" }, + { url = "https://files.pythonhosted.org/packages/c9/ad/33b2ccec09bf96c2b2ef3f9a6f66baac8253d7565d8839e024a6b905d45d/psutil-7.1.3-cp37-abi3-win_arm64.whl", hash = "sha256:bd0d69cee829226a761e92f28140bec9a5ee9d5b4fb4b0cc589068dbfff559b1", size = 244608, upload-time = "2025-11-02T12:26:36.136Z" }, +] + +[[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 = "pyarrow" +version = "22.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/30/53/04a7fdc63e6056116c9ddc8b43bc28c12cdd181b85cbeadb79278475f3ae/pyarrow-22.0.0.tar.gz", hash = "sha256:3d600dc583260d845c7d8a6db540339dd883081925da2bd1c5cb808f720b3cd9", size = 1151151, upload-time = "2025-10-24T12:30:00.762Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/af/63/ba23862d69652f85b615ca14ad14f3bcfc5bf1b99ef3f0cd04ff93fdad5a/pyarrow-22.0.0-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:bea79263d55c24a32b0d79c00a1c58bb2ee5f0757ed95656b01c0fb310c5af3d", size = 34211578, upload-time = "2025-10-24T10:05:21.583Z" }, + { url = "https://files.pythonhosted.org/packages/b1/d0/f9ad86fe809efd2bcc8be32032fa72e8b0d112b01ae56a053006376c5930/pyarrow-22.0.0-cp312-cp312-macosx_12_0_x86_64.whl", hash = "sha256:12fe549c9b10ac98c91cf791d2945e878875d95508e1a5d14091a7aaa66d9cf8", size = 35989906, upload-time = "2025-10-24T10:05:29.485Z" }, + { url = "https://files.pythonhosted.org/packages/b4/a8/f910afcb14630e64d673f15904ec27dd31f1e009b77033c365c84e8c1e1d/pyarrow-22.0.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:334f900ff08ce0423407af97e6c26ad5d4e3b0763645559ece6fbf3747d6a8f5", size = 45021677, upload-time = "2025-10-24T10:05:38.274Z" }, + { url = "https://files.pythonhosted.org/packages/13/95/aec81f781c75cd10554dc17a25849c720d54feafb6f7847690478dcf5ef8/pyarrow-22.0.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:c6c791b09c57ed76a18b03f2631753a4960eefbbca80f846da8baefc6491fcfe", size = 47726315, upload-time = "2025-10-24T10:05:47.314Z" }, + { url = "https://files.pythonhosted.org/packages/bb/d4/74ac9f7a54cfde12ee42734ea25d5a3c9a45db78f9def949307a92720d37/pyarrow-22.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:c3200cb41cdbc65156e5f8c908d739b0dfed57e890329413da2748d1a2cd1a4e", size = 47990906, upload-time = "2025-10-24T10:05:58.254Z" }, + { url = "https://files.pythonhosted.org/packages/2e/71/fedf2499bf7a95062eafc989ace56572f3343432570e1c54e6599d5b88da/pyarrow-22.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ac93252226cf288753d8b46280f4edf3433bf9508b6977f8dd8526b521a1bbb9", size = 50306783, upload-time = "2025-10-24T10:06:08.08Z" }, + { url = "https://files.pythonhosted.org/packages/68/ed/b202abd5a5b78f519722f3d29063dda03c114711093c1995a33b8e2e0f4b/pyarrow-22.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:44729980b6c50a5f2bfcc2668d36c569ce17f8b17bccaf470c4313dcbbf13c9d", size = 27972883, upload-time = "2025-10-24T10:06:14.204Z" }, + { url = "https://files.pythonhosted.org/packages/a6/d6/d0fac16a2963002fc22c8fa75180a838737203d558f0ed3b564c4a54eef5/pyarrow-22.0.0-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:e6e95176209257803a8b3d0394f21604e796dadb643d2f7ca21b66c9c0b30c9a", size = 34204629, upload-time = "2025-10-24T10:06:20.274Z" }, + { url = "https://files.pythonhosted.org/packages/c6/9c/1d6357347fbae062ad3f17082f9ebc29cc733321e892c0d2085f42a2212b/pyarrow-22.0.0-cp313-cp313-macosx_12_0_x86_64.whl", hash = "sha256:001ea83a58024818826a9e3f89bf9310a114f7e26dfe404a4c32686f97bd7901", size = 35985783, upload-time = "2025-10-24T10:06:27.301Z" }, + { url = "https://files.pythonhosted.org/packages/ff/c0/782344c2ce58afbea010150df07e3a2f5fdad299cd631697ae7bd3bac6e3/pyarrow-22.0.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:ce20fe000754f477c8a9125543f1936ea5b8867c5406757c224d745ed033e691", size = 45020999, upload-time = "2025-10-24T10:06:35.387Z" }, + { url = "https://files.pythonhosted.org/packages/1b/8b/5362443737a5307a7b67c1017c42cd104213189b4970bf607e05faf9c525/pyarrow-22.0.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:e0a15757fccb38c410947df156f9749ae4a3c89b2393741a50521f39a8cf202a", size = 47724601, upload-time = "2025-10-24T10:06:43.551Z" }, + { url = "https://files.pythonhosted.org/packages/69/4d/76e567a4fc2e190ee6072967cb4672b7d9249ac59ae65af2d7e3047afa3b/pyarrow-22.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:cedb9dd9358e4ea1d9bce3665ce0797f6adf97ff142c8e25b46ba9cdd508e9b6", size = 48001050, upload-time = "2025-10-24T10:06:52.284Z" }, + { url = "https://files.pythonhosted.org/packages/01/5e/5653f0535d2a1aef8223cee9d92944cb6bccfee5cf1cd3f462d7cb022790/pyarrow-22.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:252be4a05f9d9185bb8c18e83764ebcfea7185076c07a7a662253af3a8c07941", size = 50307877, upload-time = "2025-10-24T10:07:02.405Z" }, + { url = "https://files.pythonhosted.org/packages/2d/f8/1d0bd75bf9328a3b826e24a16e5517cd7f9fbf8d34a3184a4566ef5a7f29/pyarrow-22.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:a4893d31e5ef780b6edcaf63122df0f8d321088bb0dee4c8c06eccb1ca28d145", size = 27977099, upload-time = "2025-10-24T10:08:07.259Z" }, + { url = "https://files.pythonhosted.org/packages/90/81/db56870c997805bf2b0f6eeeb2d68458bf4654652dccdcf1bf7a42d80903/pyarrow-22.0.0-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:f7fe3dbe871294ba70d789be16b6e7e52b418311e166e0e3cba9522f0f437fb1", size = 34336685, upload-time = "2025-10-24T10:07:11.47Z" }, + { url = "https://files.pythonhosted.org/packages/1c/98/0727947f199aba8a120f47dfc229eeb05df15bcd7a6f1b669e9f882afc58/pyarrow-22.0.0-cp313-cp313t-macosx_12_0_x86_64.whl", hash = "sha256:ba95112d15fd4f1105fb2402c4eab9068f0554435e9b7085924bcfaac2cc306f", size = 36032158, upload-time = "2025-10-24T10:07:18.626Z" }, + { url = "https://files.pythonhosted.org/packages/96/b4/9babdef9c01720a0785945c7cf550e4acd0ebcd7bdd2e6f0aa7981fa85e2/pyarrow-22.0.0-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:c064e28361c05d72eed8e744c9605cbd6d2bb7481a511c74071fd9b24bc65d7d", size = 44892060, upload-time = "2025-10-24T10:07:26.002Z" }, + { url = "https://files.pythonhosted.org/packages/f8/ca/2f8804edd6279f78a37062d813de3f16f29183874447ef6d1aadbb4efa0f/pyarrow-22.0.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:6f9762274496c244d951c819348afbcf212714902742225f649cf02823a6a10f", size = 47504395, upload-time = "2025-10-24T10:07:34.09Z" }, + { url = "https://files.pythonhosted.org/packages/b9/f0/77aa5198fd3943682b2e4faaf179a674f0edea0d55d326d83cb2277d9363/pyarrow-22.0.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:a9d9ffdc2ab696f6b15b4d1f7cec6658e1d788124418cb30030afbae31c64746", size = 48066216, upload-time = "2025-10-24T10:07:43.528Z" }, + { url = "https://files.pythonhosted.org/packages/79/87/a1937b6e78b2aff18b706d738c9e46ade5bfcf11b294e39c87706a0089ac/pyarrow-22.0.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:ec1a15968a9d80da01e1d30349b2b0d7cc91e96588ee324ce1b5228175043e95", size = 50288552, upload-time = "2025-10-24T10:07:53.519Z" }, + { url = "https://files.pythonhosted.org/packages/60/ae/b5a5811e11f25788ccfdaa8f26b6791c9807119dffcf80514505527c384c/pyarrow-22.0.0-cp313-cp313t-win_amd64.whl", hash = "sha256:bba208d9c7decf9961998edf5c65e3ea4355d5818dd6cd0f6809bec1afb951cc", size = 28262504, upload-time = "2025-10-24T10:08:00.932Z" }, + { url = "https://files.pythonhosted.org/packages/bd/b0/0fa4d28a8edb42b0a7144edd20befd04173ac79819547216f8a9f36f9e50/pyarrow-22.0.0-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:9bddc2cade6561f6820d4cd73f99a0243532ad506bc510a75a5a65a522b2d74d", size = 34224062, upload-time = "2025-10-24T10:08:14.101Z" }, + { url = "https://files.pythonhosted.org/packages/0f/a8/7a719076b3c1be0acef56a07220c586f25cd24de0e3f3102b438d18ae5df/pyarrow-22.0.0-cp314-cp314-macosx_12_0_x86_64.whl", hash = "sha256:e70ff90c64419709d38c8932ea9fe1cc98415c4f87ea8da81719e43f02534bc9", size = 35990057, upload-time = "2025-10-24T10:08:21.842Z" }, + { url = "https://files.pythonhosted.org/packages/89/3c/359ed54c93b47fb6fe30ed16cdf50e3f0e8b9ccfb11b86218c3619ae50a8/pyarrow-22.0.0-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:92843c305330aa94a36e706c16209cd4df274693e777ca47112617db7d0ef3d7", size = 45068002, upload-time = "2025-10-24T10:08:29.034Z" }, + { url = "https://files.pythonhosted.org/packages/55/fc/4945896cc8638536ee787a3bd6ce7cec8ec9acf452d78ec39ab328efa0a1/pyarrow-22.0.0-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:6dda1ddac033d27421c20d7a7943eec60be44e0db4e079f33cc5af3b8280ccde", size = 47737765, upload-time = "2025-10-24T10:08:38.559Z" }, + { url = "https://files.pythonhosted.org/packages/cd/5e/7cb7edeb2abfaa1f79b5d5eb89432356155c8426f75d3753cbcb9592c0fd/pyarrow-22.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:84378110dd9a6c06323b41b56e129c504d157d1a983ce8f5443761eb5256bafc", size = 48048139, upload-time = "2025-10-24T10:08:46.784Z" }, + { url = "https://files.pythonhosted.org/packages/88/c6/546baa7c48185f5e9d6e59277c4b19f30f48c94d9dd938c2a80d4d6b067c/pyarrow-22.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:854794239111d2b88b40b6ef92aa478024d1e5074f364033e73e21e3f76b25e0", size = 50314244, upload-time = "2025-10-24T10:08:55.771Z" }, + { url = "https://files.pythonhosted.org/packages/3c/79/755ff2d145aafec8d347bf18f95e4e81c00127f06d080135dfc86aea417c/pyarrow-22.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:b883fe6fd85adad7932b3271c38ac289c65b7337c2c132e9569f9d3940620730", size = 28757501, upload-time = "2025-10-24T10:09:59.891Z" }, + { url = "https://files.pythonhosted.org/packages/0e/d2/237d75ac28ced3147912954e3c1a174df43a95f4f88e467809118a8165e0/pyarrow-22.0.0-cp314-cp314t-macosx_12_0_arm64.whl", hash = "sha256:7a820d8ae11facf32585507c11f04e3f38343c1e784c9b5a8b1da5c930547fe2", size = 34355506, upload-time = "2025-10-24T10:09:02.953Z" }, + { url = "https://files.pythonhosted.org/packages/1e/2c/733dfffe6d3069740f98e57ff81007809067d68626c5faef293434d11bd6/pyarrow-22.0.0-cp314-cp314t-macosx_12_0_x86_64.whl", hash = "sha256:c6ec3675d98915bf1ec8b3c7986422682f7232ea76cad276f4c8abd5b7319b70", size = 36047312, upload-time = "2025-10-24T10:09:10.334Z" }, + { url = "https://files.pythonhosted.org/packages/7c/2b/29d6e3782dc1f299727462c1543af357a0f2c1d3c160ce199950d9ca51eb/pyarrow-22.0.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:3e739edd001b04f654b166204fc7a9de896cf6007eaff33409ee9e50ceaff754", size = 45081609, upload-time = "2025-10-24T10:09:18.61Z" }, + { url = "https://files.pythonhosted.org/packages/8d/42/aa9355ecc05997915af1b7b947a7f66c02dcaa927f3203b87871c114ba10/pyarrow-22.0.0-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:7388ac685cab5b279a41dfe0a6ccd99e4dbf322edfb63e02fc0443bf24134e91", size = 47703663, upload-time = "2025-10-24T10:09:27.369Z" }, + { url = "https://files.pythonhosted.org/packages/ee/62/45abedde480168e83a1de005b7b7043fd553321c1e8c5a9a114425f64842/pyarrow-22.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:f633074f36dbc33d5c05b5dc75371e5660f1dbf9c8b1d95669def05e5425989c", size = 48066543, upload-time = "2025-10-24T10:09:34.908Z" }, + { url = "https://files.pythonhosted.org/packages/84/e9/7878940a5b072e4f3bf998770acafeae13b267f9893af5f6d4ab3904b67e/pyarrow-22.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:4c19236ae2402a8663a2c8f21f1870a03cc57f0bef7e4b6eb3238cc82944de80", size = 50288838, upload-time = "2025-10-24T10:09:44.394Z" }, + { url = "https://files.pythonhosted.org/packages/7b/03/f335d6c52b4a4761bcc83499789a1e2e16d9d201a58c327a9b5cc9a41bd9/pyarrow-22.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:0c34fe18094686194f204a3b1787a27456897d8a2d62caf84b61e8dfbc0252ae", size = 29185594, upload-time = "2025-10-24T10:09:53.111Z" }, +] + +[[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 = "python-json-logger" +version = "4.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/29/bf/eca6a3d43db1dae7070f70e160ab20b807627ba953663ba07928cdd3dc58/python_json_logger-4.0.0.tar.gz", hash = "sha256:f58e68eb46e1faed27e0f574a55a0455eecd7b8a5b88b85a784519ba3cff047f", size = 17683, upload-time = "2025-10-06T04:15:18.984Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/51/e5/fecf13f06e5e5f67e8837d777d1bc43fac0ed2b77a676804df5c34744727/python_json_logger-4.0.0-py3-none-any.whl", hash = "sha256:af09c9daf6a813aa4cc7180395f50f2a9e5fa056034c9953aec92e381c5ba1e2", size = 15548, upload-time = "2025-10-06T04:15:17.553Z" }, +] + +[[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 = "pywinpty" +version = "3.0.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f3/bb/a7cc2967c5c4eceb6cc49cfe39447d4bfc56e6c865e7c2249b6eb978935f/pywinpty-3.0.2.tar.gz", hash = "sha256:1505cc4cb248af42cb6285a65c9c2086ee9e7e574078ee60933d5d7fa86fb004", size = 30669, upload-time = "2025-10-03T21:16:29.205Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/02/4e/1098484e042c9485f56f16eb2b69b43b874bd526044ee401512234cf9e04/pywinpty-3.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:99fdd9b455f0ad6419aba6731a7a0d2f88ced83c3c94a80ff9533d95fa8d8a9e", size = 2050391, upload-time = "2025-10-03T21:19:01.642Z" }, + { url = "https://files.pythonhosted.org/packages/fc/19/b757fe28008236a4a713e813283721b8a40aa60cd7d3f83549f2e25a3155/pywinpty-3.0.2-cp313-cp313-win_amd64.whl", hash = "sha256:18f78b81e4cfee6aabe7ea8688441d30247b73e52cd9657138015c5f4ee13a51", size = 2050057, upload-time = "2025-10-03T21:19:26.732Z" }, + { url = "https://files.pythonhosted.org/packages/cb/44/cbae12ecf6f4fa4129c36871fd09c6bef4f98d5f625ecefb5e2449765508/pywinpty-3.0.2-cp313-cp313t-win_amd64.whl", hash = "sha256:663383ecfab7fc382cc97ea5c4f7f0bb32c2f889259855df6ea34e5df42d305b", size = 2049874, upload-time = "2025-10-03T21:18:53.923Z" }, + { url = "https://files.pythonhosted.org/packages/ca/15/f12c6055e2d7a617d4d5820e8ac4ceaff849da4cb124640ef5116a230771/pywinpty-3.0.2-cp314-cp314-win_amd64.whl", hash = "sha256:28297cecc37bee9f24d8889e47231972d6e9e84f7b668909de54f36ca785029a", size = 2050386, upload-time = "2025-10-03T21:18:50.477Z" }, + { url = "https://files.pythonhosted.org/packages/de/24/c6907c5bb06043df98ad6a0a0ff5db2e0affcecbc3b15c42404393a3f72a/pywinpty-3.0.2-cp314-cp314t-win_amd64.whl", hash = "sha256:34b55ae9a1b671fe3eae071d86618110538e8eaad18fcb1531c0830b91a82767", size = 2049834, upload-time = "2025-10-03T21:19:25.688Z" }, +] + +[[package]] +name = "pyyaml" +version = "6.0.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/33/422b98d2195232ca1826284a76852ad5a86fe23e31b009c9886b2d0fb8b2/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", size = 182063, upload-time = "2025-09-25T21:32:11.445Z" }, + { url = "https://files.pythonhosted.org/packages/89/a0/6cf41a19a1f2f3feab0e9c0b74134aa2ce6849093d5517a0c550fe37a648/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0", size = 173973, upload-time = "2025-09-25T21:32:12.492Z" }, + { url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116, upload-time = "2025-09-25T21:32:13.652Z" }, + { url = "https://files.pythonhosted.org/packages/65/30/d7353c338e12baef4ecc1b09e877c1970bd3382789c159b4f89d6a70dc09/pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c", size = 844011, upload-time = "2025-09-25T21:32:15.21Z" }, + { url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", size = 807870, upload-time = "2025-09-25T21:32:16.431Z" }, + { url = "https://files.pythonhosted.org/packages/05/c0/b3be26a015601b822b97d9149ff8cb5ead58c66f981e04fedf4e762f4bd4/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e", size = 761089, upload-time = "2025-09-25T21:32:17.56Z" }, + { url = "https://files.pythonhosted.org/packages/be/8e/98435a21d1d4b46590d5459a22d88128103f8da4c2d4cb8f14f2a96504e1/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", size = 790181, upload-time = "2025-09-25T21:32:18.834Z" }, + { url = "https://files.pythonhosted.org/packages/74/93/7baea19427dcfbe1e5a372d81473250b379f04b1bd3c4c5ff825e2327202/pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5", size = 137658, upload-time = "2025-09-25T21:32:20.209Z" }, + { url = "https://files.pythonhosted.org/packages/86/bf/899e81e4cce32febab4fb42bb97dcdf66bc135272882d1987881a4b519e9/pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b", size = 154003, upload-time = "2025-09-25T21:32:21.167Z" }, + { url = "https://files.pythonhosted.org/packages/1a/08/67bd04656199bbb51dbed1439b7f27601dfb576fb864099c7ef0c3e55531/pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd", size = 140344, upload-time = "2025-09-25T21:32:22.617Z" }, + { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669, upload-time = "2025-09-25T21:32:23.673Z" }, + { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252, upload-time = "2025-09-25T21:32:25.149Z" }, + { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081, upload-time = "2025-09-25T21:32:26.575Z" }, + { url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159, upload-time = "2025-09-25T21:32:27.727Z" }, + { url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626, upload-time = "2025-09-25T21:32:28.878Z" }, + { url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613, upload-time = "2025-09-25T21:32:30.178Z" }, + { url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115, upload-time = "2025-09-25T21:32:31.353Z" }, + { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427, upload-time = "2025-09-25T21:32:32.58Z" }, + { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090, upload-time = "2025-09-25T21:32:33.659Z" }, + { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246, upload-time = "2025-09-25T21:32:34.663Z" }, + { url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814, upload-time = "2025-09-25T21:32:35.712Z" }, + { url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809, upload-time = "2025-09-25T21:32:36.789Z" }, + { url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454, upload-time = "2025-09-25T21:32:37.966Z" }, + { url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355, upload-time = "2025-09-25T21:32:39.178Z" }, + { url = "https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175, upload-time = "2025-09-25T21:32:40.865Z" }, + { url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228, upload-time = "2025-09-25T21:32:42.084Z" }, + { url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194, upload-time = "2025-09-25T21:32:43.362Z" }, + { url = "https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", size = 156429, upload-time = "2025-09-25T21:32:57.844Z" }, + { url = "https://files.pythonhosted.org/packages/f4/f4/a4541072bb9422c8a883ab55255f918fa378ecf083f5b85e87fc2b4eda1b/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", size = 143912, upload-time = "2025-09-25T21:32:59.247Z" }, + { url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108, upload-time = "2025-09-25T21:32:44.377Z" }, + { url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641, upload-time = "2025-09-25T21:32:45.407Z" }, + { url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901, upload-time = "2025-09-25T21:32:48.83Z" }, + { url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132, upload-time = "2025-09-25T21:32:50.149Z" }, + { url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261, upload-time = "2025-09-25T21:32:51.808Z" }, + { url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272, upload-time = "2025-09-25T21:32:52.941Z" }, + { url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923, upload-time = "2025-09-25T21:32:54.537Z" }, + { url = "https://files.pythonhosted.org/packages/f0/7a/1c7270340330e575b92f397352af856a8c06f230aa3e76f86b39d01b416a/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", size = 174062, upload-time = "2025-09-25T21:32:55.767Z" }, + { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" }, +] + +[[package]] +name = "pyzmq" +version = "27.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi", marker = "implementation_name == 'pypy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/04/0b/3c9baedbdf613ecaa7aa07027780b8867f57b6293b6ee50de316c9f3222b/pyzmq-27.1.0.tar.gz", hash = "sha256:ac0765e3d44455adb6ddbf4417dcce460fc40a05978c08efdf2948072f6db540", size = 281750, upload-time = "2025-09-08T23:10:18.157Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/92/e7/038aab64a946d535901103da16b953c8c9cc9c961dadcbf3609ed6428d23/pyzmq-27.1.0-cp312-abi3-macosx_10_15_universal2.whl", hash = "sha256:452631b640340c928fa343801b0d07eb0c3789a5ffa843f6e1a9cee0ba4eb4fc", size = 1306279, upload-time = "2025-09-08T23:08:03.807Z" }, + { url = "https://files.pythonhosted.org/packages/e8/5e/c3c49fdd0f535ef45eefcc16934648e9e59dace4a37ee88fc53f6cd8e641/pyzmq-27.1.0-cp312-abi3-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:1c179799b118e554b66da67d88ed66cd37a169f1f23b5d9f0a231b4e8d44a113", size = 895645, upload-time = "2025-09-08T23:08:05.301Z" }, + { url = "https://files.pythonhosted.org/packages/f8/e5/b0b2504cb4e903a74dcf1ebae157f9e20ebb6ea76095f6cfffea28c42ecd/pyzmq-27.1.0-cp312-abi3-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3837439b7f99e60312f0c926a6ad437b067356dc2bc2ec96eb395fd0fe804233", size = 652574, upload-time = "2025-09-08T23:08:06.828Z" }, + { url = "https://files.pythonhosted.org/packages/f8/9b/c108cdb55560eaf253f0cbdb61b29971e9fb34d9c3499b0e96e4e60ed8a5/pyzmq-27.1.0-cp312-abi3-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:43ad9a73e3da1fab5b0e7e13402f0b2fb934ae1c876c51d0afff0e7c052eca31", size = 840995, upload-time = "2025-09-08T23:08:08.396Z" }, + { url = "https://files.pythonhosted.org/packages/c2/bb/b79798ca177b9eb0825b4c9998c6af8cd2a7f15a6a1a4272c1d1a21d382f/pyzmq-27.1.0-cp312-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:0de3028d69d4cdc475bfe47a6128eb38d8bc0e8f4d69646adfbcd840facbac28", size = 1642070, upload-time = "2025-09-08T23:08:09.989Z" }, + { url = "https://files.pythonhosted.org/packages/9c/80/2df2e7977c4ede24c79ae39dcef3899bfc5f34d1ca7a5b24f182c9b7a9ca/pyzmq-27.1.0-cp312-abi3-musllinux_1_2_i686.whl", hash = "sha256:cf44a7763aea9298c0aa7dbf859f87ed7012de8bda0f3977b6fb1d96745df856", size = 2021121, upload-time = "2025-09-08T23:08:11.907Z" }, + { url = "https://files.pythonhosted.org/packages/46/bd/2d45ad24f5f5ae7e8d01525eb76786fa7557136555cac7d929880519e33a/pyzmq-27.1.0-cp312-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:f30f395a9e6fbca195400ce833c731e7b64c3919aa481af4d88c3759e0cb7496", size = 1878550, upload-time = "2025-09-08T23:08:13.513Z" }, + { url = "https://files.pythonhosted.org/packages/e6/2f/104c0a3c778d7c2ab8190e9db4f62f0b6957b53c9d87db77c284b69f33ea/pyzmq-27.1.0-cp312-abi3-win32.whl", hash = "sha256:250e5436a4ba13885494412b3da5d518cd0d3a278a1ae640e113c073a5f88edd", size = 559184, upload-time = "2025-09-08T23:08:15.163Z" }, + { url = "https://files.pythonhosted.org/packages/fc/7f/a21b20d577e4100c6a41795842028235998a643b1ad406a6d4163ea8f53e/pyzmq-27.1.0-cp312-abi3-win_amd64.whl", hash = "sha256:9ce490cf1d2ca2ad84733aa1d69ce6855372cb5ce9223802450c9b2a7cba0ccf", size = 619480, upload-time = "2025-09-08T23:08:17.192Z" }, + { url = "https://files.pythonhosted.org/packages/78/c2/c012beae5f76b72f007a9e91ee9401cb88c51d0f83c6257a03e785c81cc2/pyzmq-27.1.0-cp312-abi3-win_arm64.whl", hash = "sha256:75a2f36223f0d535a0c919e23615fc85a1e23b71f40c7eb43d7b1dedb4d8f15f", size = 552993, upload-time = "2025-09-08T23:08:18.926Z" }, + { url = "https://files.pythonhosted.org/packages/60/cb/84a13459c51da6cec1b7b1dc1a47e6db6da50b77ad7fd9c145842750a011/pyzmq-27.1.0-cp313-cp313-android_24_arm64_v8a.whl", hash = "sha256:93ad4b0855a664229559e45c8d23797ceac03183c7b6f5b4428152a6b06684a5", size = 1122436, upload-time = "2025-09-08T23:08:20.801Z" }, + { url = "https://files.pythonhosted.org/packages/dc/b6/94414759a69a26c3dd674570a81813c46a078767d931a6c70ad29fc585cb/pyzmq-27.1.0-cp313-cp313-android_24_x86_64.whl", hash = "sha256:fbb4f2400bfda24f12f009cba62ad5734148569ff4949b1b6ec3b519444342e6", size = 1156301, upload-time = "2025-09-08T23:08:22.47Z" }, + { url = "https://files.pythonhosted.org/packages/a5/ad/15906493fd40c316377fd8a8f6b1f93104f97a752667763c9b9c1b71d42d/pyzmq-27.1.0-cp313-cp313t-macosx_10_15_universal2.whl", hash = "sha256:e343d067f7b151cfe4eb3bb796a7752c9d369eed007b91231e817071d2c2fec7", size = 1341197, upload-time = "2025-09-08T23:08:24.286Z" }, + { url = "https://files.pythonhosted.org/packages/14/1d/d343f3ce13db53a54cb8946594e567410b2125394dafcc0268d8dda027e0/pyzmq-27.1.0-cp313-cp313t-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:08363b2011dec81c354d694bdecaef4770e0ae96b9afea70b3f47b973655cc05", size = 897275, upload-time = "2025-09-08T23:08:26.063Z" }, + { url = "https://files.pythonhosted.org/packages/69/2d/d83dd6d7ca929a2fc67d2c3005415cdf322af7751d773524809f9e585129/pyzmq-27.1.0-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d54530c8c8b5b8ddb3318f481297441af102517602b569146185fa10b63f4fa9", size = 660469, upload-time = "2025-09-08T23:08:27.623Z" }, + { url = "https://files.pythonhosted.org/packages/3e/cd/9822a7af117f4bc0f1952dbe9ef8358eb50a24928efd5edf54210b850259/pyzmq-27.1.0-cp313-cp313t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6f3afa12c392f0a44a2414056d730eebc33ec0926aae92b5ad5cf26ebb6cc128", size = 847961, upload-time = "2025-09-08T23:08:29.672Z" }, + { url = "https://files.pythonhosted.org/packages/9a/12/f003e824a19ed73be15542f172fd0ec4ad0b60cf37436652c93b9df7c585/pyzmq-27.1.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:c65047adafe573ff023b3187bb93faa583151627bc9c51fc4fb2c561ed689d39", size = 1650282, upload-time = "2025-09-08T23:08:31.349Z" }, + { url = "https://files.pythonhosted.org/packages/d5/4a/e82d788ed58e9a23995cee70dbc20c9aded3d13a92d30d57ec2291f1e8a3/pyzmq-27.1.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:90e6e9441c946a8b0a667356f7078d96411391a3b8f80980315455574177ec97", size = 2024468, upload-time = "2025-09-08T23:08:33.543Z" }, + { url = "https://files.pythonhosted.org/packages/d9/94/2da0a60841f757481e402b34bf4c8bf57fa54a5466b965de791b1e6f747d/pyzmq-27.1.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:add071b2d25f84e8189aaf0882d39a285b42fa3853016ebab234a5e78c7a43db", size = 1885394, upload-time = "2025-09-08T23:08:35.51Z" }, + { url = "https://files.pythonhosted.org/packages/4f/6f/55c10e2e49ad52d080dc24e37adb215e5b0d64990b57598abc2e3f01725b/pyzmq-27.1.0-cp313-cp313t-win32.whl", hash = "sha256:7ccc0700cfdf7bd487bea8d850ec38f204478681ea02a582a8da8171b7f90a1c", size = 574964, upload-time = "2025-09-08T23:08:37.178Z" }, + { url = "https://files.pythonhosted.org/packages/87/4d/2534970ba63dd7c522d8ca80fb92777f362c0f321900667c615e2067cb29/pyzmq-27.1.0-cp313-cp313t-win_amd64.whl", hash = "sha256:8085a9fba668216b9b4323be338ee5437a235fe275b9d1610e422ccc279733e2", size = 641029, upload-time = "2025-09-08T23:08:40.595Z" }, + { url = "https://files.pythonhosted.org/packages/f6/fa/f8aea7a28b0641f31d40dea42d7ef003fded31e184ef47db696bc74cd610/pyzmq-27.1.0-cp313-cp313t-win_arm64.whl", hash = "sha256:6bb54ca21bcfe361e445256c15eedf083f153811c37be87e0514934d6913061e", size = 561541, upload-time = "2025-09-08T23:08:42.668Z" }, + { url = "https://files.pythonhosted.org/packages/87/45/19efbb3000956e82d0331bafca5d9ac19ea2857722fa2caacefb6042f39d/pyzmq-27.1.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:ce980af330231615756acd5154f29813d553ea555485ae712c491cd483df6b7a", size = 1341197, upload-time = "2025-09-08T23:08:44.973Z" }, + { url = "https://files.pythonhosted.org/packages/48/43/d72ccdbf0d73d1343936296665826350cb1e825f92f2db9db3e61c2162a2/pyzmq-27.1.0-cp314-cp314t-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:1779be8c549e54a1c38f805e56d2a2e5c009d26de10921d7d51cfd1c8d4632ea", size = 897175, upload-time = "2025-09-08T23:08:46.601Z" }, + { url = "https://files.pythonhosted.org/packages/2f/2e/a483f73a10b65a9ef0161e817321d39a770b2acf8bcf3004a28d90d14a94/pyzmq-27.1.0-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7200bb0f03345515df50d99d3db206a0a6bee1955fbb8c453c76f5bf0e08fb96", size = 660427, upload-time = "2025-09-08T23:08:48.187Z" }, + { url = "https://files.pythonhosted.org/packages/f5/d2/5f36552c2d3e5685abe60dfa56f91169f7a2d99bbaf67c5271022ab40863/pyzmq-27.1.0-cp314-cp314t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:01c0e07d558b06a60773744ea6251f769cd79a41a97d11b8bf4ab8f034b0424d", size = 847929, upload-time = "2025-09-08T23:08:49.76Z" }, + { url = "https://files.pythonhosted.org/packages/c4/2a/404b331f2b7bf3198e9945f75c4c521f0c6a3a23b51f7a4a401b94a13833/pyzmq-27.1.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:80d834abee71f65253c91540445d37c4c561e293ba6e741b992f20a105d69146", size = 1650193, upload-time = "2025-09-08T23:08:51.7Z" }, + { url = "https://files.pythonhosted.org/packages/1c/0b/f4107e33f62a5acf60e3ded67ed33d79b4ce18de432625ce2fc5093d6388/pyzmq-27.1.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:544b4e3b7198dde4a62b8ff6685e9802a9a1ebf47e77478a5eb88eca2a82f2fd", size = 2024388, upload-time = "2025-09-08T23:08:53.393Z" }, + { url = "https://files.pythonhosted.org/packages/0d/01/add31fe76512642fd6e40e3a3bd21f4b47e242c8ba33efb6809e37076d9b/pyzmq-27.1.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:cedc4c68178e59a4046f97eca31b148ddcf51e88677de1ef4e78cf06c5376c9a", size = 1885316, upload-time = "2025-09-08T23:08:55.702Z" }, + { url = "https://files.pythonhosted.org/packages/c4/59/a5f38970f9bf07cee96128de79590bb354917914a9be11272cfc7ff26af0/pyzmq-27.1.0-cp314-cp314t-win32.whl", hash = "sha256:1f0b2a577fd770aa6f053211a55d1c47901f4d537389a034c690291485e5fe92", size = 587472, upload-time = "2025-09-08T23:08:58.18Z" }, + { url = "https://files.pythonhosted.org/packages/70/d8/78b1bad170f93fcf5e3536e70e8fadac55030002275c9a29e8f5719185de/pyzmq-27.1.0-cp314-cp314t-win_amd64.whl", hash = "sha256:19c9468ae0437f8074af379e986c5d3d7d7bfe033506af442e8c879732bedbe0", size = 661401, upload-time = "2025-09-08T23:08:59.802Z" }, + { url = "https://files.pythonhosted.org/packages/81/d6/4bfbb40c9a0b42fc53c7cf442f6385db70b40f74a783130c5d0a5aa62228/pyzmq-27.1.0-cp314-cp314t-win_arm64.whl", hash = "sha256:dc5dbf68a7857b59473f7df42650c621d7e8923fb03fa74a526890f4d33cc4d7", size = 575170, upload-time = "2025-09-08T23:09:01.418Z" }, +] + +[[package]] +name = "referencing" +version = "0.37.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "attrs" }, + { name = "rpds-py" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/22/f5/df4e9027acead3ecc63e50fe1e36aca1523e1719559c499951bb4b53188f/referencing-0.37.0.tar.gz", hash = "sha256:44aefc3142c5b842538163acb373e24cce6632bd54bdb01b21ad5863489f50d8", size = 78036, upload-time = "2025-10-13T15:30:48.871Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2c/58/ca301544e1fa93ed4f80d724bf5b194f6e4b945841c5bfd555878eea9fcb/referencing-0.37.0-py3-none-any.whl", hash = "sha256:381329a9f99628c9069361716891d34ad94af76e461dcb0335825aecc7692231", size = 26766, upload-time = "2025-10-13T15:30:47.625Z" }, +] + +[[package]] +name = "requests" +version = "2.32.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "charset-normalizer" }, + { name = "idna" }, + { name = "urllib3" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c9/74/b3ff8e6c8446842c3f5c837e9c3dfcfe2018ea6ecef224c710c85ef728f4/requests-2.32.5.tar.gz", hash = "sha256:dbba0bac56e100853db0ea71b82b4dfd5fe2bf6d3754a8893c3af500cec7d7cf", size = 134517, upload-time = "2025-08-18T20:46:02.573Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1e/db/4254e3eabe8020b458f1a747140d32277ec7a271daf1d235b70dc0b4e6e3/requests-2.32.5-py3-none-any.whl", hash = "sha256:2462f94637a34fd532264295e186976db0f5d453d1cdd31473c85a6a161affb6", size = 64738, upload-time = "2025-08-18T20:46:00.542Z" }, +] + +[[package]] +name = "rfc3339-validator" +version = "0.1.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "six" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/28/ea/a9387748e2d111c3c2b275ba970b735e04e15cdb1eb30693b6b5708c4dbd/rfc3339_validator-0.1.4.tar.gz", hash = "sha256:138a2abdf93304ad60530167e51d2dfb9549521a836871b88d7f4695d0022f6b", size = 5513, upload-time = "2021-05-12T16:37:54.178Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7b/44/4e421b96b67b2daff264473f7465db72fbdf36a07e05494f50300cc7b0c6/rfc3339_validator-0.1.4-py2.py3-none-any.whl", hash = "sha256:24f6ec1eda14ef823da9e36ec7113124b39c04d50a4d3d3a3c2859577e7791fa", size = 3490, upload-time = "2021-05-12T16:37:52.536Z" }, +] + +[[package]] +name = "rfc3986-validator" +version = "0.1.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/da/88/f270de456dd7d11dcc808abfa291ecdd3f45ff44e3b549ffa01b126464d0/rfc3986_validator-0.1.1.tar.gz", hash = "sha256:3d44bde7921b3b9ec3ae4e3adca370438eccebc676456449b145d533b240d055", size = 6760, upload-time = "2019-10-28T16:00:19.144Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9e/51/17023c0f8f1869d8806b979a2bffa3f861f26a3f1a66b094288323fba52f/rfc3986_validator-0.1.1-py2.py3-none-any.whl", hash = "sha256:2f235c432ef459970b4306369336b9d5dbdda31b510ca1e327636e01f528bfa9", size = 4242, upload-time = "2019-10-28T16:00:13.976Z" }, +] + +[[package]] +name = "rfc3987-syntax" +version = "1.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "lark" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/2c/06/37c1a5557acf449e8e406a830a05bf885ac47d33270aec454ef78675008d/rfc3987_syntax-1.1.0.tar.gz", hash = "sha256:717a62cbf33cffdd16dfa3a497d81ce48a660ea691b1ddd7be710c22f00b4a0d", size = 14239, upload-time = "2025-07-18T01:05:05.015Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7e/71/44ce230e1b7fadd372515a97e32a83011f906ddded8d03e3c6aafbdedbb7/rfc3987_syntax-1.1.0-py3-none-any.whl", hash = "sha256:6c3d97604e4c5ce9f714898e05401a0445a641cfa276432b0a648c80856f6a3f", size = 8046, upload-time = "2025-07-18T01:05:03.843Z" }, +] + +[[package]] +name = "rpds-py" +version = "0.28.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/48/dc/95f074d43452b3ef5d06276696ece4b3b5d696e7c9ad7173c54b1390cd70/rpds_py-0.28.0.tar.gz", hash = "sha256:abd4df20485a0983e2ca334a216249b6186d6e3c1627e106651943dbdb791aea", size = 27419, upload-time = "2025-10-22T22:24:29.327Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b8/5c/6c3936495003875fe7b14f90ea812841a08fca50ab26bd840e924097d9c8/rpds_py-0.28.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:6b4f28583a4f247ff60cd7bdda83db8c3f5b05a7a82ff20dd4b078571747708f", size = 366439, upload-time = "2025-10-22T22:22:04.525Z" }, + { url = "https://files.pythonhosted.org/packages/56/f9/a0f1ca194c50aa29895b442771f036a25b6c41a35e4f35b1a0ea713bedae/rpds_py-0.28.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:d678e91b610c29c4b3d52a2c148b641df2b4676ffe47c59f6388d58b99cdc424", size = 348170, upload-time = "2025-10-22T22:22:06.397Z" }, + { url = "https://files.pythonhosted.org/packages/18/ea/42d243d3a586beb72c77fa5def0487daf827210069a95f36328e869599ea/rpds_py-0.28.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e819e0e37a44a78e1383bf1970076e2ccc4dc8c2bbaa2f9bd1dc987e9afff628", size = 378838, upload-time = "2025-10-22T22:22:07.932Z" }, + { url = "https://files.pythonhosted.org/packages/e7/78/3de32e18a94791af8f33601402d9d4f39613136398658412a4e0b3047327/rpds_py-0.28.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5ee514e0f0523db5d3fb171f397c54875dbbd69760a414dccf9d4d7ad628b5bd", size = 393299, upload-time = "2025-10-22T22:22:09.435Z" }, + { url = "https://files.pythonhosted.org/packages/13/7e/4bdb435afb18acea2eb8a25ad56b956f28de7c59f8a1d32827effa0d4514/rpds_py-0.28.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5f3fa06d27fdcee47f07a39e02862da0100cb4982508f5ead53ec533cd5fe55e", size = 518000, upload-time = "2025-10-22T22:22:11.326Z" }, + { url = "https://files.pythonhosted.org/packages/31/d0/5f52a656875cdc60498ab035a7a0ac8f399890cc1ee73ebd567bac4e39ae/rpds_py-0.28.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:46959ef2e64f9e4a41fc89aa20dbca2b85531f9a72c21099a3360f35d10b0d5a", size = 408746, upload-time = "2025-10-22T22:22:13.143Z" }, + { url = "https://files.pythonhosted.org/packages/3e/cd/49ce51767b879cde77e7ad9fae164ea15dce3616fe591d9ea1df51152706/rpds_py-0.28.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8455933b4bcd6e83fde3fefc987a023389c4b13f9a58c8d23e4b3f6d13f78c84", size = 386379, upload-time = "2025-10-22T22:22:14.602Z" }, + { url = "https://files.pythonhosted.org/packages/6a/99/e4e1e1ee93a98f72fc450e36c0e4d99c35370220e815288e3ecd2ec36a2a/rpds_py-0.28.0-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:ad50614a02c8c2962feebe6012b52f9802deec4263946cddea37aaf28dd25a66", size = 401280, upload-time = "2025-10-22T22:22:16.063Z" }, + { url = "https://files.pythonhosted.org/packages/61/35/e0c6a57488392a8b319d2200d03dad2b29c0db9996f5662c3b02d0b86c02/rpds_py-0.28.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:e5deca01b271492553fdb6c7fd974659dce736a15bae5dad7ab8b93555bceb28", size = 412365, upload-time = "2025-10-22T22:22:17.504Z" }, + { url = "https://files.pythonhosted.org/packages/ff/6a/841337980ea253ec797eb084665436007a1aad0faac1ba097fb906c5f69c/rpds_py-0.28.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:735f8495a13159ce6a0d533f01e8674cec0c57038c920495f87dcb20b3ddb48a", size = 559573, upload-time = "2025-10-22T22:22:19.108Z" }, + { url = "https://files.pythonhosted.org/packages/e7/5e/64826ec58afd4c489731f8b00729c5f6afdb86f1df1df60bfede55d650bb/rpds_py-0.28.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:961ca621ff10d198bbe6ba4957decca61aa2a0c56695384c1d6b79bf61436df5", size = 583973, upload-time = "2025-10-22T22:22:20.768Z" }, + { url = "https://files.pythonhosted.org/packages/b6/ee/44d024b4843f8386a4eeaa4c171b3d31d55f7177c415545fd1a24c249b5d/rpds_py-0.28.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:2374e16cc9131022e7d9a8f8d65d261d9ba55048c78f3b6e017971a4f5e6353c", size = 553800, upload-time = "2025-10-22T22:22:22.25Z" }, + { url = "https://files.pythonhosted.org/packages/7d/89/33e675dccff11a06d4d85dbb4d1865f878d5020cbb69b2c1e7b2d3f82562/rpds_py-0.28.0-cp312-cp312-win32.whl", hash = "sha256:d15431e334fba488b081d47f30f091e5d03c18527c325386091f31718952fe08", size = 216954, upload-time = "2025-10-22T22:22:24.105Z" }, + { url = "https://files.pythonhosted.org/packages/af/36/45f6ebb3210887e8ee6dbf1bc710ae8400bb417ce165aaf3024b8360d999/rpds_py-0.28.0-cp312-cp312-win_amd64.whl", hash = "sha256:a410542d61fc54710f750d3764380b53bf09e8c4edbf2f9141a82aa774a04f7c", size = 227844, upload-time = "2025-10-22T22:22:25.551Z" }, + { url = "https://files.pythonhosted.org/packages/57/91/f3fb250d7e73de71080f9a221d19bd6a1c1eb0d12a1ea26513f6c1052ad6/rpds_py-0.28.0-cp312-cp312-win_arm64.whl", hash = "sha256:1f0cfd1c69e2d14f8c892b893997fa9a60d890a0c8a603e88dca4955f26d1edd", size = 217624, upload-time = "2025-10-22T22:22:26.914Z" }, + { url = "https://files.pythonhosted.org/packages/d3/03/ce566d92611dfac0085c2f4b048cd53ed7c274a5c05974b882a908d540a2/rpds_py-0.28.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:e9e184408a0297086f880556b6168fa927d677716f83d3472ea333b42171ee3b", size = 366235, upload-time = "2025-10-22T22:22:28.397Z" }, + { url = "https://files.pythonhosted.org/packages/00/34/1c61da1b25592b86fd285bd7bd8422f4c9d748a7373b46126f9ae792a004/rpds_py-0.28.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:edd267266a9b0448f33dc465a97cfc5d467594b600fe28e7fa2f36450e03053a", size = 348241, upload-time = "2025-10-22T22:22:30.171Z" }, + { url = "https://files.pythonhosted.org/packages/fc/00/ed1e28616848c61c493a067779633ebf4b569eccaacf9ccbdc0e7cba2b9d/rpds_py-0.28.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:85beb8b3f45e4e32f6802fb6cd6b17f615ef6c6a52f265371fb916fae02814aa", size = 378079, upload-time = "2025-10-22T22:22:31.644Z" }, + { url = "https://files.pythonhosted.org/packages/11/b2/ccb30333a16a470091b6e50289adb4d3ec656fd9951ba8c5e3aaa0746a67/rpds_py-0.28.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d2412be8d00a1b895f8ad827cc2116455196e20ed994bb704bf138fe91a42724", size = 393151, upload-time = "2025-10-22T22:22:33.453Z" }, + { url = "https://files.pythonhosted.org/packages/8c/d0/73e2217c3ee486d555cb84920597480627d8c0240ff3062005c6cc47773e/rpds_py-0.28.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:cf128350d384b777da0e68796afdcebc2e9f63f0e9f242217754e647f6d32491", size = 517520, upload-time = "2025-10-22T22:22:34.949Z" }, + { url = "https://files.pythonhosted.org/packages/c4/91/23efe81c700427d0841a4ae7ea23e305654381831e6029499fe80be8a071/rpds_py-0.28.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a2036d09b363aa36695d1cc1a97b36865597f4478470b0697b5ee9403f4fe399", size = 408699, upload-time = "2025-10-22T22:22:36.584Z" }, + { url = "https://files.pythonhosted.org/packages/ca/ee/a324d3198da151820a326c1f988caaa4f37fc27955148a76fff7a2d787a9/rpds_py-0.28.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b8e1e9be4fa6305a16be628959188e4fd5cd6f1b0e724d63c6d8b2a8adf74ea6", size = 385720, upload-time = "2025-10-22T22:22:38.014Z" }, + { url = "https://files.pythonhosted.org/packages/19/ad/e68120dc05af8b7cab4a789fccd8cdcf0fe7e6581461038cc5c164cd97d2/rpds_py-0.28.0-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:0a403460c9dd91a7f23fc3188de6d8977f1d9603a351d5db6cf20aaea95b538d", size = 401096, upload-time = "2025-10-22T22:22:39.869Z" }, + { url = "https://files.pythonhosted.org/packages/99/90/c1e070620042459d60df6356b666bb1f62198a89d68881816a7ed121595a/rpds_py-0.28.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d7366b6553cdc805abcc512b849a519167db8f5e5c3472010cd1228b224265cb", size = 411465, upload-time = "2025-10-22T22:22:41.395Z" }, + { url = "https://files.pythonhosted.org/packages/68/61/7c195b30d57f1b8d5970f600efee72a4fad79ec829057972e13a0370fd24/rpds_py-0.28.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:5b43c6a3726efd50f18d8120ec0551241c38785b68952d240c45ea553912ac41", size = 558832, upload-time = "2025-10-22T22:22:42.871Z" }, + { url = "https://files.pythonhosted.org/packages/b0/3d/06f3a718864773f69941d4deccdf18e5e47dd298b4628062f004c10f3b34/rpds_py-0.28.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:0cb7203c7bc69d7c1585ebb33a2e6074492d2fc21ad28a7b9d40457ac2a51ab7", size = 583230, upload-time = "2025-10-22T22:22:44.877Z" }, + { url = "https://files.pythonhosted.org/packages/66/df/62fc783781a121e77fee9a21ead0a926f1b652280a33f5956a5e7833ed30/rpds_py-0.28.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:7a52a5169c664dfb495882adc75c304ae1d50df552fbd68e100fdc719dee4ff9", size = 553268, upload-time = "2025-10-22T22:22:46.441Z" }, + { url = "https://files.pythonhosted.org/packages/84/85/d34366e335140a4837902d3dea89b51f087bd6a63c993ebdff59e93ee61d/rpds_py-0.28.0-cp313-cp313-win32.whl", hash = "sha256:2e42456917b6687215b3e606ab46aa6bca040c77af7df9a08a6dcfe8a4d10ca5", size = 217100, upload-time = "2025-10-22T22:22:48.342Z" }, + { url = "https://files.pythonhosted.org/packages/3c/1c/f25a3f3752ad7601476e3eff395fe075e0f7813fbb9862bd67c82440e880/rpds_py-0.28.0-cp313-cp313-win_amd64.whl", hash = "sha256:e0a0311caedc8069d68fc2bf4c9019b58a2d5ce3cd7cb656c845f1615b577e1e", size = 227759, upload-time = "2025-10-22T22:22:50.219Z" }, + { url = "https://files.pythonhosted.org/packages/e0/d6/5f39b42b99615b5bc2f36ab90423ea404830bdfee1c706820943e9a645eb/rpds_py-0.28.0-cp313-cp313-win_arm64.whl", hash = "sha256:04c1b207ab8b581108801528d59ad80aa83bb170b35b0ddffb29c20e411acdc1", size = 217326, upload-time = "2025-10-22T22:22:51.647Z" }, + { url = "https://files.pythonhosted.org/packages/5c/8b/0c69b72d1cee20a63db534be0df271effe715ef6c744fdf1ff23bb2b0b1c/rpds_py-0.28.0-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:f296ea3054e11fc58ad42e850e8b75c62d9a93a9f981ad04b2e5ae7d2186ff9c", size = 355736, upload-time = "2025-10-22T22:22:53.211Z" }, + { url = "https://files.pythonhosted.org/packages/f7/6d/0c2ee773cfb55c31a8514d2cece856dd299170a49babd50dcffb15ddc749/rpds_py-0.28.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:5a7306c19b19005ad98468fcefeb7100b19c79fc23a5f24a12e06d91181193fa", size = 342677, upload-time = "2025-10-22T22:22:54.723Z" }, + { url = "https://files.pythonhosted.org/packages/e2/1c/22513ab25a27ea205144414724743e305e8153e6abe81833b5e678650f5a/rpds_py-0.28.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e5d9b86aa501fed9862a443c5c3116f6ead8bc9296185f369277c42542bd646b", size = 371847, upload-time = "2025-10-22T22:22:56.295Z" }, + { url = "https://files.pythonhosted.org/packages/60/07/68e6ccdb4b05115ffe61d31afc94adef1833d3a72f76c9632d4d90d67954/rpds_py-0.28.0-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e5bbc701eff140ba0e872691d573b3d5d30059ea26e5785acba9132d10c8c31d", size = 381800, upload-time = "2025-10-22T22:22:57.808Z" }, + { url = "https://files.pythonhosted.org/packages/73/bf/6d6d15df80781d7f9f368e7c1a00caf764436518c4877fb28b029c4624af/rpds_py-0.28.0-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9a5690671cd672a45aa8616d7374fdf334a1b9c04a0cac3c854b1136e92374fe", size = 518827, upload-time = "2025-10-22T22:22:59.826Z" }, + { url = "https://files.pythonhosted.org/packages/7b/d3/2decbb2976cc452cbf12a2b0aaac5f1b9dc5dd9d1f7e2509a3ee00421249/rpds_py-0.28.0-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9f1d92ecea4fa12f978a367c32a5375a1982834649cdb96539dcdc12e609ab1a", size = 399471, upload-time = "2025-10-22T22:23:01.968Z" }, + { url = "https://files.pythonhosted.org/packages/b1/2c/f30892f9e54bd02e5faca3f6a26d6933c51055e67d54818af90abed9748e/rpds_py-0.28.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8d252db6b1a78d0a3928b6190156042d54c93660ce4d98290d7b16b5296fb7cc", size = 377578, upload-time = "2025-10-22T22:23:03.52Z" }, + { url = "https://files.pythonhosted.org/packages/f0/5d/3bce97e5534157318f29ac06bf2d279dae2674ec12f7cb9c12739cee64d8/rpds_py-0.28.0-cp313-cp313t-manylinux_2_31_riscv64.whl", hash = "sha256:d61b355c3275acb825f8777d6c4505f42b5007e357af500939d4a35b19177259", size = 390482, upload-time = "2025-10-22T22:23:05.391Z" }, + { url = "https://files.pythonhosted.org/packages/e3/f0/886bd515ed457b5bd93b166175edb80a0b21a210c10e993392127f1e3931/rpds_py-0.28.0-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:acbe5e8b1026c0c580d0321c8aae4b0a1e1676861d48d6e8c6586625055b606a", size = 402447, upload-time = "2025-10-22T22:23:06.93Z" }, + { url = "https://files.pythonhosted.org/packages/42/b5/71e8777ac55e6af1f4f1c05b47542a1eaa6c33c1cf0d300dca6a1c6e159a/rpds_py-0.28.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:8aa23b6f0fc59b85b4c7d89ba2965af274346f738e8d9fc2455763602e62fd5f", size = 552385, upload-time = "2025-10-22T22:23:08.557Z" }, + { url = "https://files.pythonhosted.org/packages/5d/cb/6ca2d70cbda5a8e36605e7788c4aa3bea7c17d71d213465a5a675079b98d/rpds_py-0.28.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:7b14b0c680286958817c22d76fcbca4800ddacef6f678f3a7c79a1fe7067fe37", size = 575642, upload-time = "2025-10-22T22:23:10.348Z" }, + { url = "https://files.pythonhosted.org/packages/4a/d4/407ad9960ca7856d7b25c96dcbe019270b5ffdd83a561787bc682c797086/rpds_py-0.28.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:bcf1d210dfee61a6c86551d67ee1031899c0fdbae88b2d44a569995d43797712", size = 544507, upload-time = "2025-10-22T22:23:12.434Z" }, + { url = "https://files.pythonhosted.org/packages/51/31/2f46fe0efcac23fbf5797c6b6b7e1c76f7d60773e525cb65fcbc582ee0f2/rpds_py-0.28.0-cp313-cp313t-win32.whl", hash = "sha256:3aa4dc0fdab4a7029ac63959a3ccf4ed605fee048ba67ce89ca3168da34a1342", size = 205376, upload-time = "2025-10-22T22:23:13.979Z" }, + { url = "https://files.pythonhosted.org/packages/92/e4/15947bda33cbedfc134490a41841ab8870a72a867a03d4969d886f6594a2/rpds_py-0.28.0-cp313-cp313t-win_amd64.whl", hash = "sha256:7b7d9d83c942855e4fdcfa75d4f96f6b9e272d42fffcb72cd4bb2577db2e2907", size = 215907, upload-time = "2025-10-22T22:23:15.5Z" }, + { url = "https://files.pythonhosted.org/packages/08/47/ffe8cd7a6a02833b10623bf765fbb57ce977e9a4318ca0e8cf97e9c3d2b3/rpds_py-0.28.0-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:dcdcb890b3ada98a03f9f2bb108489cdc7580176cb73b4f2d789e9a1dac1d472", size = 353830, upload-time = "2025-10-22T22:23:17.03Z" }, + { url = "https://files.pythonhosted.org/packages/f9/9f/890f36cbd83a58491d0d91ae0db1702639edb33fb48eeb356f80ecc6b000/rpds_py-0.28.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:f274f56a926ba2dc02976ca5b11c32855cbd5925534e57cfe1fda64e04d1add2", size = 341819, upload-time = "2025-10-22T22:23:18.57Z" }, + { url = "https://files.pythonhosted.org/packages/09/e3/921eb109f682aa24fb76207698fbbcf9418738f35a40c21652c29053f23d/rpds_py-0.28.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4fe0438ac4a29a520ea94c8c7f1754cdd8feb1bc490dfda1bfd990072363d527", size = 373127, upload-time = "2025-10-22T22:23:20.216Z" }, + { url = "https://files.pythonhosted.org/packages/23/13/bce4384d9f8f4989f1a9599c71b7a2d877462e5fd7175e1f69b398f729f4/rpds_py-0.28.0-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:8a358a32dd3ae50e933347889b6af9a1bdf207ba5d1a3f34e1a38cd3540e6733", size = 382767, upload-time = "2025-10-22T22:23:21.787Z" }, + { url = "https://files.pythonhosted.org/packages/23/e1/579512b2d89a77c64ccef5a0bc46a6ef7f72ae0cf03d4b26dcd52e57ee0a/rpds_py-0.28.0-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e80848a71c78aa328fefaba9c244d588a342c8e03bda518447b624ea64d1ff56", size = 517585, upload-time = "2025-10-22T22:23:23.699Z" }, + { url = "https://files.pythonhosted.org/packages/62/3c/ca704b8d324a2591b0b0adcfcaadf9c862375b11f2f667ac03c61b4fd0a6/rpds_py-0.28.0-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f586db2e209d54fe177e58e0bc4946bea5fb0102f150b1b2f13de03e1f0976f8", size = 399828, upload-time = "2025-10-22T22:23:25.713Z" }, + { url = "https://files.pythonhosted.org/packages/da/37/e84283b9e897e3adc46b4c88bb3f6ec92a43bd4d2f7ef5b13459963b2e9c/rpds_py-0.28.0-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5ae8ee156d6b586e4292491e885d41483136ab994e719a13458055bec14cf370", size = 375509, upload-time = "2025-10-22T22:23:27.32Z" }, + { url = "https://files.pythonhosted.org/packages/1a/c2/a980beab869d86258bf76ec42dec778ba98151f253a952b02fe36d72b29c/rpds_py-0.28.0-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:a805e9b3973f7e27f7cab63a6b4f61d90f2e5557cff73b6e97cd5b8540276d3d", size = 392014, upload-time = "2025-10-22T22:23:29.332Z" }, + { url = "https://files.pythonhosted.org/packages/da/b5/b1d3c5f9d3fa5aeef74265f9c64de3c34a0d6d5cd3c81c8b17d5c8f10ed4/rpds_py-0.28.0-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:5d3fd16b6dc89c73a4da0b4ac8b12a7ecc75b2864b95c9e5afed8003cb50a728", size = 402410, upload-time = "2025-10-22T22:23:31.14Z" }, + { url = "https://files.pythonhosted.org/packages/74/ae/cab05ff08dfcc052afc73dcb38cbc765ffc86f94e966f3924cd17492293c/rpds_py-0.28.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:6796079e5d24fdaba6d49bda28e2c47347e89834678f2bc2c1b4fc1489c0fb01", size = 553593, upload-time = "2025-10-22T22:23:32.834Z" }, + { url = "https://files.pythonhosted.org/packages/70/80/50d5706ea2a9bfc9e9c5f401d91879e7c790c619969369800cde202da214/rpds_py-0.28.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:76500820c2af232435cbe215e3324c75b950a027134e044423f59f5b9a1ba515", size = 576925, upload-time = "2025-10-22T22:23:34.47Z" }, + { url = "https://files.pythonhosted.org/packages/ab/12/85a57d7a5855a3b188d024b099fd09c90db55d32a03626d0ed16352413ff/rpds_py-0.28.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:bbdc5640900a7dbf9dd707fe6388972f5bbd883633eb68b76591044cfe346f7e", size = 542444, upload-time = "2025-10-22T22:23:36.093Z" }, + { url = "https://files.pythonhosted.org/packages/6c/65/10643fb50179509150eb94d558e8837c57ca8b9adc04bd07b98e57b48f8c/rpds_py-0.28.0-cp314-cp314-win32.whl", hash = "sha256:adc8aa88486857d2b35d75f0640b949759f79dc105f50aa2c27816b2e0dd749f", size = 207968, upload-time = "2025-10-22T22:23:37.638Z" }, + { url = "https://files.pythonhosted.org/packages/b4/84/0c11fe4d9aaea784ff4652499e365963222481ac647bcd0251c88af646eb/rpds_py-0.28.0-cp314-cp314-win_amd64.whl", hash = "sha256:66e6fa8e075b58946e76a78e69e1a124a21d9a48a5b4766d15ba5b06869d1fa1", size = 218876, upload-time = "2025-10-22T22:23:39.179Z" }, + { url = "https://files.pythonhosted.org/packages/0f/e0/3ab3b86ded7bb18478392dc3e835f7b754cd446f62f3fc96f4fe2aca78f6/rpds_py-0.28.0-cp314-cp314-win_arm64.whl", hash = "sha256:a6fe887c2c5c59413353b7c0caff25d0e566623501ccfff88957fa438a69377d", size = 212506, upload-time = "2025-10-22T22:23:40.755Z" }, + { url = "https://files.pythonhosted.org/packages/51/ec/d5681bb425226c3501eab50fc30e9d275de20c131869322c8a1729c7b61c/rpds_py-0.28.0-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:7a69df082db13c7070f7b8b1f155fa9e687f1d6aefb7b0e3f7231653b79a067b", size = 355433, upload-time = "2025-10-22T22:23:42.259Z" }, + { url = "https://files.pythonhosted.org/packages/be/ec/568c5e689e1cfb1ea8b875cffea3649260955f677fdd7ddc6176902d04cd/rpds_py-0.28.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b1cde22f2c30ebb049a9e74c5374994157b9b70a16147d332f89c99c5960737a", size = 342601, upload-time = "2025-10-22T22:23:44.372Z" }, + { url = "https://files.pythonhosted.org/packages/32/fe/51ada84d1d2a1d9d8f2c902cfddd0133b4a5eb543196ab5161d1c07ed2ad/rpds_py-0.28.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5338742f6ba7a51012ea470bd4dc600a8c713c0c72adaa0977a1b1f4327d6592", size = 372039, upload-time = "2025-10-22T22:23:46.025Z" }, + { url = "https://files.pythonhosted.org/packages/07/c1/60144a2f2620abade1a78e0d91b298ac2d9b91bc08864493fa00451ef06e/rpds_py-0.28.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e1460ebde1bcf6d496d80b191d854adedcc619f84ff17dc1c6d550f58c9efbba", size = 382407, upload-time = "2025-10-22T22:23:48.098Z" }, + { url = "https://files.pythonhosted.org/packages/45/ed/091a7bbdcf4038a60a461df50bc4c82a7ed6d5d5e27649aab61771c17585/rpds_py-0.28.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e3eb248f2feba84c692579257a043a7699e28a77d86c77b032c1d9fbb3f0219c", size = 518172, upload-time = "2025-10-22T22:23:50.16Z" }, + { url = "https://files.pythonhosted.org/packages/54/dd/02cc90c2fd9c2ef8016fd7813bfacd1c3a1325633ec8f244c47b449fc868/rpds_py-0.28.0-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bd3bbba5def70b16cd1c1d7255666aad3b290fbf8d0fe7f9f91abafb73611a91", size = 399020, upload-time = "2025-10-22T22:23:51.81Z" }, + { url = "https://files.pythonhosted.org/packages/ab/81/5d98cc0329bbb911ccecd0b9e19fbf7f3a5de8094b4cda5e71013b2dd77e/rpds_py-0.28.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3114f4db69ac5a1f32e7e4d1cbbe7c8f9cf8217f78e6e002cedf2d54c2a548ed", size = 377451, upload-time = "2025-10-22T22:23:53.711Z" }, + { url = "https://files.pythonhosted.org/packages/b4/07/4d5bcd49e3dfed2d38e2dcb49ab6615f2ceb9f89f5a372c46dbdebb4e028/rpds_py-0.28.0-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:4b0cb8a906b1a0196b863d460c0222fb8ad0f34041568da5620f9799b83ccf0b", size = 390355, upload-time = "2025-10-22T22:23:55.299Z" }, + { url = "https://files.pythonhosted.org/packages/3f/79/9f14ba9010fee74e4f40bf578735cfcbb91d2e642ffd1abe429bb0b96364/rpds_py-0.28.0-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:cf681ac76a60b667106141e11a92a3330890257e6f559ca995fbb5265160b56e", size = 403146, upload-time = "2025-10-22T22:23:56.929Z" }, + { url = "https://files.pythonhosted.org/packages/39/4c/f08283a82ac141331a83a40652830edd3a4a92c34e07e2bbe00baaea2f5f/rpds_py-0.28.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:1e8ee6413cfc677ce8898d9cde18cc3a60fc2ba756b0dec5b71eb6eb21c49fa1", size = 552656, upload-time = "2025-10-22T22:23:58.62Z" }, + { url = "https://files.pythonhosted.org/packages/61/47/d922fc0666f0dd8e40c33990d055f4cc6ecff6f502c2d01569dbed830f9b/rpds_py-0.28.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:b3072b16904d0b5572a15eb9d31c1954e0d3227a585fc1351aa9878729099d6c", size = 576782, upload-time = "2025-10-22T22:24:00.312Z" }, + { url = "https://files.pythonhosted.org/packages/d3/0c/5bafdd8ccf6aa9d3bfc630cfece457ff5b581af24f46a9f3590f790e3df2/rpds_py-0.28.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:b670c30fd87a6aec281c3c9896d3bae4b205fd75d79d06dc87c2503717e46092", size = 544671, upload-time = "2025-10-22T22:24:02.297Z" }, + { url = "https://files.pythonhosted.org/packages/2c/37/dcc5d8397caa924988693519069d0beea077a866128719351a4ad95e82fc/rpds_py-0.28.0-cp314-cp314t-win32.whl", hash = "sha256:8014045a15b4d2b3476f0a287fcc93d4f823472d7d1308d47884ecac9e612be3", size = 205749, upload-time = "2025-10-22T22:24:03.848Z" }, + { url = "https://files.pythonhosted.org/packages/d7/69/64d43b21a10d72b45939a28961216baeb721cc2a430f5f7c3bfa21659a53/rpds_py-0.28.0-cp314-cp314t-win_amd64.whl", hash = "sha256:7a4e59c90d9c27c561eb3160323634a9ff50b04e4f7820600a2beb0ac90db578", size = 216233, upload-time = "2025-10-22T22:24:05.471Z" }, +] + +[[package]] +name = "scipy" +version = "1.16.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/0a/ca/d8ace4f98322d01abcd52d381134344bf7b431eba7ed8b42bdea5a3c2ac9/scipy-1.16.3.tar.gz", hash = "sha256:01e87659402762f43bd2fee13370553a17ada367d42e7487800bf2916535aecb", size = 30597883, upload-time = "2025-10-28T17:38:54.068Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/40/41/5bf55c3f386b1643812f3a5674edf74b26184378ef0f3e7c7a09a7e2ca7f/scipy-1.16.3-cp312-cp312-macosx_10_14_x86_64.whl", hash = "sha256:81fc5827606858cf71446a5e98715ba0e11f0dbc83d71c7409d05486592a45d6", size = 36659043, upload-time = "2025-10-28T17:32:40.285Z" }, + { url = "https://files.pythonhosted.org/packages/1e/0f/65582071948cfc45d43e9870bf7ca5f0e0684e165d7c9ef4e50d783073eb/scipy-1.16.3-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:c97176013d404c7346bf57874eaac5187d969293bf40497140b0a2b2b7482e07", size = 28898986, upload-time = "2025-10-28T17:32:45.325Z" }, + { url = "https://files.pythonhosted.org/packages/96/5e/36bf3f0ac298187d1ceadde9051177d6a4fe4d507e8f59067dc9dd39e650/scipy-1.16.3-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:2b71d93c8a9936046866acebc915e2af2e292b883ed6e2cbe5c34beb094b82d9", size = 20889814, upload-time = "2025-10-28T17:32:49.277Z" }, + { url = "https://files.pythonhosted.org/packages/80/35/178d9d0c35394d5d5211bbff7ac4f2986c5488b59506fef9e1de13ea28d3/scipy-1.16.3-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:3d4a07a8e785d80289dfe66b7c27d8634a773020742ec7187b85ccc4b0e7b686", size = 23565795, upload-time = "2025-10-28T17:32:53.337Z" }, + { url = "https://files.pythonhosted.org/packages/fa/46/d1146ff536d034d02f83c8afc3c4bab2eddb634624d6529a8512f3afc9da/scipy-1.16.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:0553371015692a898e1aa858fed67a3576c34edefa6b7ebdb4e9dde49ce5c203", size = 33349476, upload-time = "2025-10-28T17:32:58.353Z" }, + { url = "https://files.pythonhosted.org/packages/79/2e/415119c9ab3e62249e18c2b082c07aff907a273741b3f8160414b0e9193c/scipy-1.16.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:72d1717fd3b5e6ec747327ce9bda32d5463f472c9dce9f54499e81fbd50245a1", size = 35676692, upload-time = "2025-10-28T17:33:03.88Z" }, + { url = "https://files.pythonhosted.org/packages/27/82/df26e44da78bf8d2aeaf7566082260cfa15955a5a6e96e6a29935b64132f/scipy-1.16.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1fb2472e72e24d1530debe6ae078db70fb1605350c88a3d14bc401d6306dbffe", size = 36019345, upload-time = "2025-10-28T17:33:09.773Z" }, + { url = "https://files.pythonhosted.org/packages/82/31/006cbb4b648ba379a95c87262c2855cd0d09453e500937f78b30f02fa1cd/scipy-1.16.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:c5192722cffe15f9329a3948c4b1db789fbb1f05c97899187dcf009b283aea70", size = 38678975, upload-time = "2025-10-28T17:33:15.809Z" }, + { url = "https://files.pythonhosted.org/packages/c2/7f/acbd28c97e990b421af7d6d6cd416358c9c293fc958b8529e0bd5d2a2a19/scipy-1.16.3-cp312-cp312-win_amd64.whl", hash = "sha256:56edc65510d1331dae01ef9b658d428e33ed48b4f77b1d51caf479a0253f96dc", size = 38555926, upload-time = "2025-10-28T17:33:21.388Z" }, + { url = "https://files.pythonhosted.org/packages/ce/69/c5c7807fd007dad4f48e0a5f2153038dc96e8725d3345b9ee31b2b7bed46/scipy-1.16.3-cp312-cp312-win_arm64.whl", hash = "sha256:a8a26c78ef223d3e30920ef759e25625a0ecdd0d60e5a8818b7513c3e5384cf2", size = 25463014, upload-time = "2025-10-28T17:33:25.975Z" }, + { url = "https://files.pythonhosted.org/packages/72/f1/57e8327ab1508272029e27eeef34f2302ffc156b69e7e233e906c2a5c379/scipy-1.16.3-cp313-cp313-macosx_10_14_x86_64.whl", hash = "sha256:d2ec56337675e61b312179a1ad124f5f570c00f920cc75e1000025451b88241c", size = 36617856, upload-time = "2025-10-28T17:33:31.375Z" }, + { url = "https://files.pythonhosted.org/packages/44/13/7e63cfba8a7452eb756306aa2fd9b37a29a323b672b964b4fdeded9a3f21/scipy-1.16.3-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:16b8bc35a4cc24db80a0ec836a9286d0e31b2503cb2fd7ff7fb0e0374a97081d", size = 28874306, upload-time = "2025-10-28T17:33:36.516Z" }, + { url = "https://files.pythonhosted.org/packages/15/65/3a9400efd0228a176e6ec3454b1fa998fbbb5a8defa1672c3f65706987db/scipy-1.16.3-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:5803c5fadd29de0cf27fa08ccbfe7a9e5d741bf63e4ab1085437266f12460ff9", size = 20865371, upload-time = "2025-10-28T17:33:42.094Z" }, + { url = "https://files.pythonhosted.org/packages/33/d7/eda09adf009a9fb81827194d4dd02d2e4bc752cef16737cc4ef065234031/scipy-1.16.3-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:b81c27fc41954319a943d43b20e07c40bdcd3ff7cf013f4fb86286faefe546c4", size = 23524877, upload-time = "2025-10-28T17:33:48.483Z" }, + { url = "https://files.pythonhosted.org/packages/7d/6b/3f911e1ebc364cb81320223a3422aab7d26c9c7973109a9cd0f27c64c6c0/scipy-1.16.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:0c3b4dd3d9b08dbce0f3440032c52e9e2ab9f96ade2d3943313dfe51a7056959", size = 33342103, upload-time = "2025-10-28T17:33:56.495Z" }, + { url = "https://files.pythonhosted.org/packages/21/f6/4bfb5695d8941e5c570a04d9fcd0d36bce7511b7d78e6e75c8f9791f82d0/scipy-1.16.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7dc1360c06535ea6116a2220f760ae572db9f661aba2d88074fe30ec2aa1ff88", size = 35697297, upload-time = "2025-10-28T17:34:04.722Z" }, + { url = "https://files.pythonhosted.org/packages/04/e1/6496dadbc80d8d896ff72511ecfe2316b50313bfc3ebf07a3f580f08bd8c/scipy-1.16.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:663b8d66a8748051c3ee9c96465fb417509315b99c71550fda2591d7dd634234", size = 36021756, upload-time = "2025-10-28T17:34:13.482Z" }, + { url = "https://files.pythonhosted.org/packages/fe/bd/a8c7799e0136b987bda3e1b23d155bcb31aec68a4a472554df5f0937eef7/scipy-1.16.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eab43fae33a0c39006a88096cd7b4f4ef545ea0447d250d5ac18202d40b6611d", size = 38696566, upload-time = "2025-10-28T17:34:22.384Z" }, + { url = "https://files.pythonhosted.org/packages/cd/01/1204382461fcbfeb05b6161b594f4007e78b6eba9b375382f79153172b4d/scipy-1.16.3-cp313-cp313-win_amd64.whl", hash = "sha256:062246acacbe9f8210de8e751b16fc37458213f124bef161a5a02c7a39284304", size = 38529877, upload-time = "2025-10-28T17:35:51.076Z" }, + { url = "https://files.pythonhosted.org/packages/7f/14/9d9fbcaa1260a94f4bb5b64ba9213ceb5d03cd88841fe9fd1ffd47a45b73/scipy-1.16.3-cp313-cp313-win_arm64.whl", hash = "sha256:50a3dbf286dbc7d84f176f9a1574c705f277cb6565069f88f60db9eafdbe3ee2", size = 25455366, upload-time = "2025-10-28T17:35:59.014Z" }, + { url = "https://files.pythonhosted.org/packages/e2/a3/9ec205bd49f42d45d77f1730dbad9ccf146244c1647605cf834b3a8c4f36/scipy-1.16.3-cp313-cp313t-macosx_10_14_x86_64.whl", hash = "sha256:fb4b29f4cf8cc5a8d628bc8d8e26d12d7278cd1f219f22698a378c3d67db5e4b", size = 37027931, upload-time = "2025-10-28T17:34:31.451Z" }, + { url = "https://files.pythonhosted.org/packages/25/06/ca9fd1f3a4589cbd825b1447e5db3a8ebb969c1eaf22c8579bd286f51b6d/scipy-1.16.3-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:8d09d72dc92742988b0e7750bddb8060b0c7079606c0d24a8cc8e9c9c11f9079", size = 29400081, upload-time = "2025-10-28T17:34:39.087Z" }, + { url = "https://files.pythonhosted.org/packages/6a/56/933e68210d92657d93fb0e381683bc0e53a965048d7358ff5fbf9e6a1b17/scipy-1.16.3-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:03192a35e661470197556de24e7cb1330d84b35b94ead65c46ad6f16f6b28f2a", size = 21391244, upload-time = "2025-10-28T17:34:45.234Z" }, + { url = "https://files.pythonhosted.org/packages/a8/7e/779845db03dc1418e215726329674b40576879b91814568757ff0014ad65/scipy-1.16.3-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:57d01cb6f85e34f0946b33caa66e892aae072b64b034183f3d87c4025802a119", size = 23929753, upload-time = "2025-10-28T17:34:51.793Z" }, + { url = "https://files.pythonhosted.org/packages/4c/4b/f756cf8161d5365dcdef9e5f460ab226c068211030a175d2fc7f3f41ca64/scipy-1.16.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:96491a6a54e995f00a28a3c3badfff58fd093bf26cd5fb34a2188c8c756a3a2c", size = 33496912, upload-time = "2025-10-28T17:34:59.8Z" }, + { url = "https://files.pythonhosted.org/packages/09/b5/222b1e49a58668f23839ca1542a6322bb095ab8d6590d4f71723869a6c2c/scipy-1.16.3-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:cd13e354df9938598af2be05822c323e97132d5e6306b83a3b4ee6724c6e522e", size = 35802371, upload-time = "2025-10-28T17:35:08.173Z" }, + { url = "https://files.pythonhosted.org/packages/c1/8d/5964ef68bb31829bde27611f8c9deeac13764589fe74a75390242b64ca44/scipy-1.16.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:63d3cdacb8a824a295191a723ee5e4ea7768ca5ca5f2838532d9f2e2b3ce2135", size = 36190477, upload-time = "2025-10-28T17:35:16.7Z" }, + { url = "https://files.pythonhosted.org/packages/ab/f2/b31d75cb9b5fa4dd39a0a931ee9b33e7f6f36f23be5ef560bf72e0f92f32/scipy-1.16.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:e7efa2681ea410b10dde31a52b18b0154d66f2485328830e45fdf183af5aefc6", size = 38796678, upload-time = "2025-10-28T17:35:26.354Z" }, + { url = "https://files.pythonhosted.org/packages/b4/1e/b3723d8ff64ab548c38d87055483714fefe6ee20e0189b62352b5e015bb1/scipy-1.16.3-cp313-cp313t-win_amd64.whl", hash = "sha256:2d1ae2cf0c350e7705168ff2429962a89ad90c2d49d1dd300686d8b2a5af22fc", size = 38640178, upload-time = "2025-10-28T17:35:35.304Z" }, + { url = "https://files.pythonhosted.org/packages/8e/f3/d854ff38789aca9b0cc23008d607ced9de4f7ab14fa1ca4329f86b3758ca/scipy-1.16.3-cp313-cp313t-win_arm64.whl", hash = "sha256:0c623a54f7b79dd88ef56da19bc2873afec9673a48f3b85b18e4d402bdd29a5a", size = 25803246, upload-time = "2025-10-28T17:35:42.155Z" }, + { url = "https://files.pythonhosted.org/packages/99/f6/99b10fd70f2d864c1e29a28bbcaa0c6340f9d8518396542d9ea3b4aaae15/scipy-1.16.3-cp314-cp314-macosx_10_14_x86_64.whl", hash = "sha256:875555ce62743e1d54f06cdf22c1e0bc47b91130ac40fe5d783b6dfa114beeb6", size = 36606469, upload-time = "2025-10-28T17:36:08.741Z" }, + { url = "https://files.pythonhosted.org/packages/4d/74/043b54f2319f48ea940dd025779fa28ee360e6b95acb7cd188fad4391c6b/scipy-1.16.3-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:bb61878c18a470021fb515a843dc7a76961a8daceaaaa8bad1332f1bf4b54657", size = 28872043, upload-time = "2025-10-28T17:36:16.599Z" }, + { url = "https://files.pythonhosted.org/packages/4d/e1/24b7e50cc1c4ee6ffbcb1f27fe9f4c8b40e7911675f6d2d20955f41c6348/scipy-1.16.3-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:f2622206f5559784fa5c4b53a950c3c7c1cf3e84ca1b9c4b6c03f062f289ca26", size = 20862952, upload-time = "2025-10-28T17:36:22.966Z" }, + { url = "https://files.pythonhosted.org/packages/dd/3a/3e8c01a4d742b730df368e063787c6808597ccb38636ed821d10b39ca51b/scipy-1.16.3-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:7f68154688c515cdb541a31ef8eb66d8cd1050605be9dcd74199cbd22ac739bc", size = 23508512, upload-time = "2025-10-28T17:36:29.731Z" }, + { url = "https://files.pythonhosted.org/packages/1f/60/c45a12b98ad591536bfe5330cb3cfe1850d7570259303563b1721564d458/scipy-1.16.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:8b3c820ddb80029fe9f43d61b81d8b488d3ef8ca010d15122b152db77dc94c22", size = 33413639, upload-time = "2025-10-28T17:36:37.982Z" }, + { url = "https://files.pythonhosted.org/packages/71/bc/35957d88645476307e4839712642896689df442f3e53b0fa016ecf8a3357/scipy-1.16.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d3837938ae715fc0fe3c39c0202de3a8853aff22ca66781ddc2ade7554b7e2cc", size = 35704729, upload-time = "2025-10-28T17:36:46.547Z" }, + { url = "https://files.pythonhosted.org/packages/3b/15/89105e659041b1ca11c386e9995aefacd513a78493656e57789f9d9eab61/scipy-1.16.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:aadd23f98f9cb069b3bd64ddc900c4d277778242e961751f77a8cb5c4b946fb0", size = 36086251, upload-time = "2025-10-28T17:36:55.161Z" }, + { url = "https://files.pythonhosted.org/packages/1a/87/c0ea673ac9c6cc50b3da2196d860273bc7389aa69b64efa8493bdd25b093/scipy-1.16.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:b7c5f1bda1354d6a19bc6af73a649f8285ca63ac6b52e64e658a5a11d4d69800", size = 38716681, upload-time = "2025-10-28T17:37:04.1Z" }, + { url = "https://files.pythonhosted.org/packages/91/06/837893227b043fb9b0d13e4bd7586982d8136cb249ffb3492930dab905b8/scipy-1.16.3-cp314-cp314-win_amd64.whl", hash = "sha256:e5d42a9472e7579e473879a1990327830493a7047506d58d73fc429b84c1d49d", size = 39358423, upload-time = "2025-10-28T17:38:20.005Z" }, + { url = "https://files.pythonhosted.org/packages/95/03/28bce0355e4d34a7c034727505a02d19548549e190bedd13a721e35380b7/scipy-1.16.3-cp314-cp314-win_arm64.whl", hash = "sha256:6020470b9d00245926f2d5bb93b119ca0340f0d564eb6fbaad843eaebf9d690f", size = 26135027, upload-time = "2025-10-28T17:38:24.966Z" }, + { url = "https://files.pythonhosted.org/packages/b2/6f/69f1e2b682efe9de8fe9f91040f0cd32f13cfccba690512ba4c582b0bc29/scipy-1.16.3-cp314-cp314t-macosx_10_14_x86_64.whl", hash = "sha256:e1d27cbcb4602680a49d787d90664fa4974063ac9d4134813332a8c53dbe667c", size = 37028379, upload-time = "2025-10-28T17:37:14.061Z" }, + { url = "https://files.pythonhosted.org/packages/7c/2d/e826f31624a5ebbab1cd93d30fd74349914753076ed0593e1d56a98c4fb4/scipy-1.16.3-cp314-cp314t-macosx_12_0_arm64.whl", hash = "sha256:9b9c9c07b6d56a35777a1b4cc8966118fb16cfd8daf6743867d17d36cfad2d40", size = 29400052, upload-time = "2025-10-28T17:37:21.709Z" }, + { url = "https://files.pythonhosted.org/packages/69/27/d24feb80155f41fd1f156bf144e7e049b4e2b9dd06261a242905e3bc7a03/scipy-1.16.3-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:3a4c460301fb2cffb7f88528f30b3127742cff583603aa7dc964a52c463b385d", size = 21391183, upload-time = "2025-10-28T17:37:29.559Z" }, + { url = "https://files.pythonhosted.org/packages/f8/d3/1b229e433074c5738a24277eca520a2319aac7465eea7310ea6ae0e98ae2/scipy-1.16.3-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:f667a4542cc8917af1db06366d3f78a5c8e83badd56409f94d1eac8d8d9133fa", size = 23930174, upload-time = "2025-10-28T17:37:36.306Z" }, + { url = "https://files.pythonhosted.org/packages/16/9d/d9e148b0ec680c0f042581a2be79a28a7ab66c0c4946697f9e7553ead337/scipy-1.16.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f379b54b77a597aa7ee5e697df0d66903e41b9c85a6dd7946159e356319158e8", size = 33497852, upload-time = "2025-10-28T17:37:42.228Z" }, + { url = "https://files.pythonhosted.org/packages/2f/22/4e5f7561e4f98b7bea63cf3fd7934bff1e3182e9f1626b089a679914d5c8/scipy-1.16.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4aff59800a3b7f786b70bfd6ab551001cb553244988d7d6b8299cb1ea653b353", size = 35798595, upload-time = "2025-10-28T17:37:48.102Z" }, + { url = "https://files.pythonhosted.org/packages/83/42/6644d714c179429fc7196857866f219fef25238319b650bb32dde7bf7a48/scipy-1.16.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:da7763f55885045036fabcebd80144b757d3db06ab0861415d1c3b7c69042146", size = 36186269, upload-time = "2025-10-28T17:37:53.72Z" }, + { url = "https://files.pythonhosted.org/packages/ac/70/64b4d7ca92f9cf2e6fc6aaa2eecf80bb9b6b985043a9583f32f8177ea122/scipy-1.16.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ffa6eea95283b2b8079b821dc11f50a17d0571c92b43e2b5b12764dc5f9b285d", size = 38802779, upload-time = "2025-10-28T17:37:59.393Z" }, + { url = "https://files.pythonhosted.org/packages/61/82/8d0e39f62764cce5ffd5284131e109f07cf8955aef9ab8ed4e3aa5e30539/scipy-1.16.3-cp314-cp314t-win_amd64.whl", hash = "sha256:d9f48cafc7ce94cf9b15c6bffdc443a81a27bf7075cf2dcd5c8b40f85d10c4e7", size = 39471128, upload-time = "2025-10-28T17:38:05.259Z" }, + { url = "https://files.pythonhosted.org/packages/64/47/a494741db7280eae6dc033510c319e34d42dd41b7ac0c7ead39354d1a2b5/scipy-1.16.3-cp314-cp314t-win_arm64.whl", hash = "sha256:21d9d6b197227a12dcbf9633320a4e34c6b0e51c57268df255a0942983bac562", size = 26464127, upload-time = "2025-10-28T17:38:11.34Z" }, +] + +[[package]] +name = "send2trash" +version = "1.8.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/fd/3a/aec9b02217bb79b87bbc1a21bc6abc51e3d5dcf65c30487ac96c0908c722/Send2Trash-1.8.3.tar.gz", hash = "sha256:b18e7a3966d99871aefeb00cfbcfdced55ce4871194810fc71f4aa484b953abf", size = 17394, upload-time = "2024-04-07T00:01:09.267Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/40/b0/4562db6223154aa4e22f939003cb92514c79f3d4dccca3444253fd17f902/Send2Trash-1.8.3-py3-none-any.whl", hash = "sha256:0c31227e0bd08961c7665474a3d1ef7193929fedda4233843689baa056be46c9", size = 18072, upload-time = "2024-04-07T00:01:07.438Z" }, +] + +[[package]] +name = "setuptools" +version = "80.9.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/18/5d/3bf57dcd21979b887f014ea83c24ae194cfcd12b9e0fda66b957c69d1fca/setuptools-80.9.0.tar.gz", hash = "sha256:f36b47402ecde768dbfafc46e8e4207b4360c654f1f3bb84475f0a28628fb19c", size = 1319958, upload-time = "2025-05-27T00:56:51.443Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a3/dc/17031897dae0efacfea57dfd3a82fdd2a2aeb58e0ff71b77b87e44edc772/setuptools-80.9.0-py3-none-any.whl", hash = "sha256:062d34222ad13e0cc312a4c02d73f059e86a4acbfbdea8f8f76b28c99f306922", size = 1201486, upload-time = "2025-05-27T00:56:49.664Z" }, +] + +[[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 = "sniffio" +version = "1.3.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a2/87/a6771e1546d97e7e041b6ae58d80074f81b7d5121207425c964ddf5cfdbd/sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc", size = 20372, upload-time = "2024-02-25T23:20:04.057Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235, upload-time = "2024-02-25T23:20:01.196Z" }, +] + +[[package]] +name = "soupsieve" +version = "2.8" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6d/e6/21ccce3262dd4889aa3332e5a119a3491a95e8f60939870a3a035aabac0d/soupsieve-2.8.tar.gz", hash = "sha256:e2dd4a40a628cb5f28f6d4b0db8800b8f581b65bb380b97de22ba5ca8d72572f", size = 103472, upload-time = "2025-08-27T15:39:51.78Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/14/a0/bb38d3b76b8cae341dad93a2dd83ab7462e6dbcdd84d43f54ee60a8dc167/soupsieve-2.8-py3-none-any.whl", hash = "sha256:0cc76456a30e20f5d7f2e14a98a4ae2ee4e5abdc7c5ea0aafe795f344bc7984c", size = 36679, upload-time = "2025-08-27T15:39:50.179Z" }, +] + +[[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 = "statsmodels" +version = "0.14.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, + { name = "packaging" }, + { name = "pandas" }, + { name = "patsy" }, + { name = "scipy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/64/cc/8c1bf59bf8203dea1bf2ea811cfe667d7bcc6909c83d8afb02b08e30f50b/statsmodels-0.14.5.tar.gz", hash = "sha256:de260e58cccfd2ceddf835b55a357233d6ca853a1aa4f90f7553a52cc71c6ddf", size = 20525016, upload-time = "2025-07-07T12:14:23.195Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5f/a5/fcc4f5f16355660ce7a1742e28a43e3a9391b492fc4ff29fdd6893e81c05/statsmodels-0.14.5-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:37e7364a39f9aa3b51d15a208c2868b90aadb8412f868530f5cba9197cb00eaa", size = 10042891, upload-time = "2025-07-07T12:13:41.671Z" }, + { url = "https://files.pythonhosted.org/packages/1c/6f/db0cf5efa48277ac6218d9b981c8fd5e63c4c43e0d9d65015fdc38eed0ef/statsmodels-0.14.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:4263d7f4d0f1d5ac6eb4db22e1ee34264a14d634b9332c975c9d9109b6b46e12", size = 9698912, upload-time = "2025-07-07T12:07:54.674Z" }, + { url = "https://files.pythonhosted.org/packages/4a/93/4ddc3bc4a59c51e6a57c49df1b889882c40d9e141e855b3517f6a8de3232/statsmodels-0.14.5-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:86224f6e36f38486e471e75759d241fe2912d8bc25ab157d54ee074c6aedbf45", size = 10237801, upload-time = "2025-07-07T14:23:12.593Z" }, + { url = "https://files.pythonhosted.org/packages/66/de/dc6bf2f6e8c8eb4c5815560ebdbdf2d69a767bc0f65fde34bc086cf5b36d/statsmodels-0.14.5-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c3dd760a6fa80cd5e0371685c697bb9c2c0e6e1f394d975e596a1e6d0bbb9372", size = 10424154, upload-time = "2025-07-07T14:23:25.365Z" }, + { url = "https://files.pythonhosted.org/packages/16/4f/2d5a8d14bebdf2b03b3ea89b8c6a2c837bb406ba5b7a41add8bd303bce29/statsmodels-0.14.5-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:6264fb00e02f858b86bd01ef2dc05055a71d4a0cc7551b9976b07b0f0e6cf24f", size = 10652915, upload-time = "2025-07-07T14:23:39.337Z" }, + { url = "https://files.pythonhosted.org/packages/df/4c/2feda3a9f0e17444a84ba5398ada6a4d2e1b8f832760048f04e2b8ea0c41/statsmodels-0.14.5-cp312-cp312-win_amd64.whl", hash = "sha256:b2ed065bfbaf8bb214c7201656df840457c2c8c65e1689e3eb09dc7440f9c61c", size = 9611236, upload-time = "2025-07-07T12:08:06.794Z" }, + { url = "https://files.pythonhosted.org/packages/84/fd/4c374108cf108b3130240a5b45847a61f70ddf973429044a81a05189b046/statsmodels-0.14.5-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:906263134dd1a640e55ecb01fda4a9be7b9e08558dba9e4c4943a486fdb0c9c8", size = 10013958, upload-time = "2025-07-07T14:35:01.04Z" }, + { url = "https://files.pythonhosted.org/packages/5a/36/bf3d7f0e36acd3ba9ec0babd79ace25506b6872780cbd710fb7cd31f0fa2/statsmodels-0.14.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:9118f76344f77cffbb3a9cbcff8682b325be5eed54a4b3253e09da77a74263d3", size = 9674243, upload-time = "2025-07-07T12:08:22.571Z" }, + { url = "https://files.pythonhosted.org/packages/90/ce/a55a6f37b5277683ceccd965a5828b24672bbc427db6b3969ae0b0fc29fb/statsmodels-0.14.5-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9dc4ee159070557c9a6c000625d85f653de437772fe7086857cff68f501afe45", size = 10219521, upload-time = "2025-07-07T14:23:52.646Z" }, + { url = "https://files.pythonhosted.org/packages/1e/48/973da1ee8bc0743519759e74c3615b39acdc3faf00e0a0710f8c856d8c9d/statsmodels-0.14.5-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5a085d47c8ef5387279a991633883d0e700de2b0acc812d7032d165888627bef", size = 10453538, upload-time = "2025-07-07T14:24:06.959Z" }, + { url = "https://files.pythonhosted.org/packages/c7/d6/18903fb707afd31cf1edaec5201964dbdacb2bfae9a22558274647a7c88f/statsmodels-0.14.5-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9f866b2ebb2904b47c342d00def83c526ef2eb1df6a9a3c94ba5fe63d0005aec", size = 10681584, upload-time = "2025-07-07T14:24:21.038Z" }, + { url = "https://files.pythonhosted.org/packages/44/d6/80df1bbbfcdc50bff4152f43274420fa9856d56e234d160d6206eb1f5827/statsmodels-0.14.5-cp313-cp313-win_amd64.whl", hash = "sha256:2a06bca03b7a492f88c8106103ab75f1a5ced25de90103a89f3a287518017939", size = 9604641, upload-time = "2025-07-07T12:08:36.23Z" }, + { url = "https://files.pythonhosted.org/packages/fd/6c/0fb40a89d715412160097c6f3387049ed88c9bd866c8838a8852c705ae2f/statsmodels-0.14.5-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:07c4dad25bbb15864a31b4917a820f6d104bdc24e5ddadcda59027390c3bed9e", size = 10211256, upload-time = "2025-10-30T13:46:58.591Z" }, + { url = "https://files.pythonhosted.org/packages/88/4a/e36fe8b19270ab3e80df357da924c6c029cab0fb9a0fbd28aaf49341707d/statsmodels-0.14.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:babb067c852e966c2c933b79dbb5d0240919d861941a2ef6c0e13321c255528d", size = 10110933, upload-time = "2025-10-30T13:47:11.774Z" }, + { url = "https://files.pythonhosted.org/packages/8a/bf/1b7e7b1a6c09a88a9c5c9e60622c050dfd08af11c2e6d4a42dbc71b32ee1/statsmodels-0.14.5-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:110194b137286173cc676d7bad0119a197778de6478fc6cbdc3b33571165ac1e", size = 10253981, upload-time = "2025-10-30T16:32:22.399Z" }, + { url = "https://files.pythonhosted.org/packages/b8/d0/f95da95524bdd99613923ca61a3036d1308cee1290e5e8acb89f51736a8c/statsmodels-0.14.5-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9c8a9c384a60c80731b278e7fd18764364c8817f4995b13a175d636f967823d1", size = 10460450, upload-time = "2025-10-30T16:32:44.985Z" }, + { url = "https://files.pythonhosted.org/packages/28/bb/59e7be0271be264b7b541baf3973f97747740950bfd5115de731f63da8ab/statsmodels-0.14.5-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:557df3a870a57248df744fdfcc444ecbc5bdbf1c042b8a8b5d8e3e797830dc2a", size = 10694060, upload-time = "2025-10-30T16:33:07.656Z" }, + { url = "https://files.pythonhosted.org/packages/8b/c0/b28d0fd0347ea38d3610052f479e4b922eb33bb8790817f93cd89e6e08ba/statsmodels-0.14.5-cp314-cp314-win_amd64.whl", hash = "sha256:95af7a9c4689d514f4341478b891f867766f3da297f514b8c4adf08f4fa61d03", size = 9648961, upload-time = "2025-10-30T13:47:24.303Z" }, +] + +[[package]] +name = "terminado" +version = "0.18.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ptyprocess", marker = "os_name != 'nt'" }, + { name = "pywinpty", marker = "os_name == 'nt'" }, + { name = "tornado" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/8a/11/965c6fd8e5cc254f1fe142d547387da17a8ebfd75a3455f637c663fb38a0/terminado-0.18.1.tar.gz", hash = "sha256:de09f2c4b85de4765f7714688fff57d3e75bad1f909b589fde880460c753fd2e", size = 32701, upload-time = "2024-03-12T14:34:39.026Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6a/9e/2064975477fdc887e47ad42157e214526dcad8f317a948dee17e1659a62f/terminado-0.18.1-py3-none-any.whl", hash = "sha256:a4468e1b37bb318f8a86514f65814e1afc977cf29b3992a4500d9dd305dcceb0", size = 14154, upload-time = "2024-03-12T14:34:36.569Z" }, +] + +[[package]] +name = "tinycss2" +version = "1.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "webencodings" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/7a/fd/7a5ee21fd08ff70d3d33a5781c255cbe779659bd03278feb98b19ee550f4/tinycss2-1.4.0.tar.gz", hash = "sha256:10c0972f6fc0fbee87c3edb76549357415e94548c1ae10ebccdea16fb404a9b7", size = 87085, upload-time = "2024-10-24T14:58:29.895Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e6/34/ebdc18bae6aa14fbee1a08b63c015c72b64868ff7dae68808ab500c492e2/tinycss2-1.4.0-py3-none-any.whl", hash = "sha256:3a49cf47b7675da0b15d0c6e1df8df4ebd96e9394bb905a5775adb0d884c5289", size = 26610, upload-time = "2024-10-24T14:58:28.029Z" }, +] + +[[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 = "typing-extensions" +version = "4.15.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" }, +] + +[[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 = "uri-template" +version = "1.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/31/c7/0336f2bd0bcbada6ccef7aaa25e443c118a704f828a0620c6fa0207c1b64/uri-template-1.3.0.tar.gz", hash = "sha256:0e00f8eb65e18c7de20d595a14336e9f337ead580c70934141624b6d1ffdacc7", size = 21678, upload-time = "2023-06-21T01:49:05.374Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e7/00/3fca040d7cf8a32776d3d81a00c8ee7457e00f80c649f1e4a863c8321ae9/uri_template-1.3.0-py3-none-any.whl", hash = "sha256:a44a133ea12d44a0c0f06d7d42a52d71282e77e2f937d8abd5655b8d56fc1363", size = 11140, upload-time = "2023-06-21T01:49:03.467Z" }, +] + +[[package]] +name = "urllib3" +version = "2.5.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/15/22/9ee70a2574a4f4599c47dd506532914ce044817c7752a79b6a51286319bc/urllib3-2.5.0.tar.gz", hash = "sha256:3fc47733c7e419d4bc3f6b3dc2b4f890bb743906a30d56ba4a5bfa4bbff92760", size = 393185, upload-time = "2025-06-18T14:07:41.644Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a7/c2/fe1e52489ae3122415c51f387e221dd0773709bad6c6cdaa599e8a2c5185/urllib3-2.5.0-py3-none-any.whl", hash = "sha256:e6b01673c0fa6a13e374b50871808eb3bf7046c4b125b216f6bf1cc604cff0dc", size = 129795, upload-time = "2025-06-18T14:07:40.39Z" }, +] + +[[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" }, +] + +[[package]] +name = "webcolors" +version = "25.10.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1d/7a/eb316761ec35664ea5174709a68bbd3389de60d4a1ebab8808bfc264ed67/webcolors-25.10.0.tar.gz", hash = "sha256:62abae86504f66d0f6364c2a8520de4a0c47b80c03fc3a5f1815fedbef7c19bf", size = 53491, upload-time = "2025-10-31T07:51:03.977Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e2/cc/e097523dd85c9cf5d354f78310927f1656c422bd7b2613b2db3e3f9a0f2c/webcolors-25.10.0-py3-none-any.whl", hash = "sha256:032c727334856fc0b968f63daa252a1ac93d33db2f5267756623c210e57a4f1d", size = 14905, upload-time = "2025-10-31T07:51:01.778Z" }, +] + +[[package]] +name = "webencodings" +version = "0.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0b/02/ae6ceac1baeda530866a85075641cec12989bd8d31af6d5ab4a3e8c92f47/webencodings-0.5.1.tar.gz", hash = "sha256:b36a1c245f2d304965eb4e0a82848379241dc04b865afcc4aab16748587e1923", size = 9721, upload-time = "2017-04-05T20:21:34.189Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f4/24/2a3e3df732393fed8b3ebf2ec078f05546de641fe1b667ee316ec1dcf3b7/webencodings-0.5.1-py2.py3-none-any.whl", hash = "sha256:a0af1213f3c2226497a97e2b3aa01a7e4bee4f403f95be16fc9acd2947514a78", size = 11774, upload-time = "2017-04-05T20:21:32.581Z" }, +] + +[[package]] +name = "websocket-client" +version = "1.9.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/2c/41/aa4bf9664e4cda14c3b39865b12251e8e7d239f4cd0e3cc1b6c2ccde25c1/websocket_client-1.9.0.tar.gz", hash = "sha256:9e813624b6eb619999a97dc7958469217c3176312b3a16a4bd1bc7e08a46ec98", size = 70576, upload-time = "2025-10-07T21:16:36.495Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/34/db/b10e48aa8fff7407e67470363eac595018441cf32d5e1001567a7aeba5d2/websocket_client-1.9.0-py3-none-any.whl", hash = "sha256:af248a825037ef591efbf6ed20cc5faa03d3b47b9e5a2230a529eeee1c1fc3ef", size = 82616, upload-time = "2025-10-07T21:16:34.951Z" }, +] From 06d77a6630db9b6987108226f9f00659d665ef2f Mon Sep 17 00:00:00 2001 From: Andrei Chernov Date: Tue, 4 Nov 2025 14:51:34 +0100 Subject: [PATCH 05/10] 0.3.3 release --- .github/workflows/lint.yml | 81 + .github/workflows/test.yml | 78 + .gitignore | 3 +- README.md | 29 +- examples/flowstate_simple_example.ipynb | 82 +- examples/model_comparison_example.ipynb | 279 +-- faim_sdk/__init__.py | 12 +- faim_sdk/client.py | 38 +- faim_sdk/models.py | 26 +- pyproject.toml | 41 + tests/unit/test_client.py | 627 +++++++ tests/unit/test_exceptions.py | 628 +++++++ tests/unit/test_models.py | 476 ++++++ tests/unit/test_utils.py | 456 +++++ uv.lock | 2059 ----------------------- 15 files changed, 2485 insertions(+), 2430 deletions(-) create mode 100644 .github/workflows/lint.yml create mode 100644 .github/workflows/test.yml create mode 100644 pyproject.toml create mode 100644 tests/unit/test_client.py create mode 100644 tests/unit/test_exceptions.py create mode 100644 tests/unit/test_models.py create mode 100644 tests/unit/test_utils.py delete mode 100644 uv.lock diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml new file mode 100644 index 0000000..4b76b0e --- /dev/null +++ b/.github/workflows/lint.yml @@ -0,0 +1,81 @@ +name: Lint + +on: + push: + branches: [main, develop, feat/**] + pull_request: + branches: [main, develop] + +jobs: + ruff: + name: Ruff (Linter & Formatter) + runs-on: ubuntu-latest + steps: + - name: Checkout code + uses: actions/checkout@v4 + + - name: Set up Python + uses: actions/setup-python@v5 + with: + python-version: "3.11" + + - name: Install Ruff + run: pip install ruff + + - name: Run Ruff linter + run: ruff check faim_sdk/ faim_client/ tests/ + + - name: Run Ruff formatter check + run: ruff format --check faim_sdk/ faim_client/ tests/ + + type-check: + name: Type Checking (mypy) + runs-on: ubuntu-latest + steps: + - name: Checkout code + uses: actions/checkout@v4 + + - name: Set up Python + uses: actions/setup-python@v5 + with: + python-version: "3.11" + + - name: Install uv + uses: astral-sh/setup-uv@v3 + with: + version: "latest" + + - name: Install dependencies + run: | + uv pip install --system -e . + uv pip install --system mypy types-requests + + - name: Run mypy + run: mypy faim_sdk/ --ignore-missing-imports --no-strict-optional + continue-on-error: true + + package-check: + name: Package Build Check + runs-on: ubuntu-latest + steps: + - name: Checkout code + uses: actions/checkout@v4 + + - name: Set up Python + uses: actions/setup-python@v5 + with: + python-version: "3.11" + + - name: Install build dependencies + run: pip install poetry build twine + + - name: Build package + run: poetry build + + - name: Check package with twine + run: twine check dist/* + + - name: Verify package contents + run: | + tar -tzf dist/*.tar.gz | grep -E "faim_sdk|faim_client" + unzip -l dist/*.whl | grep -E "faim_sdk|faim_client" diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml new file mode 100644 index 0000000..fa96df7 --- /dev/null +++ b/.github/workflows/test.yml @@ -0,0 +1,78 @@ +name: Test + +on: + push: + branches: [main, develop, feat/**] + pull_request: + branches: [main, develop] + +jobs: + test: + name: Test Python ${{ matrix.python-version }} + runs-on: ubuntu-latest + strategy: + fail-fast: false + matrix: + python-version: ["3.11", "3.12"] + + steps: + - name: Checkout code + uses: actions/checkout@v4 + + - name: Set up Python ${{ matrix.python-version }} + uses: actions/setup-python@v5 + with: + python-version: ${{ matrix.python-version }} + + - name: Install uv + uses: astral-sh/setup-uv@v3 + with: + version: "latest" + + - name: Install dependencies + run: | + uv pip install --system -e . + uv pip install --system pytest pytest-cov pytest-asyncio + + - name: Run unit tests + run: | + pytest tests/unit/ -v --cov=faim_sdk --cov=faim_client --cov-report=xml --cov-report=term + + - name: Upload coverage to Codecov + uses: codecov/codecov-action@v4 + if: matrix.python-version == '3.11' + with: + file: ./coverage.xml + fail_ci_if_error: false + token: ${{ secrets.CODECOV_TOKEN }} + + test-examples: + name: Test Examples + runs-on: ubuntu-latest + steps: + - name: Checkout code + uses: actions/checkout@v4 + + - name: Set up Python 3.11 + uses: actions/setup-python@v5 + with: + python-version: "3.11" + + - name: Install uv + uses: astral-sh/setup-uv@v3 + with: + version: "latest" + + - name: Install dependencies with viz extras + run: | + uv pip install --system -e ".[viz]" + uv pip install --system jupyterlab pandas statsmodels + + - name: Check example notebooks can be read + run: | + python -c "import nbformat; nbformat.read('examples/flowstate_simple_example.ipynb', as_version=4)" + python -c "import nbformat; nbformat.read('examples/model_comparison_example.ipynb', as_version=4)" + + - name: Verify eval package imports + run: | + python -c "from faim_sdk.eval import mse, mase, crps_from_quantiles, plot_forecast; print('Eval imports successful')" diff --git a/.gitignore b/.gitignore index 40b808b..349373e 100644 --- a/.gitignore +++ b/.gitignore @@ -24,4 +24,5 @@ dmypy.json openapi.json pyproject.toml -CLAUDE.md \ No newline at end of file +CLAUDE.md +/poetry.lock diff --git a/README.md b/README.md index 40d3241..b169178 100644 --- a/README.md +++ b/README.md @@ -28,7 +28,6 @@ pip install faim-sdk ```python import numpy as np from faim_sdk import ForecastClient, Chronos2ForecastRequest -from faim_client.models import ModelName # Initialize client with your API endpoint client = ForecastClient( @@ -49,8 +48,8 @@ request = Chronos2ForecastRequest( quantiles=[0.1, 0.5, 0.9] # 10th, 50th (median), 90th percentiles ) -# Generate forecast -response = client.forecast(ModelName.CHRONOS2, request) +# Generate forecast - model inferred automatically from request type +response = client.forecast(request) # Access predictions print(response.quantiles.shape) # (32, 24, 3) @@ -75,7 +74,7 @@ request = FlowStateForecastRequest( prediction_type="mean" # Options: "mean", "median" ) -response = client.forecast(ModelName.FLOWSTATE, request) +response = client.forecast(request) print(response.point.shape) # (batch_size, 24, features) ``` @@ -94,7 +93,7 @@ request = Chronos2ForecastRequest( quantiles=[0.05, 0.25, 0.5, 0.75, 0.95] # Full distribution ) -response = client.forecast(ModelName.CHRONOS2, request) +response = client.forecast(request) print(response.quantiles.shape) # (batch_size, 24, 5) ``` @@ -111,7 +110,7 @@ request = TiRexForecastRequest( output_type="point" ) -response = client.forecast(ModelName.TIREX, request) +response = client.forecast(request) print(response.point.shape) # (batch_size, 24, features) ``` @@ -120,7 +119,7 @@ print(response.point.shape) # (batch_size, 24, features) All forecasts return a `ForecastResponse` object with predictions and metadata: ```python -response = client.forecast(ModelName.CHRONOS2, request) +response = client.forecast(request) # Access predictions based on output_type if response.point is not None: @@ -252,7 +251,6 @@ fig, axes = plot_forecast( import numpy as np from faim_sdk import ForecastClient, Chronos2ForecastRequest from faim_sdk.eval import mse, mase, crps_from_quantiles, plot_forecast -from faim_client.models import ModelName # Initialize client client = ForecastClient(base_url="https://api.faim.example.com") @@ -268,7 +266,7 @@ request = Chronos2ForecastRequest( output_type="quantiles", quantiles=[0.1, 0.5, 0.9] ) -response = client.forecast(ModelName.CHRONOS2, request) +response = client.forecast(request) # Evaluate point forecast (use median) point_pred = response.quantiles[:, :, 1:2] # Extract median, keep 3D shape @@ -315,6 +313,7 @@ The SDK provides **machine-readable error codes** for robust error handling: ```python from faim_sdk import ( ForecastClient, + Chronos2ForecastRequest, ValidationError, AuthenticationError, RateLimitError, @@ -323,7 +322,8 @@ from faim_sdk import ( ) try: - response = client.forecast(ModelName.CHRONOS2, request) + request = Chronos2ForecastRequest(x=data, horizon=24, quantiles=[0.1, 0.5, 0.9]) + response = client.forecast(request) except AuthenticationError as e: # Handle authentication failures (401, 403) @@ -375,7 +375,6 @@ The SDK supports async operations for concurrent requests: ```python import asyncio from faim_sdk import ForecastClient, Chronos2ForecastRequest -from faim_client.models import ModelName async def forecast_multiple_series(): client = ForecastClient( @@ -393,7 +392,7 @@ async def forecast_multiple_series(): # Execute concurrently async with client: tasks = [ - client.forecast_async(ModelName.CHRONOS2, req) + client.forecast_async(req) for req in requests ] responses = await asyncio.gather(*tasks) @@ -462,13 +461,15 @@ Use context managers for automatic resource cleanup: ```python # Sync context manager with ForecastClient(base_url="https://api.faim.example.com") as client: - response = client.forecast(ModelName.CHRONOS2, request) + request = Chronos2ForecastRequest(x=data, horizon=24, quantiles=[0.1, 0.5, 0.9]) + response = client.forecast(request) print(response.quantiles) # Client automatically closed # Async context manager async with ForecastClient(base_url="https://api.faim.example.com") as client: - response = await client.forecast_async(ModelName.CHRONOS2, request) + request = Chronos2ForecastRequest(x=data, horizon=24, quantiles=[0.1, 0.9]) + response = await client.forecast_async(request) print(response.quantiles) # Client automatically closed ``` diff --git a/examples/flowstate_simple_example.ipynb b/examples/flowstate_simple_example.ipynb index 0ee9f4f..ed22993 100644 --- a/examples/flowstate_simple_example.ipynb +++ b/examples/flowstate_simple_example.ipynb @@ -35,20 +35,9 @@ "start_time": "2025-11-03T19:29:40.615481Z" } }, - "source": [ - "import os\n", - "\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "import pandas as pd\n", - "\n", - "from faim_client.models import ModelName\n", - "\n", - "# Import FAIM SDK\n", - "from faim_sdk import FlowStateForecastRequest, ForecastClient" - ], + "source": "import os\n\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport pandas as pd\n\n# Import FAIM SDK\nfrom faim_sdk import FlowStateForecastRequest, ForecastClient\n\n# Import evaluation tools\nfrom faim_sdk.eval import mase, plot_forecast", "outputs": [], - "execution_count": 32 + "execution_count": null }, { "cell_type": "markdown", @@ -320,10 +309,10 @@ "evalue": "cannot reshape array of size 259 into shape (1,2048,1)", "output_type": "error", "traceback": [ - "\u001B[31m---------------------------------------------------------------------------\u001B[39m", - "\u001B[31mValueError\u001B[39m Traceback (most recent call last)", - "\u001B[36mCell\u001B[39m\u001B[36m \u001B[39m\u001B[32mIn[52]\u001B[39m\u001B[32m, line 10\u001B[39m\n\u001B[32m 7\u001B[39m horizon = \u001B[32m50\u001B[39m\n\u001B[32m 9\u001B[39m \u001B[38;5;66;03m# Use data from index -110 to -10 for context\u001B[39;00m\n\u001B[32m---> \u001B[39m\u001B[32m10\u001B[39m x = \u001B[43msunspots\u001B[49m\u001B[43m[\u001B[49m\u001B[43m-\u001B[49m\u001B[43mcontext_length\u001B[49m\u001B[43m \u001B[49m\u001B[43m-\u001B[49m\u001B[43m \u001B[49m\u001B[43mhorizon\u001B[49m\u001B[43m \u001B[49m\u001B[43m:\u001B[49m\u001B[43m \u001B[49m\u001B[43m-\u001B[49m\u001B[43mhorizon\u001B[49m\u001B[43m]\u001B[49m\u001B[43m.\u001B[49m\u001B[43mreshape\u001B[49m\u001B[43m(\u001B[49m\u001B[32;43m1\u001B[39;49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mcontext_length\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[32;43m1\u001B[39;49m\u001B[43m)\u001B[49m\n\u001B[32m 12\u001B[39m \u001B[38;5;66;03m# Ground truth for comparison (last 10 years)\u001B[39;00m\n\u001B[32m 13\u001B[39m y_true = sunspots[-horizon:]\n", - "\u001B[31mValueError\u001B[39m: cannot reshape array of size 259 into shape (1,2048,1)" + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mValueError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[52]\u001b[39m\u001b[32m, line 10\u001b[39m\n\u001b[32m 7\u001b[39m horizon = \u001b[32m50\u001b[39m\n\u001b[32m 9\u001b[39m \u001b[38;5;66;03m# Use data from index -110 to -10 for context\u001b[39;00m\n\u001b[32m---> \u001b[39m\u001b[32m10\u001b[39m x = \u001b[43msunspots\u001b[49m\u001b[43m[\u001b[49m\u001b[43m-\u001b[49m\u001b[43mcontext_length\u001b[49m\u001b[43m \u001b[49m\u001b[43m-\u001b[49m\u001b[43m \u001b[49m\u001b[43mhorizon\u001b[49m\u001b[43m \u001b[49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43m-\u001b[49m\u001b[43mhorizon\u001b[49m\u001b[43m]\u001b[49m\u001b[43m.\u001b[49m\u001b[43mreshape\u001b[49m\u001b[43m(\u001b[49m\u001b[32;43m1\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcontext_length\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[32;43m1\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[32m 12\u001b[39m \u001b[38;5;66;03m# Ground truth for comparison (last 10 years)\u001b[39;00m\n\u001b[32m 13\u001b[39m y_true = sunspots[-horizon:]\n", + "\u001b[31mValueError\u001b[39m: cannot reshape array of size 259 into shape (1,2048,1)" ] } ], @@ -487,60 +476,9 @@ "start_time": "2025-11-03T19:43:30.625141Z" } }, - "source": [ - "try:\n", - " # Make forecast request\n", - " response = client.forecast(ModelName.FLOWSTATE, request)\n", - "\n", - " print(\"✓ Forecast successful!\")\n", - " print(f\"\\nResponse: {response}\")\n", - " print(\"\\nResponse details:\")\n", - " print(f\" - Point predictions shape: {response.point.shape}\")\n", - " print(f\" - Metadata: {response.metadata}\")\n", - "\n", - " # Extract point predictions (FlowState returns 'point' array)\n", - " predictions = response.point.flatten() # Shape: (horizon,)\n", - "\n", - "except Exception as e:\n", - " print(f\"✗ Forecast failed: {e}\")\n", - " print(f\"\\nError type: {type(e).__name__}\")\n", - " if hasattr(e, \"details\"):\n", - " print(f\"Details: {e.details}\")\n", - " raise" - ], - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Failed to parse error response: Expecting value: line 2 column 1 (char 1)\n", - "API error: status=502, no error_response\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "✗ Forecast failed: Request failed with status 502 | status=502\n", - "\n", - "Error type: APIError\n", - "Details: {}\n" - ] - }, - { - "ename": "APIError", - "evalue": "Request failed with status 502 | status=502", - "output_type": "error", - "traceback": [ - "\u001B[31m---------------------------------------------------------------------------\u001B[39m", - "\u001B[31mAPIError\u001B[39m Traceback (most recent call last)", - "\u001B[36mCell\u001B[39m\u001B[36m \u001B[39m\u001B[32mIn[65]\u001B[39m\u001B[32m, line 3\u001B[39m\n\u001B[32m 1\u001B[39m \u001B[38;5;28;01mtry\u001B[39;00m:\n\u001B[32m 2\u001B[39m \u001B[38;5;66;03m# Make forecast request\u001B[39;00m\n\u001B[32m----> \u001B[39m\u001B[32m3\u001B[39m response = \u001B[43mclient\u001B[49m\u001B[43m.\u001B[49m\u001B[43mforecast\u001B[49m\u001B[43m(\u001B[49m\u001B[43mModelName\u001B[49m\u001B[43m.\u001B[49m\u001B[43mFLOWSTATE\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mrequest\u001B[49m\u001B[43m)\u001B[49m\n\u001B[32m 5\u001B[39m \u001B[38;5;28mprint\u001B[39m(\u001B[33m\"\u001B[39m\u001B[33m✓ Forecast successful!\u001B[39m\u001B[33m\"\u001B[39m)\n\u001B[32m 6\u001B[39m \u001B[38;5;28mprint\u001B[39m(\u001B[33mf\u001B[39m\u001B[33m\"\u001B[39m\u001B[38;5;130;01m\\n\u001B[39;00m\u001B[33mResponse: \u001B[39m\u001B[38;5;132;01m{\u001B[39;00mresponse\u001B[38;5;132;01m}\u001B[39;00m\u001B[33m\"\u001B[39m)\n", - "\u001B[36mFile \u001B[39m\u001B[32m~/Documents/Personal/research/FAIM/faim-client/faim_sdk/client.py:296\u001B[39m, in \u001B[36mForecastClient.forecast\u001B[39m\u001B[34m(self, model, request)\u001B[39m\n\u001B[32m 289\u001B[39m \u001B[38;5;28;01mraise\u001B[39;00m ServiceUnavailableError(\n\u001B[32m 290\u001B[39m message=message,\n\u001B[32m 291\u001B[39m status_code=response.status_code,\n\u001B[32m 292\u001B[39m error_response=error_response,\n\u001B[32m 293\u001B[39m )\n\u001B[32m 294\u001B[39m \u001B[38;5;28;01melse\u001B[39;00m:\n\u001B[32m 295\u001B[39m \u001B[38;5;66;03m# Fallback for unmapped status codes\u001B[39;00m\n\u001B[32m--> \u001B[39m\u001B[32m296\u001B[39m \u001B[38;5;28;01mraise\u001B[39;00m APIError(\n\u001B[32m 297\u001B[39m message=message,\n\u001B[32m 298\u001B[39m status_code=response.status_code,\n\u001B[32m 299\u001B[39m error_response=error_response,\n\u001B[32m 300\u001B[39m )\n\u001B[32m 302\u001B[39m \u001B[38;5;66;03m# Deserialize successful response\u001B[39;00m\n\u001B[32m 303\u001B[39m \u001B[38;5;28;01mtry\u001B[39;00m:\n", - "\u001B[31mAPIError\u001B[39m: Request failed with status 502 | status=502" - ] - } - ], - "execution_count": 65 + "source": "try:\n # Make forecast request\n response = client.forecast(request)\n\n print(\"✓ Forecast successful!\")\n print(f\"\\nResponse: {response}\")\n print(\"\\nResponse details:\")\n print(f\" - Point predictions shape: {response.point.shape}\")\n print(f\" - Metadata: {response.metadata}\")\n \nexcept Exception as e:\n print(f\"✗ Forecast failed: {e}\")\n print(f\" Error type: {type(e).__name__}\")", + "outputs": [], + "execution_count": null }, { "metadata": { @@ -775,4 +713,4 @@ }, "nbformat": 4, "nbformat_minor": 4 -} +} \ No newline at end of file diff --git a/examples/model_comparison_example.ipynb b/examples/model_comparison_example.ipynb index c1ea4c5..0ecb0b0 100644 --- a/examples/model_comparison_example.ipynb +++ b/examples/model_comparison_example.ipynb @@ -29,40 +29,9 @@ "start_time": "2025-11-03T21:34:43.895562Z" } }, - "source": [ - "import os\n", - "import sys\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "import pandas as pd\n", - "\n", - "# Import FAIM SDK\n", - "from faim_sdk import (\n", - " ForecastClient,\n", - " FlowStateForecastRequest,\n", - " Chronos2ForecastRequest,\n", - " TiRexForecastRequest,\n", - ")\n", - "from faim_client.models import ModelName\n", - "\n", - "# Import evaluation tools\n", - "from faim_sdk.eval import mse, mase, crps_from_quantiles, plot_forecast\n", - "\n", - "# Import data generation utilities\n", - "from generate_data import generate_linear_trend_series, generate_correlated_multi_series\n", - "\n", - "print(\"✓ All imports successful\")" - ], - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "✓ All imports successful\n" - ] - } - ], - "execution_count": 1 + "source": "import os\nimport sys\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport pandas as pd\n\n# Import FAIM SDK\nfrom faim_sdk import (\n ForecastClient,\n FlowStateForecastRequest,\n Chronos2ForecastRequest,\n TiRexForecastRequest,\n)\n\n# Import evaluation tools\nfrom faim_sdk.eval import mse, mase, crps_from_quantiles, plot_forecast\n\n# Import data generation utilities\nfrom generate_data import generate_linear_trend_series, generate_correlated_multi_series\n\nprint(\"✓ All imports successful\")", + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -305,96 +274,9 @@ "start_time": "2025-11-03T21:38:49.145028Z" } }, - "source": [ - "print(\"=\" * 60)\n", - "print(\"FLOWSTATE MODEL\")\n", - "print(\"=\" * 60)\n", - "\n", - "# Linear trend dataset\n", - "print(\"\\n1. Linear Trend Dataset (single feature)\")\n", - "request_linear_fs = FlowStateForecastRequest(\n", - " x=linear_train,\n", - " horizon=HORIZON,\n", - " scale_factor=1.0,\n", - " prediction_type=\"mean\",\n", - " output_type=\"point\"\n", - ")\n", - "\n", - "response_linear_fs = client.forecast(ModelName.FLOWSTATE, request_linear_fs)\n", - "print(f\" Response shape: {response_linear_fs.point.shape}\")\n", - "print(f\" Metadata: {response_linear_fs.metadata}\")\n", - "\n", - "# Evaluate\n", - "mse_linear_fs = mse(linear_test, response_linear_fs.point)\n", - "mase_linear_fs = mase(linear_test, response_linear_fs.point, linear_train)\n", - "print(f\" MSE: {mse_linear_fs:.4f}\")\n", - "print(f\" MASE: {mase_linear_fs:.4f}\")\n", - "\n", - "# Multi-series dataset\n", - "print(\"\\n2. Correlated Multi-Series Dataset (2 features)\")\n", - "request_multi_fs = FlowStateForecastRequest(\n", - " x=multi_train,\n", - " horizon=HORIZON,\n", - " scale_factor=1.0,\n", - " prediction_type=\"mean\",\n", - " output_type=\"point\"\n", - ")\n", - "\n", - "response_multi_fs = client.forecast(ModelName.FLOWSTATE, request_multi_fs)\n", - "print(f\" Response shape: {response_multi_fs.point.shape}\")\n", - "print(f\" Metadata: {response_multi_fs.metadata}\")\n", - "\n", - "# Evaluate\n", - "mse_multi_fs = mse(multi_test, response_multi_fs.point)\n", - "mase_multi_fs = mase(multi_test, response_multi_fs.point, multi_train)\n", - "print(f\" MSE: {mse_multi_fs:.4f}\")\n", - "print(f\" MASE: {mase_multi_fs:.4f}\")\n", - "\n", - "print(\"\\n✓ FlowState forecasts complete\")" - ], - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "============================================================\n", - "FLOWSTATE MODEL\n", - "============================================================\n", - "\n", - "1. Linear Trend Dataset (single feature)\n" - ] - }, - { - "ename": "KeyboardInterrupt", - "evalue": "", - "output_type": "error", - "traceback": [ - "\u001B[31m---------------------------------------------------------------------------\u001B[39m", - "\u001B[31mKeyboardInterrupt\u001B[39m Traceback (most recent call last)", - "\u001B[36mCell\u001B[39m\u001B[36m \u001B[39m\u001B[32mIn[14]\u001B[39m\u001B[32m, line 15\u001B[39m\n\u001B[32m 6\u001B[39m \u001B[38;5;28mprint\u001B[39m(\u001B[33m\"\u001B[39m\u001B[38;5;130;01m\\n\u001B[39;00m\u001B[33m1. Linear Trend Dataset (single feature)\u001B[39m\u001B[33m\"\u001B[39m)\n\u001B[32m 7\u001B[39m request_linear_fs = FlowStateForecastRequest(\n\u001B[32m 8\u001B[39m x=linear_train,\n\u001B[32m 9\u001B[39m horizon=HORIZON,\n\u001B[32m (...)\u001B[39m\u001B[32m 12\u001B[39m output_type=\u001B[33m\"\u001B[39m\u001B[33mpoint\u001B[39m\u001B[33m\"\u001B[39m\n\u001B[32m 13\u001B[39m )\n\u001B[32m---> \u001B[39m\u001B[32m15\u001B[39m response_linear_fs = \u001B[43mclient\u001B[49m\u001B[43m.\u001B[49m\u001B[43mforecast\u001B[49m\u001B[43m(\u001B[49m\u001B[43mModelName\u001B[49m\u001B[43m.\u001B[49m\u001B[43mFLOWSTATE\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mrequest_linear_fs\u001B[49m\u001B[43m)\u001B[49m\n\u001B[32m 16\u001B[39m \u001B[38;5;28mprint\u001B[39m(\u001B[33mf\u001B[39m\u001B[33m\"\u001B[39m\u001B[33m Response shape: \u001B[39m\u001B[38;5;132;01m{\u001B[39;00mresponse_linear_fs.point.shape\u001B[38;5;132;01m}\u001B[39;00m\u001B[33m\"\u001B[39m)\n\u001B[32m 17\u001B[39m \u001B[38;5;28mprint\u001B[39m(\u001B[33mf\u001B[39m\u001B[33m\"\u001B[39m\u001B[33m Metadata: \u001B[39m\u001B[38;5;132;01m{\u001B[39;00mresponse_linear_fs.metadata\u001B[38;5;132;01m}\u001B[39;00m\u001B[33m\"\u001B[39m)\n", - "\u001B[36mFile \u001B[39m\u001B[32m~/Documents/Personal/research/FAIM/faim-client/faim_sdk/client.py:189\u001B[39m, in \u001B[36mForecastClient.forecast\u001B[39m\u001B[34m(self, model, request)\u001B[39m\n\u001B[32m 187\u001B[39m \u001B[38;5;66;03m# Make API call\u001B[39;00m\n\u001B[32m 188\u001B[39m \u001B[38;5;28;01mtry\u001B[39;00m:\n\u001B[32m--> \u001B[39m\u001B[32m189\u001B[39m response = \u001B[43mforecast_v1_ts_forecast_model_name_model_version_post\u001B[49m\u001B[43m.\u001B[49m\u001B[43msync_detailed\u001B[49m\u001B[43m(\u001B[49m\n\u001B[32m 190\u001B[39m \u001B[43m \u001B[49m\u001B[43mmodel_name\u001B[49m\u001B[43m=\u001B[49m\u001B[43mmodel\u001B[49m\u001B[43m,\u001B[49m\n\u001B[32m 191\u001B[39m \u001B[43m \u001B[49m\u001B[43mmodel_version\u001B[49m\u001B[43m=\u001B[49m\u001B[43mrequest\u001B[49m\u001B[43m.\u001B[49m\u001B[43mmodel_version\u001B[49m\u001B[43m,\u001B[49m\n\u001B[32m 192\u001B[39m \u001B[43m \u001B[49m\u001B[43mclient\u001B[49m\u001B[43m=\u001B[49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[43m.\u001B[49m\u001B[43m_client\u001B[49m\u001B[43m,\u001B[49m\n\u001B[32m 193\u001B[39m \u001B[43m \u001B[49m\u001B[43mbody\u001B[49m\u001B[43m=\u001B[49m\u001B[43mpayload_file\u001B[49m\u001B[43m,\u001B[49m\n\u001B[32m 194\u001B[39m \u001B[43m \u001B[49m\u001B[43m)\u001B[49m\n\u001B[32m 196\u001B[39m \u001B[38;5;28;01mexcept\u001B[39;00m \u001B[38;5;167;01mKeyError\u001B[39;00m \u001B[38;5;28;01mas\u001B[39;00m e:\n\u001B[32m 197\u001B[39m \u001B[38;5;66;03m# Backend returned error response with unexpected format\u001B[39;00m\n\u001B[32m 198\u001B[39m logger.error(\u001B[33mf\u001B[39m\u001B[33m\"\u001B[39m\u001B[33mFailed to parse error response: \u001B[39m\u001B[38;5;132;01m{\u001B[39;00me\u001B[38;5;132;01m}\u001B[39;00m\u001B[33m\"\u001B[39m)\n", - "\u001B[36mFile \u001B[39m\u001B[32m~/Documents/Personal/research/FAIM/faim-client/faim_client/api/forecast/forecast_v1_ts_forecast_model_name_model_version_post.py:246\u001B[39m, in \u001B[36msync_detailed\u001B[39m\u001B[34m(model_name, model_version, client, body)\u001B[39m\n\u001B[32m 107\u001B[39m \u001B[38;5;250m\u001B[39m\u001B[33mr\u001B[39m\u001B[33;03m\"\"\"Generate time series forecast\u001B[39;00m\n\u001B[32m 108\u001B[39m \n\u001B[32m 109\u001B[39m \u001B[33;03m Generate time series forecasts using the specified Triton model.\u001B[39;00m\n\u001B[32m (...)\u001B[39m\u001B[32m 237\u001B[39m \u001B[33;03m Response[Union[ErrorResponse, File]]\u001B[39;00m\n\u001B[32m 238\u001B[39m \u001B[33;03m\"\"\"\u001B[39;00m\n\u001B[32m 240\u001B[39m kwargs = _get_kwargs(\n\u001B[32m 241\u001B[39m model_name=model_name,\n\u001B[32m 242\u001B[39m model_version=model_version,\n\u001B[32m 243\u001B[39m body=body,\n\u001B[32m 244\u001B[39m )\n\u001B[32m--> \u001B[39m\u001B[32m246\u001B[39m response = \u001B[43mclient\u001B[49m\u001B[43m.\u001B[49m\u001B[43mget_httpx_client\u001B[49m\u001B[43m(\u001B[49m\u001B[43m)\u001B[49m\u001B[43m.\u001B[49m\u001B[43mrequest\u001B[49m\u001B[43m(\u001B[49m\n\u001B[32m 247\u001B[39m \u001B[43m \u001B[49m\u001B[43m*\u001B[49m\u001B[43m*\u001B[49m\u001B[43mkwargs\u001B[49m\u001B[43m,\u001B[49m\n\u001B[32m 248\u001B[39m \u001B[43m\u001B[49m\u001B[43m)\u001B[49m\n\u001B[32m 250\u001B[39m \u001B[38;5;28;01mreturn\u001B[39;00m _build_response(client=client, response=response)\n", - "\u001B[36mFile \u001B[39m\u001B[32m~/Documents/Personal/research/FAIM/faim-client/.venv/lib/python3.12/site-packages/httpx/_client.py:825\u001B[39m, in \u001B[36mClient.request\u001B[39m\u001B[34m(self, method, url, content, data, files, json, params, headers, cookies, auth, follow_redirects, timeout, extensions)\u001B[39m\n\u001B[32m 810\u001B[39m warnings.warn(message, \u001B[38;5;167;01mDeprecationWarning\u001B[39;00m, stacklevel=\u001B[32m2\u001B[39m)\n\u001B[32m 812\u001B[39m request = \u001B[38;5;28mself\u001B[39m.build_request(\n\u001B[32m 813\u001B[39m method=method,\n\u001B[32m 814\u001B[39m url=url,\n\u001B[32m (...)\u001B[39m\u001B[32m 823\u001B[39m extensions=extensions,\n\u001B[32m 824\u001B[39m )\n\u001B[32m--> \u001B[39m\u001B[32m825\u001B[39m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[38;5;28;43mself\u001B[39;49m\u001B[43m.\u001B[49m\u001B[43msend\u001B[49m\u001B[43m(\u001B[49m\u001B[43mrequest\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mauth\u001B[49m\u001B[43m=\u001B[49m\u001B[43mauth\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mfollow_redirects\u001B[49m\u001B[43m=\u001B[49m\u001B[43mfollow_redirects\u001B[49m\u001B[43m)\u001B[49m\n", - "\u001B[36mFile \u001B[39m\u001B[32m~/Documents/Personal/research/FAIM/faim-client/.venv/lib/python3.12/site-packages/httpx/_client.py:914\u001B[39m, in \u001B[36mClient.send\u001B[39m\u001B[34m(self, request, stream, auth, follow_redirects)\u001B[39m\n\u001B[32m 910\u001B[39m \u001B[38;5;28mself\u001B[39m._set_timeout(request)\n\u001B[32m 912\u001B[39m auth = \u001B[38;5;28mself\u001B[39m._build_request_auth(request, auth)\n\u001B[32m--> \u001B[39m\u001B[32m914\u001B[39m response = \u001B[38;5;28;43mself\u001B[39;49m\u001B[43m.\u001B[49m\u001B[43m_send_handling_auth\u001B[49m\u001B[43m(\u001B[49m\n\u001B[32m 915\u001B[39m \u001B[43m \u001B[49m\u001B[43mrequest\u001B[49m\u001B[43m,\u001B[49m\n\u001B[32m 916\u001B[39m \u001B[43m \u001B[49m\u001B[43mauth\u001B[49m\u001B[43m=\u001B[49m\u001B[43mauth\u001B[49m\u001B[43m,\u001B[49m\n\u001B[32m 917\u001B[39m \u001B[43m \u001B[49m\u001B[43mfollow_redirects\u001B[49m\u001B[43m=\u001B[49m\u001B[43mfollow_redirects\u001B[49m\u001B[43m,\u001B[49m\n\u001B[32m 918\u001B[39m \u001B[43m \u001B[49m\u001B[43mhistory\u001B[49m\u001B[43m=\u001B[49m\u001B[43m[\u001B[49m\u001B[43m]\u001B[49m\u001B[43m,\u001B[49m\n\u001B[32m 919\u001B[39m \u001B[43m\u001B[49m\u001B[43m)\u001B[49m\n\u001B[32m 920\u001B[39m \u001B[38;5;28;01mtry\u001B[39;00m:\n\u001B[32m 921\u001B[39m \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;129;01mnot\u001B[39;00m stream:\n", - "\u001B[36mFile \u001B[39m\u001B[32m~/Documents/Personal/research/FAIM/faim-client/.venv/lib/python3.12/site-packages/httpx/_client.py:942\u001B[39m, in \u001B[36mClient._send_handling_auth\u001B[39m\u001B[34m(self, request, auth, follow_redirects, history)\u001B[39m\n\u001B[32m 939\u001B[39m request = \u001B[38;5;28mnext\u001B[39m(auth_flow)\n\u001B[32m 941\u001B[39m \u001B[38;5;28;01mwhile\u001B[39;00m \u001B[38;5;28;01mTrue\u001B[39;00m:\n\u001B[32m--> \u001B[39m\u001B[32m942\u001B[39m response = \u001B[38;5;28;43mself\u001B[39;49m\u001B[43m.\u001B[49m\u001B[43m_send_handling_redirects\u001B[49m\u001B[43m(\u001B[49m\n\u001B[32m 943\u001B[39m \u001B[43m \u001B[49m\u001B[43mrequest\u001B[49m\u001B[43m,\u001B[49m\n\u001B[32m 944\u001B[39m \u001B[43m \u001B[49m\u001B[43mfollow_redirects\u001B[49m\u001B[43m=\u001B[49m\u001B[43mfollow_redirects\u001B[49m\u001B[43m,\u001B[49m\n\u001B[32m 945\u001B[39m \u001B[43m \u001B[49m\u001B[43mhistory\u001B[49m\u001B[43m=\u001B[49m\u001B[43mhistory\u001B[49m\u001B[43m,\u001B[49m\n\u001B[32m 946\u001B[39m \u001B[43m \u001B[49m\u001B[43m)\u001B[49m\n\u001B[32m 947\u001B[39m \u001B[38;5;28;01mtry\u001B[39;00m:\n\u001B[32m 948\u001B[39m \u001B[38;5;28;01mtry\u001B[39;00m:\n", - "\u001B[36mFile \u001B[39m\u001B[32m~/Documents/Personal/research/FAIM/faim-client/.venv/lib/python3.12/site-packages/httpx/_client.py:979\u001B[39m, in \u001B[36mClient._send_handling_redirects\u001B[39m\u001B[34m(self, request, follow_redirects, history)\u001B[39m\n\u001B[32m 976\u001B[39m \u001B[38;5;28;01mfor\u001B[39;00m hook \u001B[38;5;129;01min\u001B[39;00m \u001B[38;5;28mself\u001B[39m._event_hooks[\u001B[33m\"\u001B[39m\u001B[33mrequest\u001B[39m\u001B[33m\"\u001B[39m]:\n\u001B[32m 977\u001B[39m hook(request)\n\u001B[32m--> \u001B[39m\u001B[32m979\u001B[39m response = \u001B[38;5;28;43mself\u001B[39;49m\u001B[43m.\u001B[49m\u001B[43m_send_single_request\u001B[49m\u001B[43m(\u001B[49m\u001B[43mrequest\u001B[49m\u001B[43m)\u001B[49m\n\u001B[32m 980\u001B[39m \u001B[38;5;28;01mtry\u001B[39;00m:\n\u001B[32m 981\u001B[39m \u001B[38;5;28;01mfor\u001B[39;00m hook \u001B[38;5;129;01min\u001B[39;00m \u001B[38;5;28mself\u001B[39m._event_hooks[\u001B[33m\"\u001B[39m\u001B[33mresponse\u001B[39m\u001B[33m\"\u001B[39m]:\n", - "\u001B[36mFile \u001B[39m\u001B[32m~/Documents/Personal/research/FAIM/faim-client/.venv/lib/python3.12/site-packages/httpx/_client.py:1014\u001B[39m, in \u001B[36mClient._send_single_request\u001B[39m\u001B[34m(self, request)\u001B[39m\n\u001B[32m 1009\u001B[39m \u001B[38;5;28;01mraise\u001B[39;00m \u001B[38;5;167;01mRuntimeError\u001B[39;00m(\n\u001B[32m 1010\u001B[39m \u001B[33m\"\u001B[39m\u001B[33mAttempted to send an async request with a sync Client instance.\u001B[39m\u001B[33m\"\u001B[39m\n\u001B[32m 1011\u001B[39m )\n\u001B[32m 1013\u001B[39m \u001B[38;5;28;01mwith\u001B[39;00m request_context(request=request):\n\u001B[32m-> \u001B[39m\u001B[32m1014\u001B[39m response = \u001B[43mtransport\u001B[49m\u001B[43m.\u001B[49m\u001B[43mhandle_request\u001B[49m\u001B[43m(\u001B[49m\u001B[43mrequest\u001B[49m\u001B[43m)\u001B[49m\n\u001B[32m 1016\u001B[39m \u001B[38;5;28;01massert\u001B[39;00m \u001B[38;5;28misinstance\u001B[39m(response.stream, SyncByteStream)\n\u001B[32m 1018\u001B[39m response.request = request\n", - "\u001B[36mFile \u001B[39m\u001B[32m~/Documents/Personal/research/FAIM/faim-client/.venv/lib/python3.12/site-packages/httpx/_transports/default.py:250\u001B[39m, in \u001B[36mHTTPTransport.handle_request\u001B[39m\u001B[34m(self, request)\u001B[39m\n\u001B[32m 237\u001B[39m req = httpcore.Request(\n\u001B[32m 238\u001B[39m method=request.method,\n\u001B[32m 239\u001B[39m url=httpcore.URL(\n\u001B[32m (...)\u001B[39m\u001B[32m 247\u001B[39m extensions=request.extensions,\n\u001B[32m 248\u001B[39m )\n\u001B[32m 249\u001B[39m \u001B[38;5;28;01mwith\u001B[39;00m map_httpcore_exceptions():\n\u001B[32m--> \u001B[39m\u001B[32m250\u001B[39m resp = \u001B[38;5;28;43mself\u001B[39;49m\u001B[43m.\u001B[49m\u001B[43m_pool\u001B[49m\u001B[43m.\u001B[49m\u001B[43mhandle_request\u001B[49m\u001B[43m(\u001B[49m\u001B[43mreq\u001B[49m\u001B[43m)\u001B[49m\n\u001B[32m 252\u001B[39m \u001B[38;5;28;01massert\u001B[39;00m \u001B[38;5;28misinstance\u001B[39m(resp.stream, typing.Iterable)\n\u001B[32m 254\u001B[39m \u001B[38;5;28;01mreturn\u001B[39;00m Response(\n\u001B[32m 255\u001B[39m status_code=resp.status,\n\u001B[32m 256\u001B[39m headers=resp.headers,\n\u001B[32m 257\u001B[39m stream=ResponseStream(resp.stream),\n\u001B[32m 258\u001B[39m extensions=resp.extensions,\n\u001B[32m 259\u001B[39m )\n", - "\u001B[36mFile \u001B[39m\u001B[32m~/Documents/Personal/research/FAIM/faim-client/.venv/lib/python3.12/site-packages/httpcore/_sync/connection_pool.py:256\u001B[39m, in \u001B[36mConnectionPool.handle_request\u001B[39m\u001B[34m(self, request)\u001B[39m\n\u001B[32m 253\u001B[39m closing = \u001B[38;5;28mself\u001B[39m._assign_requests_to_connections()\n\u001B[32m 255\u001B[39m \u001B[38;5;28mself\u001B[39m._close_connections(closing)\n\u001B[32m--> \u001B[39m\u001B[32m256\u001B[39m \u001B[38;5;28;01mraise\u001B[39;00m exc \u001B[38;5;28;01mfrom\u001B[39;00m\u001B[38;5;250m \u001B[39m\u001B[38;5;28;01mNone\u001B[39;00m\n\u001B[32m 258\u001B[39m \u001B[38;5;66;03m# Return the response. Note that in this case we still have to manage\u001B[39;00m\n\u001B[32m 259\u001B[39m \u001B[38;5;66;03m# the point at which the response is closed.\u001B[39;00m\n\u001B[32m 260\u001B[39m \u001B[38;5;28;01massert\u001B[39;00m \u001B[38;5;28misinstance\u001B[39m(response.stream, typing.Iterable)\n", - "\u001B[36mFile \u001B[39m\u001B[32m~/Documents/Personal/research/FAIM/faim-client/.venv/lib/python3.12/site-packages/httpcore/_sync/connection_pool.py:236\u001B[39m, in \u001B[36mConnectionPool.handle_request\u001B[39m\u001B[34m(self, request)\u001B[39m\n\u001B[32m 232\u001B[39m connection = pool_request.wait_for_connection(timeout=timeout)\n\u001B[32m 234\u001B[39m \u001B[38;5;28;01mtry\u001B[39;00m:\n\u001B[32m 235\u001B[39m \u001B[38;5;66;03m# Send the request on the assigned connection.\u001B[39;00m\n\u001B[32m--> \u001B[39m\u001B[32m236\u001B[39m response = \u001B[43mconnection\u001B[49m\u001B[43m.\u001B[49m\u001B[43mhandle_request\u001B[49m\u001B[43m(\u001B[49m\n\u001B[32m 237\u001B[39m \u001B[43m \u001B[49m\u001B[43mpool_request\u001B[49m\u001B[43m.\u001B[49m\u001B[43mrequest\u001B[49m\n\u001B[32m 238\u001B[39m \u001B[43m \u001B[49m\u001B[43m)\u001B[49m\n\u001B[32m 239\u001B[39m \u001B[38;5;28;01mexcept\u001B[39;00m ConnectionNotAvailable:\n\u001B[32m 240\u001B[39m \u001B[38;5;66;03m# In some cases a connection may initially be available to\u001B[39;00m\n\u001B[32m 241\u001B[39m \u001B[38;5;66;03m# handle a request, but then become unavailable.\u001B[39;00m\n\u001B[32m 242\u001B[39m \u001B[38;5;66;03m#\u001B[39;00m\n\u001B[32m 243\u001B[39m \u001B[38;5;66;03m# In this case we clear the connection and try again.\u001B[39;00m\n\u001B[32m 244\u001B[39m pool_request.clear_connection()\n", - "\u001B[36mFile \u001B[39m\u001B[32m~/Documents/Personal/research/FAIM/faim-client/.venv/lib/python3.12/site-packages/httpcore/_sync/connection.py:103\u001B[39m, in \u001B[36mHTTPConnection.handle_request\u001B[39m\u001B[34m(self, request)\u001B[39m\n\u001B[32m 100\u001B[39m \u001B[38;5;28mself\u001B[39m._connect_failed = \u001B[38;5;28;01mTrue\u001B[39;00m\n\u001B[32m 101\u001B[39m \u001B[38;5;28;01mraise\u001B[39;00m exc\n\u001B[32m--> \u001B[39m\u001B[32m103\u001B[39m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[38;5;28;43mself\u001B[39;49m\u001B[43m.\u001B[49m\u001B[43m_connection\u001B[49m\u001B[43m.\u001B[49m\u001B[43mhandle_request\u001B[49m\u001B[43m(\u001B[49m\u001B[43mrequest\u001B[49m\u001B[43m)\u001B[49m\n", - "\u001B[36mFile \u001B[39m\u001B[32m~/Documents/Personal/research/FAIM/faim-client/.venv/lib/python3.12/site-packages/httpcore/_sync/http11.py:136\u001B[39m, in \u001B[36mHTTP11Connection.handle_request\u001B[39m\u001B[34m(self, request)\u001B[39m\n\u001B[32m 134\u001B[39m \u001B[38;5;28;01mwith\u001B[39;00m Trace(\u001B[33m\"\u001B[39m\u001B[33mresponse_closed\u001B[39m\u001B[33m\"\u001B[39m, logger, request) \u001B[38;5;28;01mas\u001B[39;00m trace:\n\u001B[32m 135\u001B[39m \u001B[38;5;28mself\u001B[39m._response_closed()\n\u001B[32m--> \u001B[39m\u001B[32m136\u001B[39m \u001B[38;5;28;01mraise\u001B[39;00m exc\n", - "\u001B[36mFile \u001B[39m\u001B[32m~/Documents/Personal/research/FAIM/faim-client/.venv/lib/python3.12/site-packages/httpcore/_sync/http11.py:106\u001B[39m, in \u001B[36mHTTP11Connection.handle_request\u001B[39m\u001B[34m(self, request)\u001B[39m\n\u001B[32m 95\u001B[39m \u001B[38;5;28;01mpass\u001B[39;00m\n\u001B[32m 97\u001B[39m \u001B[38;5;28;01mwith\u001B[39;00m Trace(\n\u001B[32m 98\u001B[39m \u001B[33m\"\u001B[39m\u001B[33mreceive_response_headers\u001B[39m\u001B[33m\"\u001B[39m, logger, request, kwargs\n\u001B[32m 99\u001B[39m ) \u001B[38;5;28;01mas\u001B[39;00m trace:\n\u001B[32m 100\u001B[39m (\n\u001B[32m 101\u001B[39m http_version,\n\u001B[32m 102\u001B[39m status,\n\u001B[32m 103\u001B[39m reason_phrase,\n\u001B[32m 104\u001B[39m headers,\n\u001B[32m 105\u001B[39m trailing_data,\n\u001B[32m--> \u001B[39m\u001B[32m106\u001B[39m ) = \u001B[38;5;28;43mself\u001B[39;49m\u001B[43m.\u001B[49m\u001B[43m_receive_response_headers\u001B[49m\u001B[43m(\u001B[49m\u001B[43m*\u001B[49m\u001B[43m*\u001B[49m\u001B[43mkwargs\u001B[49m\u001B[43m)\u001B[49m\n\u001B[32m 107\u001B[39m trace.return_value = (\n\u001B[32m 108\u001B[39m http_version,\n\u001B[32m 109\u001B[39m status,\n\u001B[32m 110\u001B[39m reason_phrase,\n\u001B[32m 111\u001B[39m headers,\n\u001B[32m 112\u001B[39m )\n\u001B[32m 114\u001B[39m network_stream = \u001B[38;5;28mself\u001B[39m._network_stream\n", - "\u001B[36mFile \u001B[39m\u001B[32m~/Documents/Personal/research/FAIM/faim-client/.venv/lib/python3.12/site-packages/httpcore/_sync/http11.py:177\u001B[39m, in \u001B[36mHTTP11Connection._receive_response_headers\u001B[39m\u001B[34m(self, request)\u001B[39m\n\u001B[32m 174\u001B[39m timeout = timeouts.get(\u001B[33m\"\u001B[39m\u001B[33mread\u001B[39m\u001B[33m\"\u001B[39m, \u001B[38;5;28;01mNone\u001B[39;00m)\n\u001B[32m 176\u001B[39m \u001B[38;5;28;01mwhile\u001B[39;00m \u001B[38;5;28;01mTrue\u001B[39;00m:\n\u001B[32m--> \u001B[39m\u001B[32m177\u001B[39m event = \u001B[38;5;28;43mself\u001B[39;49m\u001B[43m.\u001B[49m\u001B[43m_receive_event\u001B[49m\u001B[43m(\u001B[49m\u001B[43mtimeout\u001B[49m\u001B[43m=\u001B[49m\u001B[43mtimeout\u001B[49m\u001B[43m)\u001B[49m\n\u001B[32m 178\u001B[39m \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;28misinstance\u001B[39m(event, h11.Response):\n\u001B[32m 179\u001B[39m \u001B[38;5;28;01mbreak\u001B[39;00m\n", - "\u001B[36mFile \u001B[39m\u001B[32m~/Documents/Personal/research/FAIM/faim-client/.venv/lib/python3.12/site-packages/httpcore/_sync/http11.py:217\u001B[39m, in \u001B[36mHTTP11Connection._receive_event\u001B[39m\u001B[34m(self, timeout)\u001B[39m\n\u001B[32m 214\u001B[39m event = \u001B[38;5;28mself\u001B[39m._h11_state.next_event()\n\u001B[32m 216\u001B[39m \u001B[38;5;28;01mif\u001B[39;00m event \u001B[38;5;129;01mis\u001B[39;00m h11.NEED_DATA:\n\u001B[32m--> \u001B[39m\u001B[32m217\u001B[39m data = \u001B[38;5;28;43mself\u001B[39;49m\u001B[43m.\u001B[49m\u001B[43m_network_stream\u001B[49m\u001B[43m.\u001B[49m\u001B[43mread\u001B[49m\u001B[43m(\u001B[49m\n\u001B[32m 218\u001B[39m \u001B[43m \u001B[49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[43m.\u001B[49m\u001B[43mREAD_NUM_BYTES\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mtimeout\u001B[49m\u001B[43m=\u001B[49m\u001B[43mtimeout\u001B[49m\n\u001B[32m 219\u001B[39m \u001B[43m \u001B[49m\u001B[43m)\u001B[49m\n\u001B[32m 221\u001B[39m \u001B[38;5;66;03m# If we feed this case through h11 we'll raise an exception like:\u001B[39;00m\n\u001B[32m 222\u001B[39m \u001B[38;5;66;03m#\u001B[39;00m\n\u001B[32m 223\u001B[39m \u001B[38;5;66;03m# httpcore.RemoteProtocolError: can't handle event type\u001B[39;00m\n\u001B[32m (...)\u001B[39m\u001B[32m 227\u001B[39m \u001B[38;5;66;03m# perspective. Instead we handle this case distinctly and treat\u001B[39;00m\n\u001B[32m 228\u001B[39m \u001B[38;5;66;03m# it as a ConnectError.\u001B[39;00m\n\u001B[32m 229\u001B[39m \u001B[38;5;28;01mif\u001B[39;00m data == \u001B[33mb\u001B[39m\u001B[33m\"\u001B[39m\u001B[33m\"\u001B[39m \u001B[38;5;129;01mand\u001B[39;00m \u001B[38;5;28mself\u001B[39m._h11_state.their_state == h11.SEND_RESPONSE:\n", - "\u001B[36mFile \u001B[39m\u001B[32m~/Documents/Personal/research/FAIM/faim-client/.venv/lib/python3.12/site-packages/httpcore/_backends/sync.py:128\u001B[39m, in \u001B[36mSyncStream.read\u001B[39m\u001B[34m(self, max_bytes, timeout)\u001B[39m\n\u001B[32m 126\u001B[39m \u001B[38;5;28;01mwith\u001B[39;00m map_exceptions(exc_map):\n\u001B[32m 127\u001B[39m \u001B[38;5;28mself\u001B[39m._sock.settimeout(timeout)\n\u001B[32m--> \u001B[39m\u001B[32m128\u001B[39m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[38;5;28;43mself\u001B[39;49m\u001B[43m.\u001B[49m\u001B[43m_sock\u001B[49m\u001B[43m.\u001B[49m\u001B[43mrecv\u001B[49m\u001B[43m(\u001B[49m\u001B[43mmax_bytes\u001B[49m\u001B[43m)\u001B[49m\n", - "\u001B[36mFile \u001B[39m\u001B[32m~/.pyenv/versions/3.12.3/lib/python3.12/ssl.py:1233\u001B[39m, in \u001B[36mSSLSocket.recv\u001B[39m\u001B[34m(self, buflen, flags)\u001B[39m\n\u001B[32m 1229\u001B[39m \u001B[38;5;28;01mif\u001B[39;00m flags != \u001B[32m0\u001B[39m:\n\u001B[32m 1230\u001B[39m \u001B[38;5;28;01mraise\u001B[39;00m \u001B[38;5;167;01mValueError\u001B[39;00m(\n\u001B[32m 1231\u001B[39m \u001B[33m\"\u001B[39m\u001B[33mnon-zero flags not allowed in calls to recv() on \u001B[39m\u001B[38;5;132;01m%s\u001B[39;00m\u001B[33m\"\u001B[39m %\n\u001B[32m 1232\u001B[39m \u001B[38;5;28mself\u001B[39m.\u001B[34m__class__\u001B[39m)\n\u001B[32m-> \u001B[39m\u001B[32m1233\u001B[39m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[38;5;28;43mself\u001B[39;49m\u001B[43m.\u001B[49m\u001B[43mread\u001B[49m\u001B[43m(\u001B[49m\u001B[43mbuflen\u001B[49m\u001B[43m)\u001B[49m\n\u001B[32m 1234\u001B[39m \u001B[38;5;28;01melse\u001B[39;00m:\n\u001B[32m 1235\u001B[39m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[38;5;28msuper\u001B[39m().recv(buflen, flags)\n", - "\u001B[36mFile \u001B[39m\u001B[32m~/.pyenv/versions/3.12.3/lib/python3.12/ssl.py:1106\u001B[39m, in \u001B[36mSSLSocket.read\u001B[39m\u001B[34m(self, len, buffer)\u001B[39m\n\u001B[32m 1104\u001B[39m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[38;5;28mself\u001B[39m._sslobj.read(\u001B[38;5;28mlen\u001B[39m, buffer)\n\u001B[32m 1105\u001B[39m \u001B[38;5;28;01melse\u001B[39;00m:\n\u001B[32m-> \u001B[39m\u001B[32m1106\u001B[39m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[38;5;28;43mself\u001B[39;49m\u001B[43m.\u001B[49m\u001B[43m_sslobj\u001B[49m\u001B[43m.\u001B[49m\u001B[43mread\u001B[49m\u001B[43m(\u001B[49m\u001B[38;5;28;43mlen\u001B[39;49m\u001B[43m)\u001B[49m\n\u001B[32m 1107\u001B[39m \u001B[38;5;28;01mexcept\u001B[39;00m SSLError \u001B[38;5;28;01mas\u001B[39;00m x:\n\u001B[32m 1108\u001B[39m \u001B[38;5;28;01mif\u001B[39;00m x.args[\u001B[32m0\u001B[39m] == SSL_ERROR_EOF \u001B[38;5;129;01mand\u001B[39;00m \u001B[38;5;28mself\u001B[39m.suppress_ragged_eofs:\n", - "\u001B[31mKeyboardInterrupt\u001B[39m: " - ] - } - ], - "execution_count": 14 + "source": "print(\"=\" * 60)\nprint(\"FLOWSTATE MODEL\")\nprint(\"=\" * 60)\n\n# Linear trend dataset\nprint(\"\\n1. Linear Trend Dataset (single feature)\")\nrequest_linear_fs = FlowStateForecastRequest(\n x=linear_train,\n horizon=HORIZON,\n scale_factor=1.0,\n prediction_type=\"mean\",\n output_type=\"point\"\n)\n\nresponse_linear_fs = client.forecast(request_linear_fs)\nprint(f\" Response shape: {response_linear_fs.point.shape}\")\nprint(f\" Metadata: {response_linear_fs.metadata}\")\n\n# Evaluate\nmse_linear_fs = mse(linear_test, response_linear_fs.point)\nmase_linear_fs = mase(linear_test, response_linear_fs.point, linear_train)\nprint(f\" MSE: {mse_linear_fs:.4f}\")\nprint(f\" MASE: {mase_linear_fs:.4f}\")\n\n# Multi-series dataset\nprint(\"\\n2. Correlated Multi-Series Dataset (2 features)\")\nrequest_multi_fs = FlowStateForecastRequest(\n x=multi_train,\n horizon=HORIZON,\n scale_factor=1.0,\n prediction_type=\"mean\",\n output_type=\"point\"\n)\n\nresponse_multi_fs = client.forecast(request_multi_fs)\nprint(f\" Response shape: {response_multi_fs.point.shape}\")\nprint(f\" Metadata: {response_multi_fs.metadata}\")\n\n# Evaluate\nmse_multi_fs = mse(multi_test, response_multi_fs.point)\nmase_multi_fs = mase(multi_test, response_multi_fs.point, multi_train)\nprint(f\" MSE: {mse_multi_fs:.4f}\")\nprint(f\" MASE: {mase_multi_fs:.4f}\")\n\nprint(\"\\n✓ FlowState forecasts complete\")", + "outputs": [], + "execution_count": null }, { "metadata": { @@ -434,98 +316,9 @@ "start_time": "2025-11-03T21:41:24.860415Z" } }, - "source": [ - "print(\"=\" * 60)\n", - "print(\"CHRONOS2 MODEL\")\n", - "print(\"=\" * 60)\n", - "\n", - "# Quantile levels for probabilistic forecasting\n", - "QUANTILES = [0.1, 0.25, 0.5, 0.75, 0.9]\n", - "\n", - "# Linear trend dataset\n", - "print(\"\\n1. Linear Trend Dataset (single feature)\")\n", - "request_linear_c2 = Chronos2ForecastRequest(\n", - " x=linear_train,\n", - " horizon=HORIZON,\n", - " output_type=\"quantiles\",\n", - " quantiles=QUANTILES\n", - ")\n", - "\n", - "response_linear_c2 = client.forecast(ModelName.CHRONOS2, request_linear_c2)\n", - "print(response_linear_c2.point)\n", - "print(f\" Response shape: {response_linear_c2.quantiles.shape}\")\n", - "print(f\" Metadata: {response_linear_c2.metadata}\")\n", - "\n", - "# Evaluate point forecast (use median)\n", - "point_linear_c2 = response_linear_c2.quantiles[:, :, 2:3] # Median (0.5 quantile), keep 3D\n", - "mse_linear_c2 = mse(linear_test, point_linear_c2)\n", - "mase_linear_c2 = mase(linear_test, point_linear_c2, linear_train)\n", - "crps_linear_c2 = crps_from_quantiles(linear_test, response_linear_c2.quantiles, QUANTILES)\n", - "print(f\" MSE (median): {mse_linear_c2:.4f}\")\n", - "print(f\" MASE (median): {mase_linear_c2:.4f}\")\n", - "print(f\" CRPS: {crps_linear_c2:.4f}\")\n", - "\n", - "# Multi-series dataset\n", - "print(\"\\n2. Correlated Multi-Series Dataset (2 features)\")\n", - "request_multi_c2 = Chronos2ForecastRequest(\n", - " x=multi_train,\n", - " horizon=HORIZON,\n", - " output_type=\"quantiles\",\n", - " quantiles=QUANTILES\n", - ")\n", - "\n", - "response_multi_c2 = client.forecast(ModelName.CHRONOS2, request_multi_c2)\n", - "print(f\" Response shape: {response_multi_c2.quantiles.shape}\")\n", - "print(f\" Metadata: {response_multi_c2.metadata}\")\n", - "\n", - "# Evaluate point forecast (use median)\n", - "point_multi_c2 = response_multi_c2.quantiles[:, :, 2:3] # Median, keep 3D\n", - "mse_multi_c2 = mse(multi_test, point_multi_c2)\n", - "mase_multi_c2 = mase(multi_test, point_multi_c2, multi_train)\n", - "# Note: CRPS expects single feature, so we'll compute per feature\n", - "crps_multi_c2_f1 = crps_from_quantiles(multi_test[:, :, 0:1], response_multi_c2.quantiles, QUANTILES)\n", - "crps_multi_c2_f2 = crps_from_quantiles(multi_test[:, :, 1:2], response_multi_c2.quantiles, QUANTILES)\n", - "print(f\" MSE (median): {mse_multi_c2:.4f}\")\n", - "print(f\" MASE (median): {mase_multi_c2:.4f}\")\n", - "print(f\" CRPS (feature 1): {crps_multi_c2_f1:.4f}\")\n", - "print(f\" CRPS (feature 2): {crps_multi_c2_f2:.4f}\")\n", - "\n", - "print(\"\\n✓ Chronos2 forecasts complete\")" - ], - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "============================================================\n", - "CHRONOS2 MODEL\n", - "============================================================\n", - "\n", - "1. Linear Trend Dataset (single feature)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Failed to parse error response: Expecting value: line 2 column 1 (char 1)\n", - "API error: status=502, no error_response\n" - ] - }, - { - "ename": "APIError", - "evalue": "Request failed with status 502 | status=502", - "output_type": "error", - "traceback": [ - "\u001B[31m---------------------------------------------------------------------------\u001B[39m", - "\u001B[31mAPIError\u001B[39m Traceback (most recent call last)", - "\u001B[36mCell\u001B[39m\u001B[36m \u001B[39m\u001B[32mIn[17]\u001B[39m\u001B[32m, line 17\u001B[39m\n\u001B[32m 9\u001B[39m \u001B[38;5;28mprint\u001B[39m(\u001B[33m\"\u001B[39m\u001B[38;5;130;01m\\n\u001B[39;00m\u001B[33m1. Linear Trend Dataset (single feature)\u001B[39m\u001B[33m\"\u001B[39m)\n\u001B[32m 10\u001B[39m request_linear_c2 = Chronos2ForecastRequest(\n\u001B[32m 11\u001B[39m x=linear_train,\n\u001B[32m 12\u001B[39m horizon=HORIZON,\n\u001B[32m 13\u001B[39m output_type=\u001B[33m\"\u001B[39m\u001B[33mquantiles\u001B[39m\u001B[33m\"\u001B[39m,\n\u001B[32m 14\u001B[39m quantiles=QUANTILES\n\u001B[32m 15\u001B[39m )\n\u001B[32m---> \u001B[39m\u001B[32m17\u001B[39m response_linear_c2 = \u001B[43mclient\u001B[49m\u001B[43m.\u001B[49m\u001B[43mforecast\u001B[49m\u001B[43m(\u001B[49m\u001B[43mModelName\u001B[49m\u001B[43m.\u001B[49m\u001B[43mCHRONOS2\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mrequest_linear_c2\u001B[49m\u001B[43m)\u001B[49m\n\u001B[32m 18\u001B[39m \u001B[38;5;28mprint\u001B[39m(response_linear_c2.point)\n\u001B[32m 19\u001B[39m \u001B[38;5;28mprint\u001B[39m(\u001B[33mf\u001B[39m\u001B[33m\"\u001B[39m\u001B[33m Response shape: \u001B[39m\u001B[38;5;132;01m{\u001B[39;00mresponse_linear_c2.quantiles.shape\u001B[38;5;132;01m}\u001B[39;00m\u001B[33m\"\u001B[39m)\n", - "\u001B[36mFile \u001B[39m\u001B[32m~/Documents/Personal/research/FAIM/faim-client/faim_sdk/client.py:296\u001B[39m, in \u001B[36mForecastClient.forecast\u001B[39m\u001B[34m(self, model, request)\u001B[39m\n\u001B[32m 289\u001B[39m \u001B[38;5;28;01mraise\u001B[39;00m ServiceUnavailableError(\n\u001B[32m 290\u001B[39m message=message,\n\u001B[32m 291\u001B[39m status_code=response.status_code,\n\u001B[32m 292\u001B[39m error_response=error_response,\n\u001B[32m 293\u001B[39m )\n\u001B[32m 294\u001B[39m \u001B[38;5;28;01melse\u001B[39;00m:\n\u001B[32m 295\u001B[39m \u001B[38;5;66;03m# Fallback for unmapped status codes\u001B[39;00m\n\u001B[32m--> \u001B[39m\u001B[32m296\u001B[39m \u001B[38;5;28;01mraise\u001B[39;00m APIError(\n\u001B[32m 297\u001B[39m message=message,\n\u001B[32m 298\u001B[39m status_code=response.status_code,\n\u001B[32m 299\u001B[39m error_response=error_response,\n\u001B[32m 300\u001B[39m )\n\u001B[32m 302\u001B[39m \u001B[38;5;66;03m# Deserialize successful response\u001B[39;00m\n\u001B[32m 303\u001B[39m \u001B[38;5;28;01mtry\u001B[39;00m:\n", - "\u001B[31mAPIError\u001B[39m: Request failed with status 502 | status=502" - ] - } - ], - "execution_count": 17 + "source": "print(\"=\" * 60)\nprint(\"CHRONOS2 MODEL\")\nprint(\"=\" * 60)\n\n# Quantile levels for probabilistic forecasting\nQUANTILES = [0.1, 0.25, 0.5, 0.75, 0.9]\n\n# Linear trend dataset\nprint(\"\\n1. Linear Trend Dataset (single feature)\")\nrequest_linear_c2 = Chronos2ForecastRequest(\n x=linear_train,\n horizon=HORIZON,\n output_type=\"quantiles\",\n quantiles=QUANTILES\n)\n\nresponse_linear_c2 = client.forecast(request_linear_c2)\nprint(f\" Response shape: {response_linear_c2.quantiles.shape}\")\nprint(f\" Metadata: {response_linear_c2.metadata}\")\n\n# Evaluate point forecast (use median)\npoint_linear_c2 = response_linear_c2.quantiles[:, :, 2:3] # Median (0.5 quantile), keep 3D\nmse_linear_c2 = mse(linear_test, point_linear_c2)\nmase_linear_c2 = mase(linear_test, point_linear_c2, linear_train)\ncrps_linear_c2 = crps_from_quantiles(linear_test, response_linear_c2.quantiles, QUANTILES)\nprint(f\" MSE (median): {mse_linear_c2:.4f}\")\nprint(f\" MASE (median): {mase_linear_c2:.4f}\")\nprint(f\" CRPS: {crps_linear_c2:.4f}\")\n\n# Multi-series dataset\nprint(\"\\n2. Correlated Multi-Series Dataset (2 features)\")\nrequest_multi_c2 = Chronos2ForecastRequest(\n x=multi_train,\n horizon=HORIZON,\n output_type=\"quantiles\",\n quantiles=QUANTILES\n)\n\nresponse_multi_c2 = client.forecast(request_multi_c2)\nprint(f\" Response shape: {response_multi_c2.quantiles.shape}\")\nprint(f\" Metadata: {response_multi_c2.metadata}\")\n\n# Evaluate point forecast (use median)\npoint_multi_c2 = response_multi_c2.quantiles[:, :, 2:3] # Median, keep 3D\nmse_multi_c2 = mse(multi_test, point_multi_c2)\nmase_multi_c2 = mase(multi_test, point_multi_c2, multi_train)\n# Note: CRPS expects single feature, so we'll compute per feature\ncrps_multi_c2_f1 = crps_from_quantiles(multi_test[:, :, 0:1], response_multi_c2.quantiles, QUANTILES)\ncrps_multi_c2_f2 = crps_from_quantiles(multi_test[:, :, 1:2], response_multi_c2.quantiles, QUANTILES)\nprint(f\" MSE (median): {mse_multi_c2:.4f}\")\nprint(f\" MASE (median): {mase_multi_c2:.4f}\")\nprint(f\" CRPS (feature 1): {crps_multi_c2_f1:.4f}\")\nprint(f\" CRPS (feature 2): {crps_multi_c2_f2:.4f}\")\n\nprint(\"\\n✓ Chronos2 forecasts complete\")", + "outputs": [], + "execution_count": null }, { "metadata": { @@ -542,10 +335,10 @@ "evalue": "name 'response_linear_c2' is not defined", "output_type": "error", "traceback": [ - "\u001B[31m---------------------------------------------------------------------------\u001B[39m", - "\u001B[31mNameError\u001B[39m Traceback (most recent call last)", - "\u001B[36mCell\u001B[39m\u001B[36m \u001B[39m\u001B[32mIn[13]\u001B[39m\u001B[32m, line 1\u001B[39m\n\u001B[32m----> \u001B[39m\u001B[32m1\u001B[39m \u001B[43mresponse_linear_c2\u001B[49m\n", - "\u001B[31mNameError\u001B[39m: name 'response_linear_c2' is not defined" + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mNameError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[13]\u001b[39m\u001b[32m, line 1\u001b[39m\n\u001b[32m----> \u001b[39m\u001b[32m1\u001b[39m \u001b[43mresponse_linear_c2\u001b[49m\n", + "\u001b[31mNameError\u001b[39m: name 'response_linear_c2' is not defined" ] } ], @@ -563,49 +356,7 @@ "execution_count": null, "metadata": {}, "outputs": [], - "source": [ - "print(\"=\" * 60)\n", - "print(\"TIREX MODEL\")\n", - "print(\"=\" * 60)\n", - "\n", - "# Linear trend dataset\n", - "print(\"\\n1. Linear Trend Dataset (single feature)\")\n", - "request_linear_tr = TiRexForecastRequest(\n", - " x=linear_train,\n", - " horizon=HORIZON,\n", - " output_type=\"point\"\n", - ")\n", - "\n", - "response_linear_tr = client.forecast(ModelName.TIREX, request_linear_tr)\n", - "print(f\" Response shape: {response_linear_tr.point.shape}\")\n", - "print(f\" Metadata: {response_linear_tr.metadata}\")\n", - "\n", - "# Evaluate\n", - "mse_linear_tr = mse(linear_test, response_linear_tr.point)\n", - "mase_linear_tr = mase(linear_test, response_linear_tr.point, linear_train)\n", - "print(f\" MSE: {mse_linear_tr:.4f}\")\n", - "print(f\" MASE: {mase_linear_tr:.4f}\")\n", - "\n", - "# Multi-series dataset\n", - "print(\"\\n2. Correlated Multi-Series Dataset (2 features)\")\n", - "request_multi_tr = TiRexForecastRequest(\n", - " x=multi_train,\n", - " horizon=HORIZON,\n", - " output_type=\"point\"\n", - ")\n", - "\n", - "response_multi_tr = client.forecast(ModelName.TIREX, request_multi_tr)\n", - "print(f\" Response shape: {response_multi_tr.point.shape}\")\n", - "print(f\" Metadata: {response_multi_tr.metadata}\")\n", - "\n", - "# Evaluate\n", - "mse_multi_tr = mse(multi_test, response_multi_tr.point)\n", - "mase_multi_tr = mase(multi_test, response_multi_tr.point, multi_train)\n", - "print(f\" MSE: {mse_multi_tr:.4f}\")\n", - "print(f\" MASE: {mase_multi_tr:.4f}\")\n", - "\n", - "print(\"\\n✓ TiRex forecasts complete\")" - ] + "source": "print(\"=\" * 60)\nprint(\"TIREX MODEL\")\nprint(\"=\" * 60)\n\n# Linear trend dataset\nprint(\"\\n1. Linear Trend Dataset (single feature)\")\nrequest_linear_tr = TiRexForecastRequest(\n x=linear_train,\n horizon=HORIZON,\n output_type=\"point\"\n)\n\nresponse_linear_tr = client.forecast(request_linear_tr)\nprint(f\" Response shape: {response_linear_tr.point.shape}\")\nprint(f\" Metadata: {response_linear_tr.metadata}\")\n\n# Evaluate\nmse_linear_tr = mse(linear_test, response_linear_tr.point)\nmase_linear_tr = mase(linear_test, response_linear_tr.point, linear_train)\nprint(f\" MSE: {mse_linear_tr:.4f}\")\nprint(f\" MASE: {mase_linear_tr:.4f}\")\n\n# Multi-series dataset\nprint(\"\\n2. Correlated Multi-Series Dataset (2 features)\")\nrequest_multi_tr = TiRexForecastRequest(\n x=multi_train,\n horizon=HORIZON,\n output_type=\"point\"\n)\n\nresponse_multi_tr = client.forecast(request_multi_tr)\nprint(f\" Response shape: {response_multi_tr.point.shape}\")\nprint(f\" Metadata: {response_multi_tr.metadata}\")\n\n# Evaluate\nmse_multi_tr = mse(multi_test, response_multi_tr.point)\nmase_multi_tr = mase(multi_test, response_multi_tr.point, multi_train)\nprint(f\" MSE: {mse_multi_tr:.4f}\")\nprint(f\" MASE: {mase_multi_tr:.4f}\")\n\nprint(\"\\n✓ TiRex forecasts complete\")" }, { "cell_type": "markdown", @@ -933,4 +684,4 @@ }, "nbformat": 4, "nbformat_minor": 4 -} +} \ No newline at end of file diff --git a/faim_sdk/__init__.py b/faim_sdk/__init__.py index 2328b4d..6c7920d 100644 --- a/faim_sdk/__init__.py +++ b/faim_sdk/__init__.py @@ -13,7 +13,6 @@ Basic usage: >>> from faim_sdk import ForecastClient, Chronos2ForecastRequest - >>> from faim_client.models import ModelName >>> import numpy as np >>> >>> # Initialize client @@ -31,8 +30,8 @@ ... quantiles=[0.1, 0.5, 0.9] ... ) >>> - >>> # Generate forecast - >>> response = client.forecast(ModelName.CHRONOS2, request) + >>> # Generate forecast - model inferred automatically + >>> response = client.forecast(request) >>> print(response.quantiles.shape) # (32, 10, 3) Main Components @@ -71,10 +70,11 @@ The SDK uses machine-readable error codes for programmatic error handling: - >>> from faim_sdk import ValidationError, ErrorCode + >>> from faim_sdk import ValidationError, ErrorCode, Chronos2ForecastRequest >>> >>> try: - ... response = client.forecast(ModelName.CHRONOS2, request) + ... request = Chronos2ForecastRequest(x=data, horizon=10, quantiles=[0.1, 0.5, 0.9]) + ... response = client.forecast(request) >>> except ValidationError as e: ... if e.error_code == ErrorCode.INVALID_SHAPE: ... print(f"Shape error: {e.error_response.detail}") @@ -142,4 +142,4 @@ "ConfigurationError", ] -__version__ = "0.2.1" +__version__ = "0.3.3" diff --git a/faim_sdk/client.py b/faim_sdk/client.py index d90e05c..4c0a755 100644 --- a/faim_sdk/client.py +++ b/faim_sdk/client.py @@ -69,10 +69,10 @@ class ForecastClient: - Comprehensive error handling with specific exception types - Request/response logging for observability - Support for both sync and async operations + - Automatic model inference from request type Example: >>> from faim_sdk import ForecastClient, Chronos2ForecastRequest - >>> from faim_client.models import ModelName >>> >>> client = ForecastClient(base_url="https://api.example.com") >>> request = Chronos2ForecastRequest( @@ -80,8 +80,8 @@ class ForecastClient: ... horizon=10, ... quantiles=[0.1, 0.5, 0.9] ... ) - >>> response = client.forecast(ModelName.CHRONOS2, request) - >>> print(response.point.shape) + >>> response = client.forecast(request) # Model inferred automatically + >>> print(response.quantiles.shape) """ def __init__( @@ -135,12 +135,17 @@ def __init__( ) logger.info(f"Initialized ForecastClient: base_url={base_url}, timeout={timeout}s") - def forecast(self, model: ModelName, request: ForecastRequest) -> ForecastResponse: + def forecast(self, request: ForecastRequest) -> ForecastResponse: """Generate time-series forecast (synchronous). + The model is automatically inferred from the request type: + - FlowStateForecastRequest → FlowState + - Chronos2ForecastRequest → Chronos2 + - TiRexForecastRequest → TiRex + Args: - model: Model to use (ModelName.FLOWSTATE, ModelName.CHRONOS2, or ModelName.TIREX) - request: Model-specific forecast request + request: Model-specific forecast request (FlowStateForecastRequest, + Chronos2ForecastRequest, or TiRexForecastRequest) Returns: ForecastResponse with predictions and metadata @@ -161,8 +166,9 @@ def forecast(self, model: ModelName, request: ForecastRequest) -> ForecastRespon Example: >>> request = FlowStateForecastRequest(x=data, horizon=10) - >>> response = client.forecast(ModelName.FLOWSTATE, request) + >>> response = client.forecast(request) """ + model = request.model_name logger.debug( f"Starting forecast: model={model}, version={request.model_version}, " f"x.shape={request.x.shape}, horizon={request.horizon}" @@ -317,12 +323,17 @@ def forecast(self, model: ModelName, request: ForecastRequest) -> ForecastRespon details={"model": str(model), "error": str(e)}, ) from e - async def forecast_async(self, model: ModelName, request: ForecastRequest) -> ForecastResponse: + async def forecast_async(self, request: ForecastRequest) -> ForecastResponse: """Generate time-series forecast (asynchronous). + The model is automatically inferred from the request type: + - FlowStateForecastRequest → FlowState + - Chronos2ForecastRequest → Chronos2 + - TiRexForecastRequest → TiRex + Args: - model: Model to use (ModelName.FLOWSTATE, ModelName.CHRONOS2, or ModelName.TIREX) - request: Model-specific forecast request + request: Model-specific forecast request (FlowStateForecastRequest, + Chronos2ForecastRequest, or TiRexForecastRequest) Returns: ForecastResponse with predictions and metadata @@ -332,8 +343,9 @@ async def forecast_async(self, model: ModelName, request: ForecastRequest) -> Fo Example: >>> request = Chronos2ForecastRequest(x=data, horizon=10) - >>> response = await client.forecast_async(ModelName.CHRONOS2, request) + >>> response = await client.forecast_async(request) """ + model = request.model_name logger.debug(f"Starting async forecast: model={model}, version={request.model_version}") # Serialize request @@ -532,7 +544,7 @@ def __enter__(self) -> "ForecastClient": Example: >>> with ForecastClient(base_url="https://api.example.com") as client: - ... response = client.forecast(ModelName.CHRONOS2, request) + ... response = client.forecast(request) ... # Client automatically closed on exit """ return self @@ -560,7 +572,7 @@ async def __aenter__(self) -> "ForecastClient": Example: >>> async with ForecastClient(base_url="https://api.example.com") as client: - ... response = await client.forecast_async(ModelName.CHRONOS2, request) + ... response = await client.forecast_async(request) ... # Client automatically closed on exit """ return self diff --git a/faim_sdk/models.py b/faim_sdk/models.py index 9630e4e..05bf71f 100644 --- a/faim_sdk/models.py +++ b/faim_sdk/models.py @@ -5,10 +5,12 @@ """ from dataclasses import dataclass, field -from typing import Any, Literal +from typing import Any, ClassVar, Literal import numpy as np +from faim_client.models import ModelName + # Type alias for output types OutputType = Literal["point", "quantiles", "samples"] @@ -22,6 +24,9 @@ class ForecastRequest: for better type safety and IDE support. """ + # Class variable to be overridden by subclasses + _model_name: ClassVar[ModelName] + x: np.ndarray """Time series data. Shape: (batch_size, sequence_length, features) or (sequence_length, features)""" @@ -34,6 +39,19 @@ class ForecastRequest: compression: str | None = "zstd" """Arrow compression algorithm. Options: 'zstd', 'lz4', None. Default: 'zstd'""" + @property + def model_name(self) -> ModelName: + """Get the model name for this request type. + + Returns: + ModelName enum value indicating which model to use + + Example: + >>> request = Chronos2ForecastRequest(x=data, horizon=10) + >>> print(request.model_name) # ModelName.CHRONOS2 + """ + return self._model_name + def __post_init__(self) -> None: """Validate common parameters. @@ -79,6 +97,8 @@ class Chronos2ForecastRequest(ForecastRequest): Supports point and quantile predictions. """ + _model_name: ClassVar[ModelName] = ModelName.CHRONOS2 + output_type: OutputType = "point" """Output type to return. Options: 'point', 'quantiles', 'samples'. Default: 'point'.""" @@ -129,6 +149,8 @@ class TiRexForecastRequest(ForecastRequest): Supports point and quantile predictions. """ + _model_name: ClassVar[ModelName] = ModelName.TIREX + output_type: OutputType = "point" """Output type to return. Options: 'point', 'quantiles', 'samples'. Default: 'point'.""" @@ -157,6 +179,8 @@ class FlowStateForecastRequest(ForecastRequest): and different prediction modes. """ + _model_name: ClassVar[ModelName] = ModelName.FLOWSTATE + output_type: OutputType = "point" """Output type to return. Options: 'point', 'quantiles', 'samples'. Default: 'point'.""" diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..b21ab73 --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,41 @@ +[tool.poetry] +name = "faim-sdk" +version = "0.3.3" +description = "Python SDK for FAIM time-series forecasting with foundation AI models" +authors = ["FAIM "] +license = "Apache-2.0" +readme = "README.md" +packages = [ + { include = "faim_sdk" }, + { include = "faim_client" }, +] +include = ["CHANGELOG.md", "faim_client/py.typed", "faim_sdk/py.typed", "faim_sdk/eval/py.typed"] + +[tool.poetry.dependencies] +python = "^3.11" +numpy = ">=1.26.0,<2.0.0" +pyarrow = ">=18.1.0" +httpx = ">=0.23.0,<0.29.0" +attrs = ">=22.2.0" +matplotlib = {version = ">=3.5.0", optional = true} + +[tool.poetry.extras] +viz = ["matplotlib"] + +[build-system] +requires = ["poetry-core>=2.0.0,<3.0.0"] +build-backend = "poetry.core.masonry.api" + +[tool.poetry.group.dev.dependencies] +jupyterlab = ">=4.4.10" +pandas = ">=2.3.3" +statsmodels = ">=0.14.5" +pytest = ">=8.0.0" +pytest-asyncio = ">=0.23.0" +pytest-cov = ">=4.1.0" + +[tool.ruff] +line-length = 120 + +[tool.ruff.lint] +select = ["F", "I", "UP"] diff --git a/tests/unit/test_client.py b/tests/unit/test_client.py new file mode 100644 index 0000000..c6f34a6 --- /dev/null +++ b/tests/unit/test_client.py @@ -0,0 +1,627 @@ +"""Unit tests for faim_sdk.client module. + +Tests ForecastClient initialization, sync/async methods, and error handling. +""" + +from unittest.mock import MagicMock, Mock, patch + +import httpx +import numpy as np +import pytest + +from faim_client.models import ModelName +from faim_client.models.error_code import ErrorCode +from faim_client.models.error_response import ErrorResponse +from faim_sdk.client import ForecastClient +from faim_sdk.exceptions import ( + AuthenticationError, + ConfigurationError, + InsufficientFundsError, + InternalServerError, + ModelNotFoundError, + NetworkError, + PayloadTooLargeError, + RateLimitError, + SerializationError, + ServiceUnavailableError, + TimeoutError, + ValidationError, +) +from faim_sdk.models import Chronos2ForecastRequest, FlowStateForecastRequest, ForecastResponse, TiRexForecastRequest +from faim_sdk.utils import serialize_to_arrow + + +class TestForecastClientInitialization: + """Tests for ForecastClient initialization.""" + + def test_initialization_minimal(self): + """Test initialization with minimal parameters.""" + client = ForecastClient(base_url="https://api.example.com") + + assert client.base_url == "https://api.example.com" + assert client.timeout == 120.0 + assert client._client is not None + + def test_initialization_with_api_key(self): + """Test initialization with API key.""" + client = ForecastClient( + base_url="https://api.example.com", + api_key="test-key-123", + ) + + assert client.base_url == "https://api.example.com" + + def test_initialization_with_timeout(self): + """Test initialization with custom timeout.""" + client = ForecastClient( + base_url="https://api.example.com", + timeout=60.0, + ) + + assert client.timeout == 60.0 + + def test_initialization_validation_requires_base_url(self): + """Test that base_url is required.""" + with pytest.raises(ConfigurationError, match="base_url is required"): + ForecastClient(base_url="") + + def test_initialization_validation_requires_valid_url(self): + """Test that base_url must be a valid URL.""" + with pytest.raises(ConfigurationError, match="base_url must be a valid URL"): + ForecastClient(base_url="not-a-url") + + def test_initialization_validation_positive_timeout(self): + """Test that timeout must be positive.""" + with pytest.raises(ConfigurationError, match="timeout must be positive"): + ForecastClient(base_url="https://api.example.com", timeout=0) + + def test_initialization_validation_negative_timeout(self): + """Test that timeout cannot be negative.""" + with pytest.raises(ConfigurationError, match="timeout must be positive"): + ForecastClient(base_url="https://api.example.com", timeout=-5) + + def test_context_manager_sync(self): + """Test synchronous context manager.""" + with ForecastClient(base_url="https://api.example.com") as client: + assert client._client is not None + + # Client should be closed after context + # (We can't easily test this without making actual requests) + + @pytest.mark.asyncio + async def test_context_manager_async(self): + """Test asynchronous context manager.""" + async with ForecastClient(base_url="https://api.example.com") as client: + assert client._client is not None + + +class TestForecastClientForecast: + """Tests for ForecastClient.forecast() method.""" + + def setup_method(self): + """Set up test fixtures.""" + self.client = ForecastClient(base_url="https://api.example.com") + self.test_data = np.random.rand(2, 10, 1).astype(np.float32) + + @patch("httpx.Client.post") + def test_forecast_chronos2_point(self, mock_post): + """Test forecast with Chronos2 model for point predictions.""" + # Setup mock response + response_arrays = {"point": np.random.rand(2, 5, 1).astype(np.float32)} + response_metadata = {"model_name": "chronos2", "model_version": "1"} + mock_response = Mock() + mock_response.status_code = 200 + mock_response.content = serialize_to_arrow(response_arrays, response_metadata) + mock_post.return_value = mock_response + + # Create request and call forecast + request = Chronos2ForecastRequest( + x=self.test_data, + horizon=5, + output_type="point", + ) + response = self.client.forecast(request) + + # Verify response + assert isinstance(response, ForecastResponse) + assert response.point is not None + assert response.point.shape == (2, 5, 1) + assert response.metadata["model_name"] == "chronos2" + + # Verify request was made correctly + mock_post.assert_called_once() + call_args = mock_post.call_args + assert "chronos2" in call_args[1]["url"] + + @patch("httpx.Client.post") + def test_forecast_chronos2_quantiles(self, mock_post): + """Test forecast with Chronos2 model for quantile predictions.""" + # Setup mock response + response_arrays = {"quantiles": np.random.rand(2, 5, 3).astype(np.float32)} + response_metadata = {"model_name": "chronos2", "quantiles": [0.1, 0.5, 0.9]} + mock_response = Mock() + mock_response.status_code = 200 + mock_response.content = serialize_to_arrow(response_arrays, response_metadata) + mock_post.return_value = mock_response + + # Create request and call forecast + request = Chronos2ForecastRequest( + x=self.test_data, + horizon=5, + output_type="quantiles", + quantiles=[0.1, 0.5, 0.9], + ) + response = self.client.forecast(request) + + # Verify response + assert response.quantiles is not None + assert response.quantiles.shape == (2, 5, 3) + assert response.point is None + + @patch("httpx.Client.post") + def test_forecast_flowstate(self, mock_post): + """Test forecast with FlowState model.""" + # Setup mock response + response_arrays = {"point": np.random.rand(2, 5, 1).astype(np.float32)} + response_metadata = {"model_name": "flowstate"} + mock_response = Mock() + mock_response.status_code = 200 + mock_response.content = serialize_to_arrow(response_arrays, response_metadata) + mock_post.return_value = mock_response + + # Create request and call forecast + request = FlowStateForecastRequest( + x=self.test_data, + horizon=5, + output_type="point", + prediction_type="mean", + ) + response = self.client.forecast(request) + + # Verify response + assert response.point is not None + assert response.metadata["model_name"] == "flowstate" + + # Verify URL contains flowstate + call_args = mock_post.call_args + assert "flowstate" in call_args[1]["url"] + + @patch("httpx.Client.post") + def test_forecast_tirex(self, mock_post): + """Test forecast with TiRex model.""" + # Setup mock response + response_arrays = {"point": np.random.rand(2, 5, 1).astype(np.float32)} + response_metadata = {"model_name": "tirex"} + mock_response = Mock() + mock_response.status_code = 200 + mock_response.content = serialize_to_arrow(response_arrays, response_metadata) + mock_post.return_value = mock_response + + # Create request and call forecast + request = TiRexForecastRequest( + x=self.test_data, + horizon=5, + output_type="point", + ) + response = self.client.forecast(request) + + # Verify response + assert response.point is not None + + # Verify URL contains tirex + call_args = mock_post.call_args + assert "tirex" in call_args[1]["url"] + + @patch("httpx.Client.post") + def test_forecast_with_custom_model_version(self, mock_post): + """Test forecast with custom model version.""" + # Setup mock response + response_arrays = {"point": np.random.rand(2, 5, 1).astype(np.float32)} + mock_response = Mock() + mock_response.status_code = 200 + mock_response.content = serialize_to_arrow(response_arrays, {}) + mock_post.return_value = mock_response + + # Create request with custom version + request = Chronos2ForecastRequest( + x=self.test_data, + horizon=5, + model_version="2.0", + ) + self.client.forecast(request) + + # Verify URL contains version + call_args = mock_post.call_args + assert "/2.0" in call_args[1]["url"] or "2.0" in call_args[1]["url"] + + +class TestForecastClientErrorHandling: + """Tests for ForecastClient error handling.""" + + def setup_method(self): + """Set up test fixtures.""" + self.client = ForecastClient(base_url="https://api.example.com") + self.test_data = np.random.rand(2, 10, 1).astype(np.float32) + self.request = Chronos2ForecastRequest(x=self.test_data, horizon=5) + + @patch("httpx.Client.post") + def test_validation_error_422(self, mock_post): + """Test handling of 422 validation errors.""" + # Setup mock error response + error_response = ErrorResponse( + error_code=ErrorCode.INVALID_SHAPE, + message="Shape validation failed", + detail="Expected (batch, seq, feat)", + request_id="req_123", + ) + mock_response = Mock() + mock_response.status_code = 422 + mock_response.json.return_value = error_response.to_dict() + mock_post.return_value = mock_response + + with pytest.raises(ValidationError) as exc_info: + self.client.forecast(self.request) + + assert exc_info.value.status_code == 422 + assert exc_info.value.error_code == ErrorCode.INVALID_SHAPE + + @patch("httpx.Client.post") + def test_authentication_error_401(self, mock_post): + """Test handling of 401 authentication errors.""" + error_response = ErrorResponse( + error_code=ErrorCode.INVALID_API_KEY, + message="API key is invalid", + ) + mock_response = Mock() + mock_response.status_code = 401 + mock_response.json.return_value = error_response.to_dict() + mock_post.return_value = mock_response + + with pytest.raises(AuthenticationError) as exc_info: + self.client.forecast(self.request) + + assert exc_info.value.status_code == 401 + + @patch("httpx.Client.post") + def test_authentication_error_403(self, mock_post): + """Test handling of 403 forbidden errors.""" + mock_response = Mock() + mock_response.status_code = 403 + mock_response.json.return_value = {} + mock_post.return_value = mock_response + + with pytest.raises(AuthenticationError) as exc_info: + self.client.forecast(self.request) + + assert exc_info.value.status_code == 403 + + @patch("httpx.Client.post") + def test_insufficient_funds_error_402(self, mock_post): + """Test handling of 402 payment required errors.""" + error_response = ErrorResponse( + error_code=ErrorCode.INSUFFICIENT_FUNDS, + message="Insufficient balance", + ) + mock_response = Mock() + mock_response.status_code = 402 + mock_response.json.return_value = error_response.to_dict() + mock_post.return_value = mock_response + + with pytest.raises(InsufficientFundsError) as exc_info: + self.client.forecast(self.request) + + assert exc_info.value.status_code == 402 + + @patch("httpx.Client.post") + def test_model_not_found_error_404(self, mock_post): + """Test handling of 404 not found errors.""" + error_response = ErrorResponse( + error_code=ErrorCode.MODEL_NOT_FOUND, + message="Model not found", + ) + mock_response = Mock() + mock_response.status_code = 404 + mock_response.json.return_value = error_response.to_dict() + mock_post.return_value = mock_response + + with pytest.raises(ModelNotFoundError) as exc_info: + self.client.forecast(self.request) + + assert exc_info.value.status_code == 404 + + @patch("httpx.Client.post") + def test_payload_too_large_error_413(self, mock_post): + """Test handling of 413 payload too large errors.""" + error_response = ErrorResponse( + error_code=ErrorCode.PAYLOAD_TOO_LARGE, + message="Payload exceeds limit", + ) + mock_response = Mock() + mock_response.status_code = 413 + mock_response.json.return_value = error_response.to_dict() + mock_post.return_value = mock_response + + with pytest.raises(PayloadTooLargeError) as exc_info: + self.client.forecast(self.request) + + assert exc_info.value.status_code == 413 + + @patch("httpx.Client.post") + def test_rate_limit_error_429(self, mock_post): + """Test handling of 429 rate limit errors.""" + error_response = ErrorResponse( + error_code=ErrorCode.RATE_LIMIT_EXCEEDED, + message="Rate limit exceeded", + ) + mock_response = Mock() + mock_response.status_code = 429 + mock_response.json.return_value = error_response.to_dict() + mock_post.return_value = mock_response + + with pytest.raises(RateLimitError) as exc_info: + self.client.forecast(self.request) + + assert exc_info.value.status_code == 429 + + @patch("httpx.Client.post") + def test_internal_server_error_500(self, mock_post): + """Test handling of 500 internal server errors.""" + mock_response = Mock() + mock_response.status_code = 500 + mock_response.json.return_value = {} + mock_post.return_value = mock_response + + with pytest.raises(InternalServerError) as exc_info: + self.client.forecast(self.request) + + assert exc_info.value.status_code == 500 + + @patch("httpx.Client.post") + def test_service_unavailable_error_503(self, mock_post): + """Test handling of 503 service unavailable errors.""" + error_response = ErrorResponse( + error_code=ErrorCode.TRITON_CONNECTION_ERROR, + message="Cannot connect to backend", + ) + mock_response = Mock() + mock_response.status_code = 503 + mock_response.json.return_value = error_response.to_dict() + mock_post.return_value = mock_response + + with pytest.raises(ServiceUnavailableError) as exc_info: + self.client.forecast(self.request) + + assert exc_info.value.status_code == 503 + + @patch("httpx.Client.post") + def test_service_unavailable_error_504(self, mock_post): + """Test handling of 504 gateway timeout errors.""" + mock_response = Mock() + mock_response.status_code = 504 + mock_response.json.return_value = {} + mock_post.return_value = mock_response + + with pytest.raises(ServiceUnavailableError) as exc_info: + self.client.forecast(self.request) + + assert exc_info.value.status_code == 504 + + @patch("httpx.Client.post") + def test_network_error_connection_failed(self, mock_post): + """Test handling of network connection errors.""" + mock_post.side_effect = httpx.ConnectError("Connection refused") + + with pytest.raises(NetworkError) as exc_info: + self.client.forecast(self.request) + + assert "Connection refused" in str(exc_info.value) + + @patch("httpx.Client.post") + def test_timeout_error(self, mock_post): + """Test handling of timeout errors.""" + mock_post.side_effect = httpx.TimeoutException("Request timeout") + + with pytest.raises(TimeoutError) as exc_info: + self.client.forecast(self.request) + + assert "timeout" in str(exc_info.value).lower() + + @patch("faim_sdk.utils.serialize_to_arrow") + def test_serialization_error(self, mock_serialize): + """Test handling of serialization errors.""" + mock_serialize.side_effect = TypeError("Invalid array type") + + with pytest.raises(SerializationError) as exc_info: + self.client.forecast(self.request) + + assert "serialization" in str(exc_info.value).lower() + + +class TestForecastClientAsync: + """Tests for ForecastClient.forecast_async() method.""" + + def setup_method(self): + """Set up test fixtures.""" + self.client = ForecastClient(base_url="https://api.example.com") + self.test_data = np.random.rand(2, 10, 1).astype(np.float32) + + @pytest.mark.asyncio + @patch("httpx.AsyncClient.post") + async def test_forecast_async_success(self, mock_post): + """Test async forecast with successful response.""" + # Setup mock response + response_arrays = {"point": np.random.rand(2, 5, 1).astype(np.float32)} + response_metadata = {"model_name": "chronos2"} + mock_response = Mock() + mock_response.status_code = 200 + mock_response.content = serialize_to_arrow(response_arrays, response_metadata) + mock_post.return_value = mock_response + + # Create request and call async forecast + request = Chronos2ForecastRequest( + x=self.test_data, + horizon=5, + output_type="point", + ) + response = await self.client.forecast_async(request) + + # Verify response + assert isinstance(response, ForecastResponse) + assert response.point is not None + assert response.point.shape == (2, 5, 1) + + @pytest.mark.asyncio + @patch("httpx.AsyncClient.post") + async def test_forecast_async_validation_error(self, mock_post): + """Test async forecast with validation error.""" + # Setup mock error response + error_response = ErrorResponse( + error_code=ErrorCode.INVALID_SHAPE, + message="Shape validation failed", + ) + mock_response = Mock() + mock_response.status_code = 422 + mock_response.json.return_value = error_response.to_dict() + mock_post.return_value = mock_response + + request = Chronos2ForecastRequest(x=self.test_data, horizon=5) + + with pytest.raises(ValidationError): + await self.client.forecast_async(request) + + +class TestForecastClientClose: + """Tests for ForecastClient resource cleanup.""" + + def test_close_method(self): + """Test close method closes underlying client.""" + client = ForecastClient(base_url="https://api.example.com") + + # Should not raise any exceptions + client.close() + + @pytest.mark.asyncio + async def test_aclose_method(self): + """Test async close method.""" + client = ForecastClient(base_url="https://api.example.com") + + # Should not raise any exceptions + await client.aclose() + + def test_context_manager_closes_client(self): + """Test that context manager closes client on exit.""" + with ForecastClient(base_url="https://api.example.com") as client: + pass + + # Client should be closed after context exits + # (We can't easily verify this without implementation details) + + @pytest.mark.asyncio + async def test_async_context_manager_closes_client(self): + """Test that async context manager closes client on exit.""" + async with ForecastClient(base_url="https://api.example.com") as client: + pass + + # Client should be closed after context exits + + +class TestForecastClientLogging: + """Tests for ForecastClient logging behavior.""" + + @patch("httpx.Client.post") + def test_logs_request_info(self, mock_post): + """Test that client logs request information.""" + # Setup mock response + response_arrays = {"point": np.random.rand(2, 5, 1).astype(np.float32)} + mock_response = Mock() + mock_response.status_code = 200 + mock_response.content = serialize_to_arrow(response_arrays, {}) + mock_post.return_value = mock_response + + client = ForecastClient(base_url="https://api.example.com") + request = Chronos2ForecastRequest( + x=np.random.rand(2, 10, 1).astype(np.float32), + horizon=5, + ) + + # Should not raise exceptions + with patch("faim_sdk.client.logger") as mock_logger: + client.forecast(request) + # Verify some logging occurred + assert mock_logger.debug.called or mock_logger.info.called + + @patch("httpx.Client.post") + def test_logs_error_info(self, mock_post): + """Test that client logs error information.""" + # Setup mock error response + mock_response = Mock() + mock_response.status_code = 422 + mock_response.json.return_value = {} + mock_post.return_value = mock_response + + client = ForecastClient(base_url="https://api.example.com") + request = Chronos2ForecastRequest( + x=np.random.rand(2, 10, 1).astype(np.float32), + horizon=5, + ) + + with patch("faim_sdk.client.logger") as mock_logger: + try: + client.forecast(request) + except ValidationError: + pass + + # Verify error logging occurred + assert mock_logger.error.called or mock_logger.warning.called + + +class TestForecastClientIntegration: + """Integration-style tests for realistic usage patterns.""" + + @patch("httpx.Client.post") + def test_multiple_requests_same_client(self, mock_post): + """Test making multiple requests with the same client instance.""" + # Setup mock response + response_arrays = {"point": np.random.rand(2, 5, 1).astype(np.float32)} + mock_response = Mock() + mock_response.status_code = 200 + mock_response.content = serialize_to_arrow(response_arrays, {}) + mock_post.return_value = mock_response + + client = ForecastClient(base_url="https://api.example.com") + data = np.random.rand(2, 10, 1).astype(np.float32) + + # Make multiple requests + for _ in range(3): + request = Chronos2ForecastRequest(x=data, horizon=5) + response = client.forecast(request) + assert response.point is not None + + # Verify all requests were made + assert mock_post.call_count == 3 + + @patch("httpx.Client.post") + def test_different_models_same_client(self, mock_post): + """Test using different models with the same client.""" + # Setup mock response + response_arrays = {"point": np.random.rand(2, 5, 1).astype(np.float32)} + mock_response = Mock() + mock_response.status_code = 200 + mock_response.content = serialize_to_arrow(response_arrays, {}) + mock_post.return_value = mock_response + + client = ForecastClient(base_url="https://api.example.com") + data = np.random.rand(2, 10, 1).astype(np.float32) + + # Test different models + requests = [ + Chronos2ForecastRequest(x=data, horizon=5), + FlowStateForecastRequest(x=data, horizon=5, prediction_type="mean"), + TiRexForecastRequest(x=data, horizon=5), + ] + + for req in requests: + response = client.forecast(req) + assert response.point is not None + + assert mock_post.call_count == 3 diff --git a/tests/unit/test_exceptions.py b/tests/unit/test_exceptions.py new file mode 100644 index 0000000..0b20510 --- /dev/null +++ b/tests/unit/test_exceptions.py @@ -0,0 +1,628 @@ +"""Unit tests for faim_sdk.exceptions module. + +Tests exception hierarchy, error handling, and error contract integration. +""" + +import pytest + +from faim_client.models.error_code import ErrorCode +from faim_client.models.error_response import ErrorResponse +from faim_sdk.exceptions import ( + APIError, + AuthenticationError, + ConfigurationError, + FAIMError, + InsufficientFundsError, + InternalServerError, + ModelNotFoundError, + NetworkError, + PayloadTooLargeError, + RateLimitError, + SerializationError, + ServiceUnavailableError, + TimeoutError, + ValidationError, +) + + +class TestFAIMError: + """Tests for base FAIMError exception.""" + + def test_initialization_with_message(self): + """Test basic initialization with message.""" + error = FAIMError("Something went wrong") + assert error.message == "Something went wrong" + assert error.details == {} + + def test_initialization_with_details(self): + """Test initialization with details.""" + details = {"key": "value", "count": 42} + error = FAIMError("Error occurred", details=details) + + assert error.message == "Error occurred" + assert error.details == details + assert error.details["key"] == "value" + assert error.details["count"] == 42 + + def test_str_without_details(self): + """Test string representation without details.""" + error = FAIMError("Test error") + assert str(error) == "Test error" + + def test_str_with_details(self): + """Test string representation with details.""" + error = FAIMError("Test error", details={"foo": "bar"}) + result = str(error) + + assert "Test error" in result + assert "details:" in result + assert "foo" in result + + def test_inherits_from_exception(self): + """Test that FAIMError inherits from Exception.""" + error = FAIMError("Test") + assert isinstance(error, Exception) + + def test_can_be_raised_and_caught(self): + """Test that error can be raised and caught.""" + with pytest.raises(FAIMError) as exc_info: + raise FAIMError("Test error") + + assert exc_info.value.message == "Test error" + + +class TestSerializationError: + """Tests for SerializationError exception.""" + + def test_inherits_from_faim_error(self): + """Test inheritance from FAIMError.""" + error = SerializationError("Serialization failed") + assert isinstance(error, FAIMError) + assert isinstance(error, Exception) + + def test_initialization(self): + """Test basic initialization.""" + error = SerializationError("Arrow serialization failed") + assert error.message == "Arrow serialization failed" + + def test_with_details(self): + """Test with additional details.""" + error = SerializationError( + "Invalid array type", + details={"expected": "ndarray", "got": "list"}, + ) + assert error.details["expected"] == "ndarray" + + +class TestAPIError: + """Tests for base APIError exception.""" + + def test_inherits_from_faim_error(self): + """Test inheritance from FAIMError.""" + error = APIError("API failed") + assert isinstance(error, FAIMError) + + def test_initialization_minimal(self): + """Test initialization with minimal parameters.""" + error = APIError("Request failed") + + assert error.message == "Request failed" + assert error.status_code is None + assert error.error_response is None + assert error.details == {} + + def test_initialization_with_status_code(self): + """Test initialization with status code.""" + error = APIError("Request failed", status_code=500) + assert error.status_code == 500 + + def test_initialization_with_error_response(self): + """Test initialization with ErrorResponse.""" + err_response = ErrorResponse( + error_code=ErrorCode.VALIDATION_ERROR, + message="Validation failed", + detail="Invalid parameter", + request_id="req_123", + ) + error = APIError("Request failed", error_response=err_response) + + assert error.error_response == err_response + assert error.error_response.error_code == ErrorCode.VALIDATION_ERROR + + def test_error_code_property_with_response(self): + """Test error_code property when error_response is available.""" + err_response = ErrorResponse( + error_code=ErrorCode.INVALID_SHAPE, + message="Shape error", + ) + error = APIError("Failed", error_response=err_response) + + assert error.error_code == ErrorCode.INVALID_SHAPE + + def test_error_code_property_without_response(self): + """Test error_code property when error_response is None.""" + error = APIError("Failed") + assert error.error_code is None + + def test_str_minimal(self): + """Test string representation with minimal info.""" + error = APIError("Request failed") + assert str(error) == "Request failed" + + def test_str_with_status_code(self): + """Test string representation with status code.""" + error = APIError("Request failed", status_code=422) + result = str(error) + + assert "Request failed" in result + assert "status=422" in result + + def test_str_with_error_response(self): + """Test string representation with error response.""" + err_response = ErrorResponse( + error_code=ErrorCode.VALIDATION_ERROR, + message="Validation failed", + request_id="req_abc123", + ) + error = APIError("Request failed", status_code=422, error_response=err_response) + result = str(error) + + assert "Request failed" in result + assert "status=422" in result + assert "error_code=validation_error" in result + assert "request_id=req_abc123" in result + + def test_str_with_all_fields(self): + """Test string representation with all fields.""" + err_response = ErrorResponse( + error_code=ErrorCode.INVALID_SHAPE, + message="Shape error", + detail="Expected (32, 100, 1)", + request_id="req_xyz789", + ) + error = APIError( + "Request failed", + status_code=422, + error_response=err_response, + details={"retry": True}, + ) + result = str(error) + + assert "Request failed" in result + assert "status=422" in result + assert "error_code=invalid_shape" in result + assert "request_id=req_xyz789" in result + assert "details=" in result + + +class TestValidationError: + """Tests for ValidationError exception.""" + + def test_inherits_from_api_error(self): + """Test inheritance hierarchy.""" + error = ValidationError("Validation failed") + assert isinstance(error, APIError) + assert isinstance(error, FAIMError) + + def test_with_error_code(self): + """Test with specific error code.""" + err_response = ErrorResponse( + error_code=ErrorCode.INVALID_SHAPE, + message="Shape mismatch", + detail="Expected (batch, seq, feat)", + ) + error = ValidationError( + "Validation failed", + status_code=422, + error_response=err_response, + ) + + assert error.error_code == ErrorCode.INVALID_SHAPE + assert error.status_code == 422 + + +class TestAuthenticationError: + """Tests for AuthenticationError exception.""" + + def test_inherits_from_api_error(self): + """Test inheritance hierarchy.""" + error = AuthenticationError("Auth failed") + assert isinstance(error, APIError) + + def test_typical_usage(self): + """Test typical authentication error scenario.""" + err_response = ErrorResponse( + error_code=ErrorCode.INVALID_API_KEY, + message="API key is invalid", + request_id="req_auth_001", + ) + error = AuthenticationError( + "Authentication failed", + status_code=401, + error_response=err_response, + ) + + assert error.error_code == ErrorCode.INVALID_API_KEY + assert error.status_code == 401 + + +class TestInsufficientFundsError: + """Tests for InsufficientFundsError exception.""" + + def test_inherits_from_api_error(self): + """Test inheritance hierarchy.""" + error = InsufficientFundsError("Insufficient funds") + assert isinstance(error, APIError) + + def test_typical_usage(self): + """Test typical billing error scenario.""" + err_response = ErrorResponse( + error_code=ErrorCode.INSUFFICIENT_FUNDS, + message="Account balance too low", + detail="Required: $10, Available: $5", + ) + error = InsufficientFundsError( + "Billing error", + status_code=402, + error_response=err_response, + ) + + assert error.error_code == ErrorCode.INSUFFICIENT_FUNDS + assert error.status_code == 402 + + +class TestRateLimitError: + """Tests for RateLimitError exception.""" + + def test_inherits_from_api_error(self): + """Test inheritance hierarchy.""" + error = RateLimitError("Rate limit exceeded") + assert isinstance(error, APIError) + + def test_typical_usage(self): + """Test typical rate limit scenario.""" + err_response = ErrorResponse( + error_code=ErrorCode.RATE_LIMIT_EXCEEDED, + message="Too many requests", + detail="Limit: 100/min", + ) + error = RateLimitError( + "Rate limit exceeded", + status_code=429, + error_response=err_response, + ) + + assert error.error_code == ErrorCode.RATE_LIMIT_EXCEEDED + assert error.status_code == 429 + + +class TestModelNotFoundError: + """Tests for ModelNotFoundError exception.""" + + def test_inherits_from_api_error(self): + """Test inheritance hierarchy.""" + error = ModelNotFoundError("Model not found") + assert isinstance(error, APIError) + + def test_typical_usage(self): + """Test typical model not found scenario.""" + err_response = ErrorResponse( + error_code=ErrorCode.MODEL_NOT_FOUND, + message="Model version not available", + detail="chronos2:2.0 not found", + ) + error = ModelNotFoundError( + "Model not found", + status_code=404, + error_response=err_response, + ) + + assert error.error_code == ErrorCode.MODEL_NOT_FOUND + assert error.status_code == 404 + + +class TestPayloadTooLargeError: + """Tests for PayloadTooLargeError exception.""" + + def test_inherits_from_api_error(self): + """Test inheritance hierarchy.""" + error = PayloadTooLargeError("Payload too large") + assert isinstance(error, APIError) + + def test_typical_usage(self): + """Test typical payload size error scenario.""" + err_response = ErrorResponse( + error_code=ErrorCode.PAYLOAD_TOO_LARGE, + message="Request size exceeds limit", + detail="Size: 150MB, Limit: 100MB", + ) + error = PayloadTooLargeError( + "Payload too large", + status_code=413, + error_response=err_response, + ) + + assert error.error_code == ErrorCode.PAYLOAD_TOO_LARGE + assert error.status_code == 413 + + +class TestInternalServerError: + """Tests for InternalServerError exception.""" + + def test_inherits_from_api_error(self): + """Test inheritance hierarchy.""" + error = InternalServerError("Internal error") + assert isinstance(error, APIError) + + def test_typical_usage(self): + """Test typical internal server error scenario.""" + err_response = ErrorResponse( + error_code=ErrorCode.INTERNAL_ERROR, + message="An unexpected error occurred", + request_id="req_500_abc", + ) + error = InternalServerError( + "Internal server error", + status_code=500, + error_response=err_response, + ) + + assert error.error_code == ErrorCode.INTERNAL_ERROR + assert error.status_code == 500 + + +class TestServiceUnavailableError: + """Tests for ServiceUnavailableError exception.""" + + def test_inherits_from_api_error(self): + """Test inheritance hierarchy.""" + error = ServiceUnavailableError("Service unavailable") + assert isinstance(error, APIError) + + def test_typical_usage_503(self): + """Test typical service unavailable scenario (503).""" + err_response = ErrorResponse( + error_code=ErrorCode.TRITON_CONNECTION_ERROR, + message="Cannot connect to inference backend", + ) + error = ServiceUnavailableError( + "Service unavailable", + status_code=503, + error_response=err_response, + ) + + assert error.error_code == ErrorCode.TRITON_CONNECTION_ERROR + assert error.status_code == 503 + + def test_typical_usage_504(self): + """Test typical timeout scenario (504).""" + err_response = ErrorResponse( + error_code=ErrorCode.TIMEOUT_ERROR, + message="Request timeout", + ) + error = ServiceUnavailableError( + "Gateway timeout", + status_code=504, + error_response=err_response, + ) + + assert error.error_code == ErrorCode.TIMEOUT_ERROR + assert error.status_code == 504 + + +class TestNetworkError: + """Tests for NetworkError exception.""" + + def test_inherits_from_faim_error(self): + """Test inheritance hierarchy.""" + error = NetworkError("Network failed") + assert isinstance(error, FAIMError) + assert not isinstance(error, APIError) + + def test_initialization(self): + """Test basic initialization.""" + error = NetworkError("Connection refused") + assert error.message == "Connection refused" + + def test_with_details(self): + """Test with connection details.""" + error = NetworkError( + "Connection failed", + details={"host": "api.example.com", "port": 443}, + ) + assert error.details["host"] == "api.example.com" + + +class TestTimeoutError: + """Tests for TimeoutError exception.""" + + def test_inherits_from_faim_error(self): + """Test inheritance hierarchy.""" + error = TimeoutError("Request timeout") + assert isinstance(error, FAIMError) + assert not isinstance(error, APIError) + + def test_initialization(self): + """Test basic initialization.""" + error = TimeoutError("Request exceeded 120s timeout") + assert error.message == "Request exceeded 120s timeout" + + def test_with_details(self): + """Test with timeout details.""" + error = TimeoutError( + "Timeout", + details={"configured": 120, "elapsed": 125}, + ) + assert error.details["configured"] == 120 + assert error.details["elapsed"] == 125 + + +class TestConfigurationError: + """Tests for ConfigurationError exception.""" + + def test_inherits_from_faim_error(self): + """Test inheritance hierarchy.""" + error = ConfigurationError("Config invalid") + assert isinstance(error, FAIMError) + assert not isinstance(error, APIError) + + def test_initialization(self): + """Test basic initialization.""" + error = ConfigurationError("Missing base_url") + assert error.message == "Missing base_url" + + def test_with_details(self): + """Test with configuration details.""" + error = ConfigurationError( + "Invalid configuration", + details={"field": "base_url", "value": None}, + ) + assert error.details["field"] == "base_url" + + +class TestExceptionHierarchy: + """Tests for exception hierarchy and inheritance.""" + + def test_all_exceptions_inherit_from_faim_error(self): + """Test that all SDK exceptions inherit from FAIMError.""" + exceptions = [ + SerializationError("test"), + APIError("test"), + ValidationError("test"), + AuthenticationError("test"), + InsufficientFundsError("test"), + RateLimitError("test"), + ModelNotFoundError("test"), + PayloadTooLargeError("test"), + InternalServerError("test"), + ServiceUnavailableError("test"), + NetworkError("test"), + TimeoutError("test"), + ConfigurationError("test"), + ] + + for exc in exceptions: + assert isinstance(exc, FAIMError) + assert isinstance(exc, Exception) + + def test_api_errors_inherit_from_api_error(self): + """Test that API exceptions inherit from APIError.""" + api_exceptions = [ + ValidationError("test"), + AuthenticationError("test"), + InsufficientFundsError("test"), + RateLimitError("test"), + ModelNotFoundError("test"), + PayloadTooLargeError("test"), + InternalServerError("test"), + ServiceUnavailableError("test"), + ] + + for exc in api_exceptions: + assert isinstance(exc, APIError) + + def test_non_api_errors_dont_inherit_from_api_error(self): + """Test that non-API exceptions don't inherit from APIError.""" + non_api_exceptions = [ + SerializationError("test"), + NetworkError("test"), + TimeoutError("test"), + ConfigurationError("test"), + ] + + for exc in non_api_exceptions: + assert not isinstance(exc, APIError) + + def test_catch_all_with_faim_error(self): + """Test that FAIMError can catch all SDK exceptions.""" + test_exceptions = [ + ValidationError("test"), + NetworkError("test"), + SerializationError("test"), + ] + + for exc_class in test_exceptions: + with pytest.raises(FAIMError): + raise exc_class + + def test_catch_api_errors_specifically(self): + """Test catching only API errors.""" + with pytest.raises(APIError): + raise ValidationError("test") + + # Non-API errors should not be caught + with pytest.raises(FAIMError): + try: + raise NetworkError("test") + except APIError: + pytest.fail("NetworkError should not be caught as APIError") + + +class TestErrorContract: + """Tests for error contract integration with ErrorResponse and ErrorCode.""" + + def test_error_response_integration(self): + """Test integration with ErrorResponse model.""" + err_response = ErrorResponse( + error_code=ErrorCode.VALIDATION_ERROR, + message="Validation failed", + detail="horizon must be positive", + request_id="req_123", + metadata={"field": "horizon", "value": -5}, + ) + + error = ValidationError("Request validation failed", error_response=err_response) + + assert error.error_response.error_code == ErrorCode.VALIDATION_ERROR + assert error.error_response.message == "Validation failed" + assert error.error_response.detail == "horizon must be positive" + assert error.error_response.request_id == "req_123" + assert error.error_response.metadata["field"] == "horizon" + + def test_error_code_enum_access(self): + """Test accessing ErrorCode enum through exception.""" + err_response = ErrorResponse( + error_code=ErrorCode.INVALID_SHAPE, + message="Shape error", + ) + error = ValidationError("Validation failed", error_response=err_response) + + # Can access via property + assert error.error_code == ErrorCode.INVALID_SHAPE + + # Can compare with enum values + assert error.error_code == ErrorCode.INVALID_SHAPE + assert error.error_code != ErrorCode.MISSING_REQUIRED_FIELD + + def test_programmatic_error_handling(self): + """Test programmatic error handling with error codes.""" + + def handle_error(exc: APIError) -> str: + """Example error handler using error codes.""" + if exc.error_code == ErrorCode.INVALID_SHAPE: + return "shape_error" + elif exc.error_code == ErrorCode.MISSING_REQUIRED_FIELD: + return "missing_field" + elif exc.error_code == ErrorCode.RATE_LIMIT_EXCEEDED: + return "rate_limit" + else: + return "unknown" + + # Test different error codes + err1 = ValidationError( + "Failed", + error_response=ErrorResponse(error_code=ErrorCode.INVALID_SHAPE, message="Shape error"), + ) + assert handle_error(err1) == "shape_error" + + err2 = ValidationError( + "Failed", + error_response=ErrorResponse(error_code=ErrorCode.MISSING_REQUIRED_FIELD, message="Missing field"), + ) + assert handle_error(err2) == "missing_field" + + err3 = RateLimitError( + "Failed", + error_response=ErrorResponse(error_code=ErrorCode.RATE_LIMIT_EXCEEDED, message="Rate limit"), + ) + assert handle_error(err3) == "rate_limit" diff --git a/tests/unit/test_models.py b/tests/unit/test_models.py new file mode 100644 index 0000000..40903e3 --- /dev/null +++ b/tests/unit/test_models.py @@ -0,0 +1,476 @@ +"""Unit tests for faim_sdk.models module. + +Tests request and response model validation, serialization, and type safety. +""" + +import numpy as np +import pytest + +from faim_client.models import ModelName +from faim_sdk.models import ( + Chronos2ForecastRequest, + FlowStateForecastRequest, + ForecastRequest, + ForecastResponse, + TiRexForecastRequest, +) + + +class TestForecastRequest: + """Tests for base ForecastRequest class.""" + + def test_cannot_instantiate_base_class_without_model_name(self): + """Base class requires _model_name to be defined.""" + with pytest.raises(AttributeError): + ForecastRequest( + x=np.array([[1.0, 2.0], [3.0, 4.0]]), + horizon=10, + ) + + def test_validation_requires_numpy_array(self): + """x parameter must be numpy array.""" + with pytest.raises(TypeError, match="x must be numpy.ndarray"): + Chronos2ForecastRequest( + x=[[1.0, 2.0], [3.0, 4.0]], # Python list, not ndarray + horizon=10, + ) + + def test_validation_requires_non_empty_array(self): + """x parameter cannot be empty.""" + with pytest.raises(ValueError, match="x cannot be empty"): + Chronos2ForecastRequest( + x=np.array([]), + horizon=10, + ) + + def test_validation_requires_positive_horizon(self): + """horizon must be positive.""" + with pytest.raises(ValueError, match="horizon must be positive"): + Chronos2ForecastRequest( + x=np.array([[1.0, 2.0]]), + horizon=0, + ) + + def test_validation_requires_positive_horizon_negative(self): + """horizon cannot be negative.""" + with pytest.raises(ValueError, match="horizon must be positive"): + Chronos2ForecastRequest( + x=np.array([[1.0, 2.0]]), + horizon=-5, + ) + + +class TestChronos2ForecastRequest: + """Tests for Chronos2ForecastRequest model.""" + + def test_model_name_is_chronos2(self): + """Model name should be CHRONOS2.""" + request = Chronos2ForecastRequest( + x=np.array([[1.0, 2.0]]), + horizon=10, + ) + assert request.model_name == ModelName.CHRONOS2 + + def test_default_values(self): + """Test default parameter values.""" + request = Chronos2ForecastRequest( + x=np.array([[1.0, 2.0]]), + horizon=10, + ) + assert request.model_version == "1" + assert request.compression == "zstd" + assert request.output_type == "point" + assert request.quantiles is None + + def test_custom_values(self): + """Test custom parameter values.""" + data = np.random.rand(32, 100, 1) + request = Chronos2ForecastRequest( + x=data, + horizon=24, + model_version="2.0", + compression="lz4", + output_type="quantiles", + quantiles=[0.1, 0.5, 0.9], + ) + assert request.horizon == 24 + assert request.model_version == "2.0" + assert request.compression == "lz4" + assert request.output_type == "quantiles" + assert request.quantiles == [0.1, 0.5, 0.9] + + def test_quantiles_validation_requires_range_0_to_1(self): + """Quantiles must be in [0.0, 1.0].""" + with pytest.raises(ValueError, match="quantiles must be in"): + Chronos2ForecastRequest( + x=np.array([[1.0, 2.0]]), + horizon=10, + quantiles=[0.1, 0.5, 1.5], # 1.5 is invalid + ) + + def test_quantiles_validation_negative_values(self): + """Quantiles cannot be negative.""" + with pytest.raises(ValueError, match="quantiles must be in"): + Chronos2ForecastRequest( + x=np.array([[1.0, 2.0]]), + horizon=10, + quantiles=[-0.1, 0.5, 0.9], + ) + + def test_to_arrays_and_metadata(self): + """Test conversion to Arrow format.""" + data = np.random.rand(32, 100, 1) + request = Chronos2ForecastRequest( + x=data, + horizon=24, + output_type="quantiles", + quantiles=[0.1, 0.5, 0.9], + ) + arrays, metadata = request.to_arrays_and_metadata() + + # Check arrays + assert "x" in arrays + assert np.array_equal(arrays["x"], data) + + # Check metadata + assert metadata["horizon"] == 24 + assert metadata["output_type"] == "quantiles" + assert metadata["quantiles"] == [0.1, 0.5, 0.9] + + def test_to_arrays_and_metadata_without_quantiles(self): + """Test conversion when quantiles not specified.""" + data = np.array([[1.0, 2.0]]) + request = Chronos2ForecastRequest( + x=data, + horizon=10, + output_type="point", + ) + arrays, metadata = request.to_arrays_and_metadata() + + assert metadata["output_type"] == "point" + assert "quantiles" not in metadata + + +class TestTiRexForecastRequest: + """Tests for TiRexForecastRequest model.""" + + def test_model_name_is_tirex(self): + """Model name should be TIREX.""" + request = TiRexForecastRequest( + x=np.array([[1.0, 2.0]]), + horizon=10, + ) + assert request.model_name == ModelName.TIREX + + def test_default_values(self): + """Test default parameter values.""" + request = TiRexForecastRequest( + x=np.array([[1.0, 2.0]]), + horizon=10, + ) + assert request.model_version == "1" + assert request.compression == "zstd" + assert request.output_type == "point" + + def test_custom_output_type(self): + """Test custom output type.""" + request = TiRexForecastRequest( + x=np.array([[1.0, 2.0]]), + horizon=10, + output_type="quantiles", + ) + assert request.output_type == "quantiles" + + def test_to_arrays_and_metadata(self): + """Test conversion to Arrow format.""" + data = np.random.rand(10, 50, 2) + request = TiRexForecastRequest( + x=data, + horizon=12, + output_type="samples", + ) + arrays, metadata = request.to_arrays_and_metadata() + + assert "x" in arrays + assert np.array_equal(arrays["x"], data) + assert metadata["horizon"] == 12 + assert metadata["output_type"] == "samples" + + +class TestFlowStateForecastRequest: + """Tests for FlowStateForecastRequest model.""" + + def test_model_name_is_flowstate(self): + """Model name should be FLOWSTATE.""" + request = FlowStateForecastRequest( + x=np.array([[1.0, 2.0]]), + horizon=10, + ) + assert request.model_name == ModelName.FLOWSTATE + + def test_default_values(self): + """Test default parameter values.""" + request = FlowStateForecastRequest( + x=np.array([[1.0, 2.0]]), + horizon=10, + ) + assert request.model_version == "1" + assert request.compression == "zstd" + assert request.output_type == "point" + assert request.scale_factor is None + assert request.prediction_type is None + + def test_custom_scale_factor(self): + """Test custom scale factor.""" + request = FlowStateForecastRequest( + x=np.array([[1.0, 2.0]]), + horizon=10, + scale_factor=100.0, + ) + assert request.scale_factor == 100.0 + + def test_scale_factor_validation_positive(self): + """Scale factor must be positive.""" + with pytest.raises(ValueError, match="scale_factor must be positive"): + FlowStateForecastRequest( + x=np.array([[1.0, 2.0]]), + horizon=10, + scale_factor=0.0, + ) + + def test_scale_factor_validation_negative(self): + """Scale factor cannot be negative.""" + with pytest.raises(ValueError, match="scale_factor must be positive"): + FlowStateForecastRequest( + x=np.array([[1.0, 2.0]]), + horizon=10, + scale_factor=-1.0, + ) + + def test_prediction_type_mean_with_point_output(self): + """prediction_type='mean' requires output_type='point'.""" + request = FlowStateForecastRequest( + x=np.array([[1.0, 2.0]]), + horizon=10, + output_type="point", + prediction_type="mean", + ) + assert request.prediction_type == "mean" + assert request.output_type == "point" + + def test_prediction_type_median_with_point_output(self): + """prediction_type='median' requires output_type='point'.""" + request = FlowStateForecastRequest( + x=np.array([[1.0, 2.0]]), + horizon=10, + output_type="point", + prediction_type="median", + ) + assert request.prediction_type == "median" + + def test_prediction_type_quantile_with_quantiles_output(self): + """prediction_type='quantile' requires output_type='quantiles'.""" + request = FlowStateForecastRequest( + x=np.array([[1.0, 2.0]]), + horizon=10, + output_type="quantiles", + prediction_type="quantile", + ) + assert request.prediction_type == "quantile" + assert request.output_type == "quantiles" + + def test_validation_mean_requires_point_output(self): + """prediction_type='mean' incompatible with output_type='quantiles'.""" + with pytest.raises(ValueError, match="prediction_type='mean' requires output_type='point'"): + FlowStateForecastRequest( + x=np.array([[1.0, 2.0]]), + horizon=10, + output_type="quantiles", + prediction_type="mean", + ) + + def test_validation_median_requires_point_output(self): + """prediction_type='median' incompatible with output_type='quantiles'.""" + with pytest.raises(ValueError, match="prediction_type='median' requires output_type='point'"): + FlowStateForecastRequest( + x=np.array([[1.0, 2.0]]), + horizon=10, + output_type="quantiles", + prediction_type="median", + ) + + def test_validation_quantile_requires_quantiles_output(self): + """prediction_type='quantile' requires output_type='quantiles'.""" + with pytest.raises(ValueError, match="prediction_type='quantile' requires output_type='quantiles'"): + FlowStateForecastRequest( + x=np.array([[1.0, 2.0]]), + horizon=10, + output_type="point", + prediction_type="quantile", + ) + + def test_validation_quantiles_output_requires_quantile_prediction(self): + """output_type='quantiles' requires prediction_type='quantile'.""" + with pytest.raises(ValueError, match="output_type='quantiles' requires prediction_type='quantile'"): + FlowStateForecastRequest( + x=np.array([[1.0, 2.0]]), + horizon=10, + output_type="quantiles", + prediction_type="mean", + ) + + def test_validation_quantiles_output_requires_prediction_type(self): + """output_type='quantiles' requires prediction_type to be set.""" + with pytest.raises(ValueError, match="output_type='quantiles' requires prediction_type='quantile'"): + FlowStateForecastRequest( + x=np.array([[1.0, 2.0]]), + horizon=10, + output_type="quantiles", + ) + + def test_to_arrays_and_metadata_with_all_params(self): + """Test conversion with all FlowState parameters.""" + data = np.random.rand(16, 80, 1) + request = FlowStateForecastRequest( + x=data, + horizon=20, + scale_factor=50.0, + prediction_type="mean", + output_type="point", + ) + arrays, metadata = request.to_arrays_and_metadata() + + assert "x" in arrays + assert np.array_equal(arrays["x"], data) + assert metadata["horizon"] == 20 + assert metadata["output_type"] == "point" + assert metadata["scale_factor"] == 50.0 + assert metadata["prediction_type"] == "mean" + + def test_to_arrays_and_metadata_without_optional_params(self): + """Test conversion without optional FlowState parameters.""" + data = np.array([[1.0, 2.0]]) + request = FlowStateForecastRequest( + x=data, + horizon=10, + ) + arrays, metadata = request.to_arrays_and_metadata() + + assert metadata["output_type"] == "point" + assert "scale_factor" not in metadata + assert "prediction_type" not in metadata + + +class TestForecastResponse: + """Tests for ForecastResponse model.""" + + def test_from_arrays_point_only(self): + """Test creating response with point predictions only.""" + point_data = np.random.rand(32, 24, 1) + arrays = {"point": point_data} + metadata = {"model_name": "chronos2", "model_version": "1.0"} + + response = ForecastResponse.from_arrays_and_metadata(arrays, metadata) + + assert response.point is not None + assert np.array_equal(response.point, point_data) + assert response.quantiles is None + assert response.samples is None + assert response.metadata == metadata + + def test_from_arrays_quantiles_only(self): + """Test creating response with quantile predictions only.""" + quantiles_data = np.random.rand(32, 24, 3) + arrays = {"quantiles": quantiles_data} + metadata = {"model_name": "chronos2", "quantiles": [0.1, 0.5, 0.9]} + + response = ForecastResponse.from_arrays_and_metadata(arrays, metadata) + + assert response.point is None + assert response.quantiles is not None + assert np.array_equal(response.quantiles, quantiles_data) + assert response.samples is None + + def test_from_arrays_samples_only(self): + """Test creating response with sample predictions only.""" + samples_data = np.random.rand(32, 24, 100) + arrays = {"samples": samples_data} + metadata = {"model_name": "tirex"} + + response = ForecastResponse.from_arrays_and_metadata(arrays, metadata) + + assert response.point is None + assert response.quantiles is None + assert response.samples is not None + assert np.array_equal(response.samples, samples_data) + + def test_from_arrays_multiple_outputs(self): + """Test creating response with multiple output types.""" + point_data = np.random.rand(32, 24, 1) + quantiles_data = np.random.rand(32, 24, 3) + arrays = {"point": point_data, "quantiles": quantiles_data} + metadata = {"model_name": "flowstate"} + + response = ForecastResponse.from_arrays_and_metadata(arrays, metadata) + + assert response.point is not None + assert response.quantiles is not None + assert response.samples is None + + def test_from_arrays_validation_requires_output(self): + """Test that at least one output array is required.""" + arrays = {} # No output arrays + metadata = {"model_name": "chronos2"} + + with pytest.raises(ValueError, match="Response missing output arrays"): + ForecastResponse.from_arrays_and_metadata(arrays, metadata) + + def test_from_arrays_ignores_non_output_arrays(self): + """Test that non-output arrays in dict are ignored.""" + point_data = np.random.rand(32, 24, 1) + arrays = {"point": point_data, "x": np.random.rand(32, 100, 1)} + metadata = {} + + response = ForecastResponse.from_arrays_and_metadata(arrays, metadata) + assert response.point is not None + # x is not stored in response + + def test_repr_with_point(self): + """Test string representation with point predictions.""" + response = ForecastResponse( + point=np.zeros((32, 24, 1)), + metadata={"model_name": "chronos2"}, + ) + repr_str = repr(response) + + assert "ForecastResponse" in repr_str + assert "point.shape=(32, 24, 1)" in repr_str + assert "metadata=" in repr_str + + def test_repr_with_multiple_outputs(self): + """Test string representation with multiple outputs.""" + response = ForecastResponse( + point=np.zeros((32, 24, 1)), + quantiles=np.zeros((32, 24, 3)), + samples=np.zeros((32, 24, 100)), + metadata={}, + ) + repr_str = repr(response) + + assert "point.shape=(32, 24, 1)" in repr_str + assert "quantiles.shape=(32, 24, 3)" in repr_str + assert "samples.shape=(32, 24, 100)" in repr_str + + def test_repr_with_no_outputs(self): + """Test string representation with no outputs.""" + response = ForecastResponse(metadata={}) + repr_str = repr(response) + + assert "ForecastResponse" in repr_str + assert "outputs=[None]" in repr_str + + def test_default_factory_metadata(self): + """Test that metadata defaults to empty dict.""" + response = ForecastResponse(point=np.zeros((1, 1, 1))) + assert response.metadata == {} + assert isinstance(response.metadata, dict) diff --git a/tests/unit/test_utils.py b/tests/unit/test_utils.py new file mode 100644 index 0000000..bea7fce --- /dev/null +++ b/tests/unit/test_utils.py @@ -0,0 +1,456 @@ +"""Unit tests for faim_sdk.utils module. + +Tests Arrow serialization and deserialization utilities. +""" + +import numpy as np +import pytest + +from faim_sdk.utils import deserialize_from_arrow, serialize_to_arrow + + +class TestSerializeToArrow: + """Tests for serialize_to_arrow function.""" + + def test_serialize_single_array(self): + """Test serializing a single numpy array.""" + arrays = {"x": np.array([[1.0, 2.0], [3.0, 4.0]])} + result = serialize_to_arrow(arrays) + + assert isinstance(result, bytes) + assert len(result) > 0 + + def test_serialize_multiple_arrays(self): + """Test serializing multiple numpy arrays.""" + arrays = { + "x": np.array([[1.0, 2.0]]), + "y": np.array([[3.0, 4.0]]), + "z": np.array([[5.0, 6.0]]), + } + result = serialize_to_arrow(arrays) + + assert isinstance(result, bytes) + assert len(result) > 0 + + def test_serialize_with_metadata(self): + """Test serializing with metadata.""" + arrays = {"x": np.array([[1.0, 2.0]])} + metadata = {"horizon": 10, "model": "chronos2"} + result = serialize_to_arrow(arrays, metadata) + + assert isinstance(result, bytes) + assert len(result) > 0 + + def test_serialize_with_compression_zstd(self): + """Test serializing with zstd compression.""" + arrays = {"x": np.random.rand(100, 100)} + result = serialize_to_arrow(arrays, compression="zstd") + + assert isinstance(result, bytes) + assert len(result) > 0 + + def test_serialize_with_compression_lz4(self): + """Test serializing with lz4 compression.""" + arrays = {"x": np.random.rand(100, 100)} + result = serialize_to_arrow(arrays, compression="lz4") + + assert isinstance(result, bytes) + assert len(result) > 0 + + def test_serialize_without_compression(self): + """Test serializing without compression.""" + arrays = {"x": np.array([[1.0, 2.0]])} + result = serialize_to_arrow(arrays, compression=None) + + assert isinstance(result, bytes) + assert len(result) > 0 + + def test_serialize_different_dtypes(self): + """Test serializing arrays with different dtypes.""" + arrays = { + "float32": np.array([[1.0, 2.0]], dtype=np.float32), + "float64": np.array([[3.0, 4.0]], dtype=np.float64), + "int32": np.array([[5, 6]], dtype=np.int32), + "int64": np.array([[7, 8]], dtype=np.int64), + } + result = serialize_to_arrow(arrays) + + assert isinstance(result, bytes) + + def test_serialize_different_shapes(self): + """Test serializing arrays with different shapes.""" + arrays = { + "scalar": np.array([1.0]), + "1d": np.array([1.0, 2.0, 3.0]), + "2d": np.array([[1.0, 2.0], [3.0, 4.0]]), + "3d": np.array([[[1.0, 2.0]], [[3.0, 4.0]]]), + } + result = serialize_to_arrow(arrays) + + assert isinstance(result, bytes) + + def test_serialize_large_array(self): + """Test serializing large arrays.""" + arrays = {"large": np.random.rand(1000, 100, 10)} + result = serialize_to_arrow(arrays) + + assert isinstance(result, bytes) + assert len(result) > 0 + + def test_serialize_empty_metadata(self): + """Test serializing with empty metadata dict.""" + arrays = {"x": np.array([[1.0]])} + result = serialize_to_arrow(arrays, metadata={}) + + assert isinstance(result, bytes) + + def test_serialize_none_metadata(self): + """Test serializing with None metadata.""" + arrays = {"x": np.array([[1.0]])} + result = serialize_to_arrow(arrays, metadata=None) + + assert isinstance(result, bytes) + + def test_serialize_complex_metadata(self): + """Test serializing with complex nested metadata.""" + arrays = {"x": np.array([[1.0]])} + metadata = { + "horizon": 10, + "quantiles": [0.1, 0.5, 0.9], + "config": {"model": "chronos2", "version": "1.0"}, + } + result = serialize_to_arrow(arrays, metadata) + + assert isinstance(result, bytes) + + def test_serialize_skips_none_arrays(self): + """Test that None values in arrays dict are skipped.""" + arrays = {"x": np.array([[1.0]]), "y": None, "z": np.array([[2.0]])} + result = serialize_to_arrow(arrays) + + # Should succeed without error + assert isinstance(result, bytes) + + def test_serialize_validation_requires_numpy_array(self): + """Test that non-numpy arrays raise TypeError.""" + arrays = {"x": [[1.0, 2.0], [3.0, 4.0]]} # Python list + + with pytest.raises(TypeError, match='Array "x" must be numpy.ndarray'): + serialize_to_arrow(arrays) + + def test_serialize_validation_rejects_list(self): + """Test that lists raise TypeError.""" + arrays = {"data": [1, 2, 3, 4, 5]} + + with pytest.raises(TypeError, match="must be numpy.ndarray"): + serialize_to_arrow(arrays) + + def test_serialize_non_native_endianness(self): + """Test handling of non-native endianness arrays.""" + # Create array with non-native byte order + arr = np.array([[1.0, 2.0]], dtype=">f8") # Big-endian + arrays = {"x": arr} + + # Should handle conversion automatically + result = serialize_to_arrow(arrays) + assert isinstance(result, bytes) + + def test_serialize_non_contiguous_array(self): + """Test handling of non-contiguous arrays.""" + # Create non-contiguous array via transpose + arr = np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]).T + assert not arr.flags.c_contiguous + + arrays = {"x": arr} + result = serialize_to_arrow(arrays) + + assert isinstance(result, bytes) + + def test_serialize_deterministic_order(self): + """Test that serialization produces deterministic ordering.""" + arrays1 = {"z": np.array([3.0]), "a": np.array([1.0]), "m": np.array([2.0])} + arrays2 = {"a": np.array([1.0]), "m": np.array([2.0]), "z": np.array([3.0])} + + result1 = serialize_to_arrow(arrays1, compression=None) + result2 = serialize_to_arrow(arrays2, compression=None) + + # Should produce identical bytes due to sorted keys + assert result1 == result2 + + +class TestDeserializeFromArrow: + """Tests for deserialize_from_arrow function.""" + + def test_deserialize_single_array(self): + """Test deserializing a single array.""" + original = {"x": np.array([[1.0, 2.0], [3.0, 4.0]])} + serialized = serialize_to_arrow(original) + + arrays, metadata = deserialize_from_arrow(serialized) + + assert "x" in arrays + assert np.array_equal(arrays["x"], original["x"]) + + def test_deserialize_multiple_arrays(self): + """Test deserializing multiple arrays.""" + original = { + "x": np.array([[1.0, 2.0]]), + "y": np.array([[3.0, 4.0]]), + "z": np.array([[5.0, 6.0]]), + } + serialized = serialize_to_arrow(original) + + arrays, metadata = deserialize_from_arrow(serialized) + + assert set(arrays.keys()) == {"x", "y", "z"} + assert np.array_equal(arrays["x"], original["x"]) + assert np.array_equal(arrays["y"], original["y"]) + assert np.array_equal(arrays["z"], original["z"]) + + def test_deserialize_with_metadata(self): + """Test deserializing with metadata.""" + original_arrays = {"x": np.array([[1.0]])} + original_metadata = {"horizon": 10, "model": "chronos2"} + serialized = serialize_to_arrow(original_arrays, original_metadata) + + arrays, metadata = deserialize_from_arrow(serialized) + + assert metadata == original_metadata + assert metadata["horizon"] == 10 + assert metadata["model"] == "chronos2" + + def test_deserialize_preserves_dtype(self): + """Test that deserialization preserves dtypes.""" + original = { + "float32": np.array([[1.0, 2.0]], dtype=np.float32), + "float64": np.array([[3.0, 4.0]], dtype=np.float64), + "int32": np.array([[5, 6]], dtype=np.int32), + "int64": np.array([[7, 8]], dtype=np.int64), + } + serialized = serialize_to_arrow(original) + + arrays, _ = deserialize_from_arrow(serialized) + + assert arrays["float32"].dtype == np.float32 + assert arrays["float64"].dtype == np.float64 + assert arrays["int32"].dtype == np.int32 + assert arrays["int64"].dtype == np.int64 + + def test_deserialize_preserves_shape(self): + """Test that deserialization preserves shapes.""" + original = { + "scalar": np.array([1.0]), + "1d": np.array([1.0, 2.0, 3.0]), + "2d": np.array([[1.0, 2.0], [3.0, 4.0]]), + "3d": np.array([[[1.0, 2.0]], [[3.0, 4.0]]]), + } + serialized = serialize_to_arrow(original) + + arrays, _ = deserialize_from_arrow(serialized) + + assert arrays["scalar"].shape == (1,) + assert arrays["1d"].shape == (3,) + assert arrays["2d"].shape == (2, 2) + assert arrays["3d"].shape == (2, 1, 2) + + def test_deserialize_large_array(self): + """Test deserializing large arrays.""" + original = {"large": np.random.rand(1000, 100, 10)} + serialized = serialize_to_arrow(original) + + arrays, _ = deserialize_from_arrow(serialized) + + assert "large" in arrays + assert arrays["large"].shape == (1000, 100, 10) + assert np.array_equal(arrays["large"], original["large"]) + + def test_deserialize_empty_metadata(self): + """Test deserializing with empty metadata.""" + original = {"x": np.array([[1.0]])} + serialized = serialize_to_arrow(original, metadata={}) + + arrays, metadata = deserialize_from_arrow(serialized) + + assert metadata == {} + + def test_deserialize_none_metadata(self): + """Test deserializing with None metadata.""" + original = {"x": np.array([[1.0]])} + serialized = serialize_to_arrow(original, metadata=None) + + arrays, metadata = deserialize_from_arrow(serialized) + + assert metadata == {} + + def test_deserialize_complex_metadata(self): + """Test deserializing with complex nested metadata.""" + original_metadata = { + "horizon": 10, + "quantiles": [0.1, 0.5, 0.9], + "config": {"model": "chronos2", "version": "1.0"}, + } + original_arrays = {"x": np.array([[1.0]])} + serialized = serialize_to_arrow(original_arrays, original_metadata) + + arrays, metadata = deserialize_from_arrow(serialized) + + assert metadata == original_metadata + assert metadata["quantiles"] == [0.1, 0.5, 0.9] + assert metadata["config"]["model"] == "chronos2" + + +class TestRoundTrip: + """Tests for serialize -> deserialize round-trip consistency.""" + + def test_roundtrip_simple_array(self): + """Test round-trip for simple array.""" + original = {"x": np.array([[1.0, 2.0], [3.0, 4.0]])} + serialized = serialize_to_arrow(original) + arrays, _ = deserialize_from_arrow(serialized) + + assert np.array_equal(arrays["x"], original["x"]) + + def test_roundtrip_with_metadata(self): + """Test round-trip preserves metadata.""" + original_arrays = {"x": np.array([[1.0]])} + original_metadata = {"horizon": 24, "output_type": "quantiles"} + + serialized = serialize_to_arrow(original_arrays, original_metadata) + arrays, metadata = deserialize_from_arrow(serialized) + + assert metadata == original_metadata + + def test_roundtrip_multiple_arrays(self): + """Test round-trip for multiple arrays.""" + original = { + "x": np.random.rand(32, 100, 1), + "point": np.random.rand(32, 24, 1), + "quantiles": np.random.rand(32, 24, 3), + } + serialized = serialize_to_arrow(original) + arrays, _ = deserialize_from_arrow(serialized) + + for key in original: + assert key in arrays + assert np.array_equal(arrays[key], original[key]) + assert arrays[key].shape == original[key].shape + assert arrays[key].dtype == original[key].dtype + + def test_roundtrip_with_zstd_compression(self): + """Test round-trip with zstd compression.""" + original = {"x": np.random.rand(100, 50)} + serialized = serialize_to_arrow(original, compression="zstd") + arrays, _ = deserialize_from_arrow(serialized) + + assert np.allclose(arrays["x"], original["x"]) + + def test_roundtrip_with_lz4_compression(self): + """Test round-trip with lz4 compression.""" + original = {"x": np.random.rand(100, 50)} + serialized = serialize_to_arrow(original, compression="lz4") + arrays, _ = deserialize_from_arrow(serialized) + + assert np.allclose(arrays["x"], original["x"]) + + def test_roundtrip_different_dtypes(self): + """Test round-trip preserves all dtypes.""" + original = { + "float32": np.array([1.5, 2.5], dtype=np.float32), + "float64": np.array([3.5, 4.5], dtype=np.float64), + "int32": np.array([5, 6], dtype=np.int32), + "int64": np.array([7, 8], dtype=np.int64), + } + serialized = serialize_to_arrow(original, compression=None) + arrays, _ = deserialize_from_arrow(serialized) + + for key in original: + assert arrays[key].dtype == original[key].dtype + assert np.array_equal(arrays[key], original[key]) + + def test_roundtrip_different_shapes(self): + """Test round-trip preserves all shapes.""" + original = { + "1d": np.array([1.0, 2.0, 3.0]), + "2d": np.array([[1.0, 2.0], [3.0, 4.0]]), + "3d": np.random.rand(4, 5, 6), + "4d": np.random.rand(2, 3, 4, 5), + } + serialized = serialize_to_arrow(original) + arrays, _ = deserialize_from_arrow(serialized) + + for key in original: + assert arrays[key].shape == original[key].shape + assert np.allclose(arrays[key], original[key]) + + def test_roundtrip_exact_values(self): + """Test round-trip preserves exact floating point values.""" + original = {"data": np.array([1.23456789, 9.87654321, -0.123456, 0.0])} + serialized = serialize_to_arrow(original, compression=None) + arrays, _ = deserialize_from_arrow(serialized) + + # Should be exactly equal (no floating point error) + assert np.array_equal(arrays["data"], original["data"]) + + def test_roundtrip_negative_values(self): + """Test round-trip with negative values.""" + original = {"data": np.array([[-1.0, -2.0], [-3.0, -4.0]])} + serialized = serialize_to_arrow(original) + arrays, _ = deserialize_from_arrow(serialized) + + assert np.array_equal(arrays["data"], original["data"]) + + def test_roundtrip_zero_values(self): + """Test round-trip with zero values.""" + original = {"data": np.zeros((10, 10))} + serialized = serialize_to_arrow(original) + arrays, _ = deserialize_from_arrow(serialized) + + assert np.array_equal(arrays["data"], original["data"]) + + def test_roundtrip_special_floats(self): + """Test round-trip with special float values.""" + original = {"data": np.array([np.inf, -np.inf, 0.0, -0.0, 1e-300, 1e300])} + serialized = serialize_to_arrow(original) + arrays, _ = deserialize_from_arrow(serialized) + + assert np.array_equal(arrays["data"], original["data"]) + + def test_roundtrip_realistic_forecast_request(self): + """Test round-trip for realistic forecast request data.""" + original_arrays = { + "x": np.random.randn(32, 100, 1).astype(np.float32), + } + original_metadata = { + "horizon": 24, + "model_version": "1.0", + "output_type": "quantiles", + "quantiles": [0.1, 0.5, 0.9], + } + + serialized = serialize_to_arrow(original_arrays, original_metadata, compression="zstd") + arrays, metadata = deserialize_from_arrow(serialized) + + assert np.allclose(arrays["x"], original_arrays["x"]) + assert arrays["x"].shape == (32, 100, 1) + assert arrays["x"].dtype == np.float32 + assert metadata == original_metadata + + def test_roundtrip_realistic_forecast_response(self): + """Test round-trip for realistic forecast response data.""" + original_arrays = { + "point": np.random.randn(32, 24, 1).astype(np.float32), + "quantiles": np.random.randn(32, 24, 3).astype(np.float32), + } + original_metadata = { + "model_name": "chronos2", + "model_version": "1.0", + "inference_time_ms": 123, + } + + serialized = serialize_to_arrow(original_arrays, original_metadata, compression="zstd") + arrays, metadata = deserialize_from_arrow(serialized) + + assert set(arrays.keys()) == {"point", "quantiles"} + assert np.allclose(arrays["point"], original_arrays["point"]) + assert np.allclose(arrays["quantiles"], original_arrays["quantiles"]) + assert metadata == original_metadata diff --git a/uv.lock b/uv.lock deleted file mode 100644 index 313db96..0000000 --- a/uv.lock +++ /dev/null @@ -1,2059 +0,0 @@ -version = 1 -revision = 3 -requires-python = ">=3.12" -resolution-markers = [ - "python_full_version >= '3.14'", - "python_full_version < '3.14'", -] - -[manifest] - -[manifest.dependency-groups] -dev = [ - { name = "jupyterlab", specifier = ">=4.4.10" }, - { name = "matplotlib", specifier = ">=3.10.7" }, - { name = "pandas", specifier = ">=2.3.3" }, - { name = "pyarrow", specifier = ">=22.0.0" }, - { name = "statsmodels", specifier = ">=0.14.5" }, -] - -[[package]] -name = "anyio" -version = "4.11.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "idna" }, - { name = "sniffio" }, - { name = "typing-extensions", marker = "python_full_version < '3.13'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/c6/78/7d432127c41b50bccba979505f272c16cbcadcc33645d5fa3a738110ae75/anyio-4.11.0.tar.gz", hash = "sha256:82a8d0b81e318cc5ce71a5f1f8b5c4e63619620b63141ef8c995fa0db95a57c4", size = 219094, upload-time = "2025-09-23T09:19:12.58Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/15/b3/9b1a8074496371342ec1e796a96f99c82c945a339cd81a8e73de28b4cf9e/anyio-4.11.0-py3-none-any.whl", hash = "sha256:0287e96f4d26d4149305414d4e3bc32f0dcd0862365a4bddea19d7a1ec38c4fc", size = 109097, upload-time = "2025-09-23T09:19:10.601Z" }, -] - -[[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 = "argon2-cffi" -version = "25.1.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "argon2-cffi-bindings" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/0e/89/ce5af8a7d472a67cc819d5d998aa8c82c5d860608c4db9f46f1162d7dab9/argon2_cffi-25.1.0.tar.gz", hash = "sha256:694ae5cc8a42f4c4e2bf2ca0e64e51e23a040c6a517a85074683d3959e1346c1", size = 45706, upload-time = "2025-06-03T06:55:32.073Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/4f/d3/a8b22fa575b297cd6e3e3b0155c7e25db170edf1c74783d6a31a2490b8d9/argon2_cffi-25.1.0-py3-none-any.whl", hash = "sha256:fdc8b074db390fccb6eb4a3604ae7231f219aa669a2652e0f20e16ba513d5741", size = 14657, upload-time = "2025-06-03T06:55:30.804Z" }, -] - -[[package]] -name = "argon2-cffi-bindings" -version = "25.1.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "cffi" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/5c/2d/db8af0df73c1cf454f71b2bbe5e356b8c1f8041c979f505b3d3186e520a9/argon2_cffi_bindings-25.1.0.tar.gz", hash = "sha256:b957f3e6ea4d55d820e40ff76f450952807013d361a65d7f28acc0acbf29229d", size = 1783441, upload-time = "2025-07-30T10:02:05.147Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/60/97/3c0a35f46e52108d4707c44b95cfe2afcafc50800b5450c197454569b776/argon2_cffi_bindings-25.1.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:3d3f05610594151994ca9ccb3c771115bdb4daef161976a266f0dd8aa9996b8f", size = 54393, upload-time = "2025-07-30T10:01:40.97Z" }, - { url = "https://files.pythonhosted.org/packages/9d/f4/98bbd6ee89febd4f212696f13c03ca302b8552e7dbf9c8efa11ea4a388c3/argon2_cffi_bindings-25.1.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:8b8efee945193e667a396cbc7b4fb7d357297d6234d30a489905d96caabde56b", size = 29328, upload-time = "2025-07-30T10:01:41.916Z" }, - { url = "https://files.pythonhosted.org/packages/43/24/90a01c0ef12ac91a6be05969f29944643bc1e5e461155ae6559befa8f00b/argon2_cffi_bindings-25.1.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:3c6702abc36bf3ccba3f802b799505def420a1b7039862014a65db3205967f5a", size = 31269, upload-time = "2025-07-30T10:01:42.716Z" }, - { url = "https://files.pythonhosted.org/packages/d4/d3/942aa10782b2697eee7af5e12eeff5ebb325ccfb86dd8abda54174e377e4/argon2_cffi_bindings-25.1.0-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a1c70058c6ab1e352304ac7e3b52554daadacd8d453c1752e547c76e9c99ac44", size = 86558, upload-time = "2025-07-30T10:01:43.943Z" }, - { url = "https://files.pythonhosted.org/packages/0d/82/b484f702fec5536e71836fc2dbc8c5267b3f6e78d2d539b4eaa6f0db8bf8/argon2_cffi_bindings-25.1.0-cp314-cp314t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e2fd3bfbff3c5d74fef31a722f729bf93500910db650c925c2d6ef879a7e51cb", size = 92364, upload-time = "2025-07-30T10:01:44.887Z" }, - { url = "https://files.pythonhosted.org/packages/c9/c1/a606ff83b3f1735f3759ad0f2cd9e038a0ad11a3de3b6c673aa41c24bb7b/argon2_cffi_bindings-25.1.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c4f9665de60b1b0e99bcd6be4f17d90339698ce954cfd8d9cf4f91c995165a92", size = 85637, upload-time = "2025-07-30T10:01:46.225Z" }, - { url = "https://files.pythonhosted.org/packages/44/b4/678503f12aceb0262f84fa201f6027ed77d71c5019ae03b399b97caa2f19/argon2_cffi_bindings-25.1.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ba92837e4a9aa6a508c8d2d7883ed5a8f6c308c89a4790e1e447a220deb79a85", size = 91934, upload-time = "2025-07-30T10:01:47.203Z" }, - { url = "https://files.pythonhosted.org/packages/f0/c7/f36bd08ef9bd9f0a9cff9428406651f5937ce27b6c5b07b92d41f91ae541/argon2_cffi_bindings-25.1.0-cp314-cp314t-win32.whl", hash = "sha256:84a461d4d84ae1295871329b346a97f68eade8c53b6ed9a7ca2d7467f3c8ff6f", size = 28158, upload-time = "2025-07-30T10:01:48.341Z" }, - { url = "https://files.pythonhosted.org/packages/b3/80/0106a7448abb24a2c467bf7d527fe5413b7fdfa4ad6d6a96a43a62ef3988/argon2_cffi_bindings-25.1.0-cp314-cp314t-win_amd64.whl", hash = "sha256:b55aec3565b65f56455eebc9b9f34130440404f27fe21c3b375bf1ea4d8fbae6", size = 32597, upload-time = "2025-07-30T10:01:49.112Z" }, - { url = "https://files.pythonhosted.org/packages/05/b8/d663c9caea07e9180b2cb662772865230715cbd573ba3b5e81793d580316/argon2_cffi_bindings-25.1.0-cp314-cp314t-win_arm64.whl", hash = "sha256:87c33a52407e4c41f3b70a9c2d3f6056d88b10dad7695be708c5021673f55623", size = 28231, upload-time = "2025-07-30T10:01:49.92Z" }, - { url = "https://files.pythonhosted.org/packages/1d/57/96b8b9f93166147826da5f90376e784a10582dd39a393c99bb62cfcf52f0/argon2_cffi_bindings-25.1.0-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:aecba1723ae35330a008418a91ea6cfcedf6d31e5fbaa056a166462ff066d500", size = 54121, upload-time = "2025-07-30T10:01:50.815Z" }, - { url = "https://files.pythonhosted.org/packages/0a/08/a9bebdb2e0e602dde230bdde8021b29f71f7841bd54801bcfd514acb5dcf/argon2_cffi_bindings-25.1.0-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:2630b6240b495dfab90aebe159ff784d08ea999aa4b0d17efa734055a07d2f44", size = 29177, upload-time = "2025-07-30T10:01:51.681Z" }, - { url = "https://files.pythonhosted.org/packages/b6/02/d297943bcacf05e4f2a94ab6f462831dc20158614e5d067c35d4e63b9acb/argon2_cffi_bindings-25.1.0-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:7aef0c91e2c0fbca6fc68e7555aa60ef7008a739cbe045541e438373bc54d2b0", size = 31090, upload-time = "2025-07-30T10:01:53.184Z" }, - { url = "https://files.pythonhosted.org/packages/c1/93/44365f3d75053e53893ec6d733e4a5e3147502663554b4d864587c7828a7/argon2_cffi_bindings-25.1.0-cp39-abi3-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1e021e87faa76ae0d413b619fe2b65ab9a037f24c60a1e6cc43457ae20de6dc6", size = 81246, upload-time = "2025-07-30T10:01:54.145Z" }, - { url = "https://files.pythonhosted.org/packages/09/52/94108adfdd6e2ddf58be64f959a0b9c7d4ef2fa71086c38356d22dc501ea/argon2_cffi_bindings-25.1.0-cp39-abi3-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d3e924cfc503018a714f94a49a149fdc0b644eaead5d1f089330399134fa028a", size = 87126, upload-time = "2025-07-30T10:01:55.074Z" }, - { url = "https://files.pythonhosted.org/packages/72/70/7a2993a12b0ffa2a9271259b79cc616e2389ed1a4d93842fac5a1f923ffd/argon2_cffi_bindings-25.1.0-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:c87b72589133f0346a1cb8d5ecca4b933e3c9b64656c9d175270a000e73b288d", size = 80343, upload-time = "2025-07-30T10:01:56.007Z" }, - { url = "https://files.pythonhosted.org/packages/78/9a/4e5157d893ffc712b74dbd868c7f62365618266982b64accab26bab01edc/argon2_cffi_bindings-25.1.0-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:1db89609c06afa1a214a69a462ea741cf735b29a57530478c06eb81dd403de99", size = 86777, upload-time = "2025-07-30T10:01:56.943Z" }, - { url = "https://files.pythonhosted.org/packages/74/cd/15777dfde1c29d96de7f18edf4cc94c385646852e7c7b0320aa91ccca583/argon2_cffi_bindings-25.1.0-cp39-abi3-win32.whl", hash = "sha256:473bcb5f82924b1becbb637b63303ec8d10e84c8d241119419897a26116515d2", size = 27180, upload-time = "2025-07-30T10:01:57.759Z" }, - { url = "https://files.pythonhosted.org/packages/e2/c6/a759ece8f1829d1f162261226fbfd2c6832b3ff7657384045286d2afa384/argon2_cffi_bindings-25.1.0-cp39-abi3-win_amd64.whl", hash = "sha256:a98cd7d17e9f7ce244c0803cad3c23a7d379c301ba618a5fa76a67d116618b98", size = 31715, upload-time = "2025-07-30T10:01:58.56Z" }, - { url = "https://files.pythonhosted.org/packages/42/b9/f8d6fa329ab25128b7e98fd83a3cb34d9db5b059a9847eddb840a0af45dd/argon2_cffi_bindings-25.1.0-cp39-abi3-win_arm64.whl", hash = "sha256:b0fdbcf513833809c882823f98dc2f931cf659d9a1429616ac3adebb49f5db94", size = 27149, upload-time = "2025-07-30T10:01:59.329Z" }, -] - -[[package]] -name = "arrow" -version = "1.4.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "python-dateutil" }, - { name = "tzdata" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/b9/33/032cdc44182491aa708d06a68b62434140d8c50820a087fac7af37703357/arrow-1.4.0.tar.gz", hash = "sha256:ed0cc050e98001b8779e84d461b0098c4ac597e88704a655582b21d116e526d7", size = 152931, upload-time = "2025-10-18T17:46:46.761Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/ed/c9/d7977eaacb9df673210491da99e6a247e93df98c715fc43fd136ce1d3d33/arrow-1.4.0-py3-none-any.whl", hash = "sha256:749f0769958ebdc79c173ff0b0670d59051a535fa26e8eba02953dc19eb43205", size = 68797, upload-time = "2025-10-18T17:46:45.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 = "async-lru" -version = "2.0.5" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/b2/4d/71ec4d3939dc755264f680f6c2b4906423a304c3d18e96853f0a595dfe97/async_lru-2.0.5.tar.gz", hash = "sha256:481d52ccdd27275f42c43a928b4a50c3bfb2d67af4e78b170e3e0bb39c66e5bb", size = 10380, upload-time = "2025-03-16T17:25:36.919Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/03/49/d10027df9fce941cb8184e78a02857af36360d33e1721df81c5ed2179a1a/async_lru-2.0.5-py3-none-any.whl", hash = "sha256:ab95404d8d2605310d345932697371a5f40def0487c03d6d0ad9138de52c9943", size = 6069, upload-time = "2025-03-16T17:25:35.422Z" }, -] - -[[package]] -name = "attrs" -version = "25.4.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/6b/5c/685e6633917e101e5dcb62b9dd76946cbb57c26e133bae9e0cd36033c0a9/attrs-25.4.0.tar.gz", hash = "sha256:16d5969b87f0859ef33a48b35d55ac1be6e42ae49d5e853b597db70c35c57e11", size = 934251, upload-time = "2025-10-06T13:54:44.725Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/3a/2a/7cc015f5b9f5db42b7d48157e23356022889fc354a2813c15934b7cb5c0e/attrs-25.4.0-py3-none-any.whl", hash = "sha256:adcf7e2a1fb3b36ac48d97835bb6d8ade15b8dcce26aba8bf1d14847b57a3373", size = 67615, upload-time = "2025-10-06T13:54:43.17Z" }, -] - -[[package]] -name = "babel" -version = "2.17.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/7d/6b/d52e42361e1aa00709585ecc30b3f9684b3ab62530771402248b1b1d6240/babel-2.17.0.tar.gz", hash = "sha256:0c54cffb19f690cdcc52a3b50bcbf71e07a808d1c80d549f2459b9d2cf0afb9d", size = 9951852, upload-time = "2025-02-01T15:17:41.026Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/b7/b8/3fe70c75fe32afc4bb507f75563d39bc5642255d1d94f1f23604725780bf/babel-2.17.0-py3-none-any.whl", hash = "sha256:4d0b53093fdfb4b21c92b5213dba5a1b23885afa8383709427046b21c366e5f2", size = 10182537, upload-time = "2025-02-01T15:17:37.39Z" }, -] - -[[package]] -name = "beautifulsoup4" -version = "4.14.2" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "soupsieve" }, - { name = "typing-extensions" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/77/e9/df2358efd7659577435e2177bfa69cba6c33216681af51a707193dec162a/beautifulsoup4-4.14.2.tar.gz", hash = "sha256:2a98ab9f944a11acee9cc848508ec28d9228abfd522ef0fad6a02a72e0ded69e", size = 625822, upload-time = "2025-09-29T10:05:42.613Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/94/fe/3aed5d0be4d404d12d36ab97e2f1791424d9ca39c2f754a6285d59a3b01d/beautifulsoup4-4.14.2-py3-none-any.whl", hash = "sha256:5ef6fa3a8cbece8488d66985560f97ed091e22bbc4e9c2338508a9d5de6d4515", size = 106392, upload-time = "2025-09-29T10:05:43.771Z" }, -] - -[[package]] -name = "bleach" -version = "6.3.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "webencodings" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/07/18/3c8523962314be6bf4c8989c79ad9531c825210dd13a8669f6b84336e8bd/bleach-6.3.0.tar.gz", hash = "sha256:6f3b91b1c0a02bb9a78b5a454c92506aa0fdf197e1d5e114d2e00c6f64306d22", size = 203533, upload-time = "2025-10-27T17:57:39.211Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/cd/3a/577b549de0cc09d95f11087ee63c739bba856cd3952697eec4c4bb91350a/bleach-6.3.0-py3-none-any.whl", hash = "sha256:fe10ec77c93ddf3d13a73b035abaac7a9f5e436513864ccdad516693213c65d6", size = 164437, upload-time = "2025-10-27T17:57:37.538Z" }, -] - -[package.optional-dependencies] -css = [ - { name = "tinycss2" }, -] - -[[package]] -name = "certifi" -version = "2025.10.5" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/4c/5b/b6ce21586237c77ce67d01dc5507039d444b630dd76611bbca2d8e5dcd91/certifi-2025.10.5.tar.gz", hash = "sha256:47c09d31ccf2acf0be3f701ea53595ee7e0b8fa08801c6624be771df09ae7b43", size = 164519, upload-time = "2025-10-05T04:12:15.808Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/e4/37/af0d2ef3967ac0d6113837b44a4f0bfe1328c2b9763bd5b1744520e5cfed/certifi-2025.10.5-py3-none-any.whl", hash = "sha256:0f212c2744a9bb6de0c56639a6f68afe01ecd92d91f14ae897c4fe7bbeeef0de", size = 163286, upload-time = "2025-10-05T04:12:14.03Z" }, -] - -[[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 = "charset-normalizer" -version = "3.4.4" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/13/69/33ddede1939fdd074bce5434295f38fae7136463422fe4fd3e0e89b98062/charset_normalizer-3.4.4.tar.gz", hash = "sha256:94537985111c35f28720e43603b8e7b43a6ecfb2ce1d3058bbe955b73404e21a", size = 129418, upload-time = "2025-10-14T04:42:32.879Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/f3/85/1637cd4af66fa687396e757dec650f28025f2a2f5a5531a3208dc0ec43f2/charset_normalizer-3.4.4-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:0a98e6759f854bd25a58a73fa88833fba3b7c491169f86ce1180c948ab3fd394", size = 208425, upload-time = "2025-10-14T04:40:53.353Z" }, - { url = "https://files.pythonhosted.org/packages/9d/6a/04130023fef2a0d9c62d0bae2649b69f7b7d8d24ea5536feef50551029df/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b5b290ccc2a263e8d185130284f8501e3e36c5e02750fc6b6bdeb2e9e96f1e25", size = 148162, upload-time = "2025-10-14T04:40:54.558Z" }, - { url = "https://files.pythonhosted.org/packages/78/29/62328d79aa60da22c9e0b9a66539feae06ca0f5a4171ac4f7dc285b83688/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:74bb723680f9f7a6234dcf67aea57e708ec1fbdf5699fb91dfd6f511b0a320ef", size = 144558, upload-time = "2025-10-14T04:40:55.677Z" }, - { url = "https://files.pythonhosted.org/packages/86/bb/b32194a4bf15b88403537c2e120b817c61cd4ecffa9b6876e941c3ee38fe/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f1e34719c6ed0b92f418c7c780480b26b5d9c50349e9a9af7d76bf757530350d", size = 161497, upload-time = "2025-10-14T04:40:57.217Z" }, - { url = "https://files.pythonhosted.org/packages/19/89/a54c82b253d5b9b111dc74aca196ba5ccfcca8242d0fb64146d4d3183ff1/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2437418e20515acec67d86e12bf70056a33abdacb5cb1655042f6538d6b085a8", size = 159240, upload-time = "2025-10-14T04:40:58.358Z" }, - { url = "https://files.pythonhosted.org/packages/c0/10/d20b513afe03acc89ec33948320a5544d31f21b05368436d580dec4e234d/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:11d694519d7f29d6cd09f6ac70028dba10f92f6cdd059096db198c283794ac86", size = 153471, upload-time = "2025-10-14T04:40:59.468Z" }, - { url = "https://files.pythonhosted.org/packages/61/fa/fbf177b55bdd727010f9c0a3c49eefa1d10f960e5f09d1d887bf93c2e698/charset_normalizer-3.4.4-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ac1c4a689edcc530fc9d9aa11f5774b9e2f33f9a0c6a57864e90908f5208d30a", size = 150864, upload-time = "2025-10-14T04:41:00.623Z" }, - { url = "https://files.pythonhosted.org/packages/05/12/9fbc6a4d39c0198adeebbde20b619790e9236557ca59fc40e0e3cebe6f40/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:21d142cc6c0ec30d2efee5068ca36c128a30b0f2c53c1c07bd78cb6bc1d3be5f", size = 150647, upload-time = "2025-10-14T04:41:01.754Z" }, - { url = "https://files.pythonhosted.org/packages/ad/1f/6a9a593d52e3e8c5d2b167daf8c6b968808efb57ef4c210acb907c365bc4/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:5dbe56a36425d26d6cfb40ce79c314a2e4dd6211d51d6d2191c00bed34f354cc", size = 145110, upload-time = "2025-10-14T04:41:03.231Z" }, - { url = "https://files.pythonhosted.org/packages/30/42/9a52c609e72471b0fc54386dc63c3781a387bb4fe61c20231a4ebcd58bdd/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:5bfbb1b9acf3334612667b61bd3002196fe2a1eb4dd74d247e0f2a4d50ec9bbf", size = 162839, upload-time = "2025-10-14T04:41:04.715Z" }, - { url = "https://files.pythonhosted.org/packages/c4/5b/c0682bbf9f11597073052628ddd38344a3d673fda35a36773f7d19344b23/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:d055ec1e26e441f6187acf818b73564e6e6282709e9bcb5b63f5b23068356a15", size = 150667, upload-time = "2025-10-14T04:41:05.827Z" }, - { url = "https://files.pythonhosted.org/packages/e4/24/a41afeab6f990cf2daf6cb8c67419b63b48cf518e4f56022230840c9bfb2/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:af2d8c67d8e573d6de5bc30cdb27e9b95e49115cd9baad5ddbd1a6207aaa82a9", size = 160535, upload-time = "2025-10-14T04:41:06.938Z" }, - { url = "https://files.pythonhosted.org/packages/2a/e5/6a4ce77ed243c4a50a1fecca6aaaab419628c818a49434be428fe24c9957/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:780236ac706e66881f3b7f2f32dfe90507a09e67d1d454c762cf642e6e1586e0", size = 154816, upload-time = "2025-10-14T04:41:08.101Z" }, - { url = "https://files.pythonhosted.org/packages/a8/ef/89297262b8092b312d29cdb2517cb1237e51db8ecef2e9af5edbe7b683b1/charset_normalizer-3.4.4-cp312-cp312-win32.whl", hash = "sha256:5833d2c39d8896e4e19b689ffc198f08ea58116bee26dea51e362ecc7cd3ed26", size = 99694, upload-time = "2025-10-14T04:41:09.23Z" }, - { url = "https://files.pythonhosted.org/packages/3d/2d/1e5ed9dd3b3803994c155cd9aacb60c82c331bad84daf75bcb9c91b3295e/charset_normalizer-3.4.4-cp312-cp312-win_amd64.whl", hash = "sha256:a79cfe37875f822425b89a82333404539ae63dbdddf97f84dcbc3d339aae9525", size = 107131, upload-time = "2025-10-14T04:41:10.467Z" }, - { url = "https://files.pythonhosted.org/packages/d0/d9/0ed4c7098a861482a7b6a95603edce4c0d9db2311af23da1fb2b75ec26fc/charset_normalizer-3.4.4-cp312-cp312-win_arm64.whl", hash = "sha256:376bec83a63b8021bb5c8ea75e21c4ccb86e7e45ca4eb81146091b56599b80c3", size = 100390, upload-time = "2025-10-14T04:41:11.915Z" }, - { url = "https://files.pythonhosted.org/packages/97/45/4b3a1239bbacd321068ea6e7ac28875b03ab8bc0aa0966452db17cd36714/charset_normalizer-3.4.4-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:e1f185f86a6f3403aa2420e815904c67b2f9ebc443f045edd0de921108345794", size = 208091, upload-time = "2025-10-14T04:41:13.346Z" }, - { url = "https://files.pythonhosted.org/packages/7d/62/73a6d7450829655a35bb88a88fca7d736f9882a27eacdca2c6d505b57e2e/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b39f987ae8ccdf0d2642338faf2abb1862340facc796048b604ef14919e55ed", size = 147936, upload-time = "2025-10-14T04:41:14.461Z" }, - { url = "https://files.pythonhosted.org/packages/89/c5/adb8c8b3d6625bef6d88b251bbb0d95f8205831b987631ab0c8bb5d937c2/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3162d5d8ce1bb98dd51af660f2121c55d0fa541b46dff7bb9b9f86ea1d87de72", size = 144180, upload-time = "2025-10-14T04:41:15.588Z" }, - { url = "https://files.pythonhosted.org/packages/91/ed/9706e4070682d1cc219050b6048bfd293ccf67b3d4f5a4f39207453d4b99/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:81d5eb2a312700f4ecaa977a8235b634ce853200e828fbadf3a9c50bab278328", size = 161346, upload-time = "2025-10-14T04:41:16.738Z" }, - { url = "https://files.pythonhosted.org/packages/d5/0d/031f0d95e4972901a2f6f09ef055751805ff541511dc1252ba3ca1f80cf5/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5bd2293095d766545ec1a8f612559f6b40abc0eb18bb2f5d1171872d34036ede", size = 158874, upload-time = "2025-10-14T04:41:17.923Z" }, - { url = "https://files.pythonhosted.org/packages/f5/83/6ab5883f57c9c801ce5e5677242328aa45592be8a00644310a008d04f922/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a8a8b89589086a25749f471e6a900d3f662d1d3b6e2e59dcecf787b1cc3a1894", size = 153076, upload-time = "2025-10-14T04:41:19.106Z" }, - { url = "https://files.pythonhosted.org/packages/75/1e/5ff781ddf5260e387d6419959ee89ef13878229732732ee73cdae01800f2/charset_normalizer-3.4.4-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bc7637e2f80d8530ee4a78e878bce464f70087ce73cf7c1caf142416923b98f1", size = 150601, upload-time = "2025-10-14T04:41:20.245Z" }, - { url = "https://files.pythonhosted.org/packages/d7/57/71be810965493d3510a6ca79b90c19e48696fb1ff964da319334b12677f0/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f8bf04158c6b607d747e93949aa60618b61312fe647a6369f88ce2ff16043490", size = 150376, upload-time = "2025-10-14T04:41:21.398Z" }, - { url = "https://files.pythonhosted.org/packages/e5/d5/c3d057a78c181d007014feb7e9f2e65905a6c4ef182c0ddf0de2924edd65/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:554af85e960429cf30784dd47447d5125aaa3b99a6f0683589dbd27e2f45da44", size = 144825, upload-time = "2025-10-14T04:41:22.583Z" }, - { url = "https://files.pythonhosted.org/packages/e6/8c/d0406294828d4976f275ffbe66f00266c4b3136b7506941d87c00cab5272/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:74018750915ee7ad843a774364e13a3db91682f26142baddf775342c3f5b1133", size = 162583, upload-time = "2025-10-14T04:41:23.754Z" }, - { url = "https://files.pythonhosted.org/packages/d7/24/e2aa1f18c8f15c4c0e932d9287b8609dd30ad56dbe41d926bd846e22fb8d/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:c0463276121fdee9c49b98908b3a89c39be45d86d1dbaa22957e38f6321d4ce3", size = 150366, upload-time = "2025-10-14T04:41:25.27Z" }, - { url = "https://files.pythonhosted.org/packages/e4/5b/1e6160c7739aad1e2df054300cc618b06bf784a7a164b0f238360721ab86/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:362d61fd13843997c1c446760ef36f240cf81d3ebf74ac62652aebaf7838561e", size = 160300, upload-time = "2025-10-14T04:41:26.725Z" }, - { url = "https://files.pythonhosted.org/packages/7a/10/f882167cd207fbdd743e55534d5d9620e095089d176d55cb22d5322f2afd/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9a26f18905b8dd5d685d6d07b0cdf98a79f3c7a918906af7cc143ea2e164c8bc", size = 154465, upload-time = "2025-10-14T04:41:28.322Z" }, - { url = "https://files.pythonhosted.org/packages/89/66/c7a9e1b7429be72123441bfdbaf2bc13faab3f90b933f664db506dea5915/charset_normalizer-3.4.4-cp313-cp313-win32.whl", hash = "sha256:9b35f4c90079ff2e2edc5b26c0c77925e5d2d255c42c74fdb70fb49b172726ac", size = 99404, upload-time = "2025-10-14T04:41:29.95Z" }, - { url = "https://files.pythonhosted.org/packages/c4/26/b9924fa27db384bdcd97ab83b4f0a8058d96ad9626ead570674d5e737d90/charset_normalizer-3.4.4-cp313-cp313-win_amd64.whl", hash = "sha256:b435cba5f4f750aa6c0a0d92c541fb79f69a387c91e61f1795227e4ed9cece14", size = 107092, upload-time = "2025-10-14T04:41:31.188Z" }, - { url = "https://files.pythonhosted.org/packages/af/8f/3ed4bfa0c0c72a7ca17f0380cd9e4dd842b09f664e780c13cff1dcf2ef1b/charset_normalizer-3.4.4-cp313-cp313-win_arm64.whl", hash = "sha256:542d2cee80be6f80247095cc36c418f7bddd14f4a6de45af91dfad36d817bba2", size = 100408, upload-time = "2025-10-14T04:41:32.624Z" }, - { url = "https://files.pythonhosted.org/packages/2a/35/7051599bd493e62411d6ede36fd5af83a38f37c4767b92884df7301db25d/charset_normalizer-3.4.4-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:da3326d9e65ef63a817ecbcc0df6e94463713b754fe293eaa03da99befb9a5bd", size = 207746, upload-time = "2025-10-14T04:41:33.773Z" }, - { url = "https://files.pythonhosted.org/packages/10/9a/97c8d48ef10d6cd4fcead2415523221624bf58bcf68a802721a6bc807c8f/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8af65f14dc14a79b924524b1e7fffe304517b2bff5a58bf64f30b98bbc5079eb", size = 147889, upload-time = "2025-10-14T04:41:34.897Z" }, - { url = "https://files.pythonhosted.org/packages/10/bf/979224a919a1b606c82bd2c5fa49b5c6d5727aa47b4312bb27b1734f53cd/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:74664978bb272435107de04e36db5a9735e78232b85b77d45cfb38f758efd33e", size = 143641, upload-time = "2025-10-14T04:41:36.116Z" }, - { url = "https://files.pythonhosted.org/packages/ba/33/0ad65587441fc730dc7bd90e9716b30b4702dc7b617e6ba4997dc8651495/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:752944c7ffbfdd10c074dc58ec2d5a8a4cd9493b314d367c14d24c17684ddd14", size = 160779, upload-time = "2025-10-14T04:41:37.229Z" }, - { url = "https://files.pythonhosted.org/packages/67/ed/331d6b249259ee71ddea93f6f2f0a56cfebd46938bde6fcc6f7b9a3d0e09/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d1f13550535ad8cff21b8d757a3257963e951d96e20ec82ab44bc64aeb62a191", size = 159035, upload-time = "2025-10-14T04:41:38.368Z" }, - { url = "https://files.pythonhosted.org/packages/67/ff/f6b948ca32e4f2a4576aa129d8bed61f2e0543bf9f5f2b7fc3758ed005c9/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ecaae4149d99b1c9e7b88bb03e3221956f68fd6d50be2ef061b2381b61d20838", size = 152542, upload-time = "2025-10-14T04:41:39.862Z" }, - { url = "https://files.pythonhosted.org/packages/16/85/276033dcbcc369eb176594de22728541a925b2632f9716428c851b149e83/charset_normalizer-3.4.4-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:cb6254dc36b47a990e59e1068afacdcd02958bdcce30bb50cc1700a8b9d624a6", size = 149524, upload-time = "2025-10-14T04:41:41.319Z" }, - { url = "https://files.pythonhosted.org/packages/9e/f2/6a2a1f722b6aba37050e626530a46a68f74e63683947a8acff92569f979a/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c8ae8a0f02f57a6e61203a31428fa1d677cbe50c93622b4149d5c0f319c1d19e", size = 150395, upload-time = "2025-10-14T04:41:42.539Z" }, - { url = "https://files.pythonhosted.org/packages/60/bb/2186cb2f2bbaea6338cad15ce23a67f9b0672929744381e28b0592676824/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:47cc91b2f4dd2833fddaedd2893006b0106129d4b94fdb6af1f4ce5a9965577c", size = 143680, upload-time = "2025-10-14T04:41:43.661Z" }, - { url = "https://files.pythonhosted.org/packages/7d/a5/bf6f13b772fbb2a90360eb620d52ed8f796f3c5caee8398c3b2eb7b1c60d/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:82004af6c302b5d3ab2cfc4cc5f29db16123b1a8417f2e25f9066f91d4411090", size = 162045, upload-time = "2025-10-14T04:41:44.821Z" }, - { url = "https://files.pythonhosted.org/packages/df/c5/d1be898bf0dc3ef9030c3825e5d3b83f2c528d207d246cbabe245966808d/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:2b7d8f6c26245217bd2ad053761201e9f9680f8ce52f0fcd8d0755aeae5b2152", size = 149687, upload-time = "2025-10-14T04:41:46.442Z" }, - { url = "https://files.pythonhosted.org/packages/a5/42/90c1f7b9341eef50c8a1cb3f098ac43b0508413f33affd762855f67a410e/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:799a7a5e4fb2d5898c60b640fd4981d6a25f1c11790935a44ce38c54e985f828", size = 160014, upload-time = "2025-10-14T04:41:47.631Z" }, - { url = "https://files.pythonhosted.org/packages/76/be/4d3ee471e8145d12795ab655ece37baed0929462a86e72372fd25859047c/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:99ae2cffebb06e6c22bdc25801d7b30f503cc87dbd283479e7b606f70aff57ec", size = 154044, upload-time = "2025-10-14T04:41:48.81Z" }, - { url = "https://files.pythonhosted.org/packages/b0/6f/8f7af07237c34a1defe7defc565a9bc1807762f672c0fde711a4b22bf9c0/charset_normalizer-3.4.4-cp314-cp314-win32.whl", hash = "sha256:f9d332f8c2a2fcbffe1378594431458ddbef721c1769d78e2cbc06280d8155f9", size = 99940, upload-time = "2025-10-14T04:41:49.946Z" }, - { url = "https://files.pythonhosted.org/packages/4b/51/8ade005e5ca5b0d80fb4aff72a3775b325bdc3d27408c8113811a7cbe640/charset_normalizer-3.4.4-cp314-cp314-win_amd64.whl", hash = "sha256:8a6562c3700cce886c5be75ade4a5db4214fda19fede41d9792d100288d8f94c", size = 107104, upload-time = "2025-10-14T04:41:51.051Z" }, - { url = "https://files.pythonhosted.org/packages/da/5f/6b8f83a55bb8278772c5ae54a577f3099025f9ade59d0136ac24a0df4bde/charset_normalizer-3.4.4-cp314-cp314-win_arm64.whl", hash = "sha256:de00632ca48df9daf77a2c65a484531649261ec9f25489917f09e455cb09ddb2", size = 100743, upload-time = "2025-10-14T04:41:52.122Z" }, - { url = "https://files.pythonhosted.org/packages/0a/4c/925909008ed5a988ccbb72dcc897407e5d6d3bd72410d69e051fc0c14647/charset_normalizer-3.4.4-py3-none-any.whl", hash = "sha256:7a32c560861a02ff789ad905a2fe94e3f840803362c84fecf1851cb4cf3dc37f", size = 53402, upload-time = "2025-10-14T04:42:31.76Z" }, -] - -[[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 = "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 = "defusedxml" -version = "0.7.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/0f/d5/c66da9b79e5bdb124974bfe172b4daf3c984ebd9c2a06e2b8a4dc7331c72/defusedxml-0.7.1.tar.gz", hash = "sha256:1bb3032db185915b62d7c6209c5a8792be6a32ab2fedacc84e01b52c51aa3e69", size = 75520, upload-time = "2021-03-08T10:59:26.269Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/07/6c/aa3f2f849e01cb6a001cd8554a88d4c77c5c1a31c95bdf1cf9301e6d9ef4/defusedxml-0.7.1-py2.py3-none-any.whl", hash = "sha256:a352e7e428770286cc899e2542b6cdaedb2b4953ff269a210103ec58f6198a61", size = 25604, upload-time = "2021-03-08T10:59:24.45Z" }, -] - -[[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 = "fastjsonschema" -version = "2.21.2" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/20/b5/23b216d9d985a956623b6bd12d4086b60f0059b27799f23016af04a74ea1/fastjsonschema-2.21.2.tar.gz", hash = "sha256:b1eb43748041c880796cd077f1a07c3d94e93ae84bba5ed36800a33554ae05de", size = 374130, upload-time = "2025-08-14T18:49:36.666Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/cb/a8/20d0723294217e47de6d9e2e40fd4a9d2f7c4b6ef974babd482a59743694/fastjsonschema-2.21.2-py3-none-any.whl", hash = "sha256:1c797122d0a86c5cace2e54bf4e819c36223b552017172f32c5c024a6b77e463", size = 24024, upload-time = "2025-08-14T18:49:34.776Z" }, -] - -[[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 = "fqdn" -version = "1.5.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/30/3e/a80a8c077fd798951169626cde3e239adeba7dab75deb3555716415bd9b0/fqdn-1.5.1.tar.gz", hash = "sha256:105ed3677e767fb5ca086a0c1f4bb66ebc3c100be518f0e0d755d9eae164d89f", size = 6015, upload-time = "2021-03-11T07:16:29.08Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/cf/58/8acf1b3e91c58313ce5cb67df61001fc9dcd21be4fadb76c1a2d540e09ed/fqdn-1.5.1-py3-none-any.whl", hash = "sha256:3a179af3761e4df6eb2e026ff9e1a3033d3587bf980a0b1b2e1e5d08d7358014", size = 9121, upload-time = "2021-03-11T07:16:28.351Z" }, -] - -[[package]] -name = "h11" -version = "0.16.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" }, -] - -[[package]] -name = "httpcore" -version = "1.0.9" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "certifi" }, - { name = "h11" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" }, -] - -[[package]] -name = "httpx" -version = "0.28.1" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "anyio" }, - { name = "certifi" }, - { name = "httpcore" }, - { name = "idna" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" }, -] - -[[package]] -name = "idna" -version = "3.11" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/6f/6d/0703ccc57f3a7233505399edb88de3cbd678da106337b9fcde432b65ed60/idna-3.11.tar.gz", hash = "sha256:795dafcc9c04ed0c1fb032c2aa73654d8e8c5023a7df64a53f39190ada629902", size = 194582, upload-time = "2025-10-12T14:55:20.501Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/0e/61/66938bbb5fc52dbdf84594873d5b51fb1f7c7794e9c0f5bd885f30bc507b/idna-3.11-py3-none-any.whl", hash = "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea", size = 71008, upload-time = "2025-10-12T14:55:18.883Z" }, -] - -[[package]] -name = "ipykernel" -version = "7.1.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "appnope", marker = "sys_platform == 'darwin'" }, - { name = "comm" }, - { name = "debugpy" }, - { name = "ipython" }, - { name = "jupyter-client" }, - { name = "jupyter-core" }, - { name = "matplotlib-inline" }, - { name = "nest-asyncio" }, - { name = "packaging" }, - { name = "psutil" }, - { name = "pyzmq" }, - { name = "tornado" }, - { name = "traitlets" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/b9/a4/4948be6eb88628505b83a1f2f40d90254cab66abf2043b3c40fa07dfce0f/ipykernel-7.1.0.tar.gz", hash = "sha256:58a3fc88533d5930c3546dc7eac66c6d288acde4f801e2001e65edc5dc9cf0db", size = 174579, upload-time = "2025-10-27T09:46:39.471Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/a3/17/20c2552266728ceba271967b87919664ecc0e33efca29c3efc6baf88c5f9/ipykernel-7.1.0-py3-none-any.whl", hash = "sha256:763b5ec6c5b7776f6a8d7ce09b267693b4e5ce75cb50ae696aaefb3c85e1ea4c", size = 117968, upload-time = "2025-10-27T09:46:37.805Z" }, -] - -[[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 = "isoduration" -version = "20.11.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "arrow" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/7c/1a/3c8edc664e06e6bd06cce40c6b22da5f1429aa4224d0c590f3be21c91ead/isoduration-20.11.0.tar.gz", hash = "sha256:ac2f9015137935279eac671f94f89eb00584f940f5dc49462a0c4ee692ba1bd9", size = 11649, upload-time = "2020-11-01T11:00:00.312Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/7b/55/e5326141505c5d5e34c5e0935d2908a74e4561eca44108fbfb9c13d2911a/isoduration-20.11.0-py3-none-any.whl", hash = "sha256:b2904c2a4228c3d44f409c8ae8e2370eb21a26f7ac2ec5446df141dde3452042", size = 11321, upload-time = "2020-11-01T10:59:58.02Z" }, -] - -[[package]] -name = "jedi" -version = "0.19.2" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "parso" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/72/3a/79a912fbd4d8dd6fbb02bf69afd3bb72cf0c729bb3063c6f4498603db17a/jedi-0.19.2.tar.gz", hash = "sha256:4770dc3de41bde3966b02eb84fbcf557fb33cce26ad23da12c742fb50ecb11f0", size = 1231287, upload-time = "2024-11-11T01:41:42.873Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/c0/5a/9cac0c82afec3d09ccd97c8b6502d48f165f9124db81b4bcb90b4af974ee/jedi-0.19.2-py2.py3-none-any.whl", hash = "sha256:a8ef22bde8490f57fe5c7681a3c83cb58874daf72b4784de3cce5b6ef6edb5b9", size = 1572278, upload-time = "2024-11-11T01:41:40.175Z" }, -] - -[[package]] -name = "jinja2" -version = "3.1.6" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "markupsafe" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d", size = 245115, upload-time = "2025-03-05T20:05:02.478Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899, upload-time = "2025-03-05T20:05:00.369Z" }, -] - -[[package]] -name = "json5" -version = "0.12.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/12/ae/929aee9619e9eba9015207a9d2c1c54db18311da7eb4dcf6d41ad6f0eb67/json5-0.12.1.tar.gz", hash = "sha256:b2743e77b3242f8d03c143dd975a6ec7c52e2f2afe76ed934e53503dd4ad4990", size = 52191, upload-time = "2025-08-12T19:47:42.583Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/85/e2/05328bd2621be49a6fed9e3030b1e51a2d04537d3f816d211b9cc53c5262/json5-0.12.1-py3-none-any.whl", hash = "sha256:d9c9b3bc34a5f54d43c35e11ef7cb87d8bdd098c6ace87117a7b7e83e705c1d5", size = 36119, upload-time = "2025-08-12T19:47:41.131Z" }, -] - -[[package]] -name = "jsonpointer" -version = "3.0.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/6a/0a/eebeb1fa92507ea94016a2a790b93c2ae41a7e18778f85471dc54475ed25/jsonpointer-3.0.0.tar.gz", hash = "sha256:2b2d729f2091522d61c3b31f82e11870f60b68f43fbc705cb76bf4b832af59ef", size = 9114, upload-time = "2024-06-10T19:24:42.462Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/71/92/5e77f98553e9e75130c78900d000368476aed74276eb8ae8796f65f00918/jsonpointer-3.0.0-py2.py3-none-any.whl", hash = "sha256:13e088adc14fca8b6aa8177c044e12701e6ad4b28ff10e65f2267a90109c9942", size = 7595, upload-time = "2024-06-10T19:24:40.698Z" }, -] - -[[package]] -name = "jsonschema" -version = "4.25.1" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "attrs" }, - { name = "jsonschema-specifications" }, - { name = "referencing" }, - { name = "rpds-py" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/74/69/f7185de793a29082a9f3c7728268ffb31cb5095131a9c139a74078e27336/jsonschema-4.25.1.tar.gz", hash = "sha256:e4a9655ce0da0c0b67a085847e00a3a51449e1157f4f75e9fb5aa545e122eb85", size = 357342, upload-time = "2025-08-18T17:03:50.038Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/bf/9c/8c95d856233c1f82500c2450b8c68576b4cf1c871db3afac5c34ff84e6fd/jsonschema-4.25.1-py3-none-any.whl", hash = "sha256:3fba0169e345c7175110351d456342c364814cfcf3b964ba4587f22915230a63", size = 90040, upload-time = "2025-08-18T17:03:48.373Z" }, -] - -[package.optional-dependencies] -format-nongpl = [ - { name = "fqdn" }, - { name = "idna" }, - { name = "isoduration" }, - { name = "jsonpointer" }, - { name = "rfc3339-validator" }, - { name = "rfc3986-validator" }, - { name = "rfc3987-syntax" }, - { name = "uri-template" }, - { name = "webcolors" }, -] - -[[package]] -name = "jsonschema-specifications" -version = "2025.9.1" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "referencing" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/19/74/a633ee74eb36c44aa6d1095e7cc5569bebf04342ee146178e2d36600708b/jsonschema_specifications-2025.9.1.tar.gz", hash = "sha256:b540987f239e745613c7a9176f3edb72b832a4ac465cf02712288397832b5e8d", size = 32855, upload-time = "2025-09-08T01:34:59.186Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/41/45/1a4ed80516f02155c51f51e8cedb3c1902296743db0bbc66608a0db2814f/jsonschema_specifications-2025.9.1-py3-none-any.whl", hash = "sha256:98802fee3a11ee76ecaca44429fda8a41bff98b00a0f2838151b113f210cc6fe", size = 18437, upload-time = "2025-09-08T01:34:57.871Z" }, -] - -[[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.1" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "platformdirs" }, - { name = "traitlets" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/02/49/9d1284d0dc65e2c757b74c6687b6d319b02f822ad039e5c512df9194d9dd/jupyter_core-5.9.1.tar.gz", hash = "sha256:4d09aaff303b9566c3ce657f580bd089ff5c91f5f89cf7d8846c3cdf465b5508", size = 89814, upload-time = "2025-10-16T19:19:18.444Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/e7/e7/80988e32bf6f73919a113473a604f5a8f09094de312b9d52b79c2df7612b/jupyter_core-5.9.1-py3-none-any.whl", hash = "sha256:ebf87fdc6073d142e114c72c9e29a9d7ca03fad818c5d300ce2adc1fb0743407", size = 29032, upload-time = "2025-10-16T19:19:16.783Z" }, -] - -[[package]] -name = "jupyter-events" -version = "0.12.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "jsonschema", extra = ["format-nongpl"] }, - { name = "packaging" }, - { name = "python-json-logger" }, - { name = "pyyaml" }, - { name = "referencing" }, - { name = "rfc3339-validator" }, - { name = "rfc3986-validator" }, - { name = "traitlets" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/9d/c3/306d090461e4cf3cd91eceaff84bede12a8e52cd821c2d20c9a4fd728385/jupyter_events-0.12.0.tar.gz", hash = "sha256:fc3fce98865f6784c9cd0a56a20644fc6098f21c8c33834a8d9fe383c17e554b", size = 62196, upload-time = "2025-02-03T17:23:41.485Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/e2/48/577993f1f99c552f18a0428731a755e06171f9902fa118c379eb7c04ea22/jupyter_events-0.12.0-py3-none-any.whl", hash = "sha256:6464b2fa5ad10451c3d35fabc75eab39556ae1e2853ad0c0cc31b656731a97fb", size = 19430, upload-time = "2025-02-03T17:23:38.643Z" }, -] - -[[package]] -name = "jupyter-lsp" -version = "2.3.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "jupyter-server" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/eb/5a/9066c9f8e94ee517133cd98dba393459a16cd48bba71a82f16a65415206c/jupyter_lsp-2.3.0.tar.gz", hash = "sha256:458aa59339dc868fb784d73364f17dbce8836e906cd75fd471a325cba02e0245", size = 54823, upload-time = "2025-08-27T17:47:34.671Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/1a/60/1f6cee0c46263de1173894f0fafcb3475ded276c472c14d25e0280c18d6d/jupyter_lsp-2.3.0-py3-none-any.whl", hash = "sha256:e914a3cb2addf48b1c7710914771aaf1819d46b2e5a79b0f917b5478ec93f34f", size = 76687, upload-time = "2025-08-27T17:47:33.15Z" }, -] - -[[package]] -name = "jupyter-server" -version = "2.17.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "anyio" }, - { name = "argon2-cffi" }, - { name = "jinja2" }, - { name = "jupyter-client" }, - { name = "jupyter-core" }, - { name = "jupyter-events" }, - { name = "jupyter-server-terminals" }, - { name = "nbconvert" }, - { name = "nbformat" }, - { name = "packaging" }, - { name = "prometheus-client" }, - { name = "pywinpty", marker = "os_name == 'nt'" }, - { name = "pyzmq" }, - { name = "send2trash" }, - { name = "terminado" }, - { name = "tornado" }, - { name = "traitlets" }, - { name = "websocket-client" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/5b/ac/e040ec363d7b6b1f11304cc9f209dac4517ece5d5e01821366b924a64a50/jupyter_server-2.17.0.tar.gz", hash = "sha256:c38ea898566964c888b4772ae1ed58eca84592e88251d2cfc4d171f81f7e99d5", size = 731949, upload-time = "2025-08-21T14:42:54.042Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/92/80/a24767e6ca280f5a49525d987bf3e4d7552bf67c8be07e8ccf20271f8568/jupyter_server-2.17.0-py3-none-any.whl", hash = "sha256:e8cb9c7db4251f51ed307e329b81b72ccf2056ff82d50524debde1ee1870e13f", size = 388221, upload-time = "2025-08-21T14:42:52.034Z" }, -] - -[[package]] -name = "jupyter-server-terminals" -version = "0.5.3" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "pywinpty", marker = "os_name == 'nt'" }, - { name = "terminado" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/fc/d5/562469734f476159e99a55426d697cbf8e7eb5efe89fb0e0b4f83a3d3459/jupyter_server_terminals-0.5.3.tar.gz", hash = "sha256:5ae0295167220e9ace0edcfdb212afd2b01ee8d179fe6f23c899590e9b8a5269", size = 31430, upload-time = "2024-03-12T14:37:03.049Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/07/2d/2b32cdbe8d2a602f697a649798554e4f072115438e92249624e532e8aca6/jupyter_server_terminals-0.5.3-py3-none-any.whl", hash = "sha256:41ee0d7dc0ebf2809c668e0fc726dfaf258fcd3e769568996ca731b6194ae9aa", size = 13656, upload-time = "2024-03-12T14:37:00.708Z" }, -] - -[[package]] -name = "jupyterlab" -version = "4.4.10" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "async-lru" }, - { name = "httpx" }, - { name = "ipykernel" }, - { name = "jinja2" }, - { name = "jupyter-core" }, - { name = "jupyter-lsp" }, - { name = "jupyter-server" }, - { name = "jupyterlab-server" }, - { name = "notebook-shim" }, - { name = "packaging" }, - { name = "setuptools" }, - { name = "tornado" }, - { name = "traitlets" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/6a/5d/75c42a48ff5fc826a7dff3fe4004cda47c54f9d981c351efacfbc9139d3c/jupyterlab-4.4.10.tar.gz", hash = "sha256:521c017508af4e1d6d9d8a9d90f47a11c61197ad63b2178342489de42540a615", size = 22969303, upload-time = "2025-10-22T14:50:58.768Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/f7/46/1eaa5db8d54a594bdade67afbcae42e9a2da676628be3eb39f36dcff6390/jupyterlab-4.4.10-py3-none-any.whl", hash = "sha256:65939ab4c8dcd0c42185c2d0d1a9d60b254dc8c46fc4fdb286b63c51e9358e07", size = 12293385, upload-time = "2025-10-22T14:50:54.075Z" }, -] - -[[package]] -name = "jupyterlab-pygments" -version = "0.3.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/90/51/9187be60d989df97f5f0aba133fa54e7300f17616e065d1ada7d7646b6d6/jupyterlab_pygments-0.3.0.tar.gz", hash = "sha256:721aca4d9029252b11cfa9d185e5b5af4d54772bb8072f9b7036f4170054d35d", size = 512900, upload-time = "2023-11-23T09:26:37.44Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/b1/dd/ead9d8ea85bf202d90cc513b533f9c363121c7792674f78e0d8a854b63b4/jupyterlab_pygments-0.3.0-py3-none-any.whl", hash = "sha256:841a89020971da1d8693f1a99997aefc5dc424bb1b251fd6322462a1b8842780", size = 15884, upload-time = "2023-11-23T09:26:34.325Z" }, -] - -[[package]] -name = "jupyterlab-server" -version = "2.28.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "babel" }, - { name = "jinja2" }, - { name = "json5" }, - { name = "jsonschema" }, - { name = "jupyter-server" }, - { name = "packaging" }, - { name = "requests" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/d6/2c/90153f189e421e93c4bb4f9e3f59802a1f01abd2ac5cf40b152d7f735232/jupyterlab_server-2.28.0.tar.gz", hash = "sha256:35baa81898b15f93573e2deca50d11ac0ae407ebb688299d3a5213265033712c", size = 76996, upload-time = "2025-10-22T13:59:18.37Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/e0/07/a000fe835f76b7e1143242ab1122e6362ef1c03f23f83a045c38859c2ae0/jupyterlab_server-2.28.0-py3-none-any.whl", hash = "sha256:e4355b148fdcf34d312bbbc80f22467d6d20460e8b8736bf235577dd18506968", size = 59830, upload-time = "2025-10-22T13:59:16.767Z" }, -] - -[[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 = "lark" -version = "1.3.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/da/34/28fff3ab31ccff1fd4f6c7c7b0ceb2b6968d8ea4950663eadcb5720591a0/lark-1.3.1.tar.gz", hash = "sha256:b426a7a6d6d53189d318f2b6236ab5d6429eaf09259f1ca33eb716eed10d2905", size = 382732, upload-time = "2025-10-27T18:25:56.653Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/82/3d/14ce75ef66813643812f3093ab17e46d3a206942ce7376d31ec2d36229e7/lark-1.3.1-py3-none-any.whl", hash = "sha256:c629b661023a014c37da873b4ff58a817398d12635d3bbb2c5a03be7fe5d1e12", size = 113151, upload-time = "2025-10-27T18:25:54.882Z" }, -] - -[[package]] -name = "markupsafe" -version = "3.0.3" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/7e/99/7690b6d4034fffd95959cbe0c02de8deb3098cc577c67bb6a24fe5d7caa7/markupsafe-3.0.3.tar.gz", hash = "sha256:722695808f4b6457b320fdc131280796bdceb04ab50fe1795cd540799ebe1698", size = 80313, upload-time = "2025-09-27T18:37:40.426Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/5a/72/147da192e38635ada20e0a2e1a51cf8823d2119ce8883f7053879c2199b5/markupsafe-3.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d53197da72cc091b024dd97249dfc7794d6a56530370992a5e1a08983ad9230e", size = 11615, upload-time = "2025-09-27T18:36:30.854Z" }, - { url = "https://files.pythonhosted.org/packages/9a/81/7e4e08678a1f98521201c3079f77db69fb552acd56067661f8c2f534a718/markupsafe-3.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1872df69a4de6aead3491198eaf13810b565bdbeec3ae2dc8780f14458ec73ce", size = 12020, upload-time = "2025-09-27T18:36:31.971Z" }, - { url = "https://files.pythonhosted.org/packages/1e/2c/799f4742efc39633a1b54a92eec4082e4f815314869865d876824c257c1e/markupsafe-3.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3a7e8ae81ae39e62a41ec302f972ba6ae23a5c5396c8e60113e9066ef893da0d", size = 24332, upload-time = "2025-09-27T18:36:32.813Z" }, - { url = "https://files.pythonhosted.org/packages/3c/2e/8d0c2ab90a8c1d9a24f0399058ab8519a3279d1bd4289511d74e909f060e/markupsafe-3.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d6dd0be5b5b189d31db7cda48b91d7e0a9795f31430b7f271219ab30f1d3ac9d", size = 22947, upload-time = "2025-09-27T18:36:33.86Z" }, - { url = "https://files.pythonhosted.org/packages/2c/54/887f3092a85238093a0b2154bd629c89444f395618842e8b0c41783898ea/markupsafe-3.0.3-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:94c6f0bb423f739146aec64595853541634bde58b2135f27f61c1ffd1cd4d16a", size = 21962, upload-time = "2025-09-27T18:36:35.099Z" }, - { url = "https://files.pythonhosted.org/packages/c9/2f/336b8c7b6f4a4d95e91119dc8521402461b74a485558d8f238a68312f11c/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:be8813b57049a7dc738189df53d69395eba14fb99345e0a5994914a3864c8a4b", size = 23760, upload-time = "2025-09-27T18:36:36.001Z" }, - { url = "https://files.pythonhosted.org/packages/32/43/67935f2b7e4982ffb50a4d169b724d74b62a3964bc1a9a527f5ac4f1ee2b/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:83891d0e9fb81a825d9a6d61e3f07550ca70a076484292a70fde82c4b807286f", size = 21529, upload-time = "2025-09-27T18:36:36.906Z" }, - { url = "https://files.pythonhosted.org/packages/89/e0/4486f11e51bbba8b0c041098859e869e304d1c261e59244baa3d295d47b7/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:77f0643abe7495da77fb436f50f8dab76dbc6e5fd25d39589a0f1fe6548bfa2b", size = 23015, upload-time = "2025-09-27T18:36:37.868Z" }, - { url = "https://files.pythonhosted.org/packages/2f/e1/78ee7a023dac597a5825441ebd17170785a9dab23de95d2c7508ade94e0e/markupsafe-3.0.3-cp312-cp312-win32.whl", hash = "sha256:d88b440e37a16e651bda4c7c2b930eb586fd15ca7406cb39e211fcff3bf3017d", size = 14540, upload-time = "2025-09-27T18:36:38.761Z" }, - { url = "https://files.pythonhosted.org/packages/aa/5b/bec5aa9bbbb2c946ca2733ef9c4ca91c91b6a24580193e891b5f7dbe8e1e/markupsafe-3.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:26a5784ded40c9e318cfc2bdb30fe164bdb8665ded9cd64d500a34fb42067b1c", size = 15105, upload-time = "2025-09-27T18:36:39.701Z" }, - { url = "https://files.pythonhosted.org/packages/e5/f1/216fc1bbfd74011693a4fd837e7026152e89c4bcf3e77b6692fba9923123/markupsafe-3.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:35add3b638a5d900e807944a078b51922212fb3dedb01633a8defc4b01a3c85f", size = 13906, upload-time = "2025-09-27T18:36:40.689Z" }, - { url = "https://files.pythonhosted.org/packages/38/2f/907b9c7bbba283e68f20259574b13d005c121a0fa4c175f9bed27c4597ff/markupsafe-3.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e1cf1972137e83c5d4c136c43ced9ac51d0e124706ee1c8aa8532c1287fa8795", size = 11622, upload-time = "2025-09-27T18:36:41.777Z" }, - { url = "https://files.pythonhosted.org/packages/9c/d9/5f7756922cdd676869eca1c4e3c0cd0df60ed30199ffd775e319089cb3ed/markupsafe-3.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:116bb52f642a37c115f517494ea5feb03889e04df47eeff5b130b1808ce7c219", size = 12029, upload-time = "2025-09-27T18:36:43.257Z" }, - { url = "https://files.pythonhosted.org/packages/00/07/575a68c754943058c78f30db02ee03a64b3c638586fba6a6dd56830b30a3/markupsafe-3.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:133a43e73a802c5562be9bbcd03d090aa5a1fe899db609c29e8c8d815c5f6de6", size = 24374, upload-time = "2025-09-27T18:36:44.508Z" }, - { url = "https://files.pythonhosted.org/packages/a9/21/9b05698b46f218fc0e118e1f8168395c65c8a2c750ae2bab54fc4bd4e0e8/markupsafe-3.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ccfcd093f13f0f0b7fdd0f198b90053bf7b2f02a3927a30e63f3ccc9df56b676", size = 22980, upload-time = "2025-09-27T18:36:45.385Z" }, - { url = "https://files.pythonhosted.org/packages/7f/71/544260864f893f18b6827315b988c146b559391e6e7e8f7252839b1b846a/markupsafe-3.0.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:509fa21c6deb7a7a273d629cf5ec029bc209d1a51178615ddf718f5918992ab9", size = 21990, upload-time = "2025-09-27T18:36:46.916Z" }, - { url = "https://files.pythonhosted.org/packages/c2/28/b50fc2f74d1ad761af2f5dcce7492648b983d00a65b8c0e0cb457c82ebbe/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a4afe79fb3de0b7097d81da19090f4df4f8d3a2b3adaa8764138aac2e44f3af1", size = 23784, upload-time = "2025-09-27T18:36:47.884Z" }, - { url = "https://files.pythonhosted.org/packages/ed/76/104b2aa106a208da8b17a2fb72e033a5a9d7073c68f7e508b94916ed47a9/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:795e7751525cae078558e679d646ae45574b47ed6e7771863fcc079a6171a0fc", size = 21588, upload-time = "2025-09-27T18:36:48.82Z" }, - { url = "https://files.pythonhosted.org/packages/b5/99/16a5eb2d140087ebd97180d95249b00a03aa87e29cc224056274f2e45fd6/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8485f406a96febb5140bfeca44a73e3ce5116b2501ac54fe953e488fb1d03b12", size = 23041, upload-time = "2025-09-27T18:36:49.797Z" }, - { url = "https://files.pythonhosted.org/packages/19/bc/e7140ed90c5d61d77cea142eed9f9c303f4c4806f60a1044c13e3f1471d0/markupsafe-3.0.3-cp313-cp313-win32.whl", hash = "sha256:bdd37121970bfd8be76c5fb069c7751683bdf373db1ed6c010162b2a130248ed", size = 14543, upload-time = "2025-09-27T18:36:51.584Z" }, - { url = "https://files.pythonhosted.org/packages/05/73/c4abe620b841b6b791f2edc248f556900667a5a1cf023a6646967ae98335/markupsafe-3.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:9a1abfdc021a164803f4d485104931fb8f8c1efd55bc6b748d2f5774e78b62c5", size = 15113, upload-time = "2025-09-27T18:36:52.537Z" }, - { url = "https://files.pythonhosted.org/packages/f0/3a/fa34a0f7cfef23cf9500d68cb7c32dd64ffd58a12b09225fb03dd37d5b80/markupsafe-3.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:7e68f88e5b8799aa49c85cd116c932a1ac15caaa3f5db09087854d218359e485", size = 13911, upload-time = "2025-09-27T18:36:53.513Z" }, - { url = "https://files.pythonhosted.org/packages/e4/d7/e05cd7efe43a88a17a37b3ae96e79a19e846f3f456fe79c57ca61356ef01/markupsafe-3.0.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:218551f6df4868a8d527e3062d0fb968682fe92054e89978594c28e642c43a73", size = 11658, upload-time = "2025-09-27T18:36:54.819Z" }, - { url = "https://files.pythonhosted.org/packages/99/9e/e412117548182ce2148bdeacdda3bb494260c0b0184360fe0d56389b523b/markupsafe-3.0.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3524b778fe5cfb3452a09d31e7b5adefeea8c5be1d43c4f810ba09f2ceb29d37", size = 12066, upload-time = "2025-09-27T18:36:55.714Z" }, - { url = "https://files.pythonhosted.org/packages/bc/e6/fa0ffcda717ef64a5108eaa7b4f5ed28d56122c9a6d70ab8b72f9f715c80/markupsafe-3.0.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4e885a3d1efa2eadc93c894a21770e4bc67899e3543680313b09f139e149ab19", size = 25639, upload-time = "2025-09-27T18:36:56.908Z" }, - { url = "https://files.pythonhosted.org/packages/96/ec/2102e881fe9d25fc16cb4b25d5f5cde50970967ffa5dddafdb771237062d/markupsafe-3.0.3-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8709b08f4a89aa7586de0aadc8da56180242ee0ada3999749b183aa23df95025", size = 23569, upload-time = "2025-09-27T18:36:57.913Z" }, - { url = "https://files.pythonhosted.org/packages/4b/30/6f2fce1f1f205fc9323255b216ca8a235b15860c34b6798f810f05828e32/markupsafe-3.0.3-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b8512a91625c9b3da6f127803b166b629725e68af71f8184ae7e7d54686a56d6", size = 23284, upload-time = "2025-09-27T18:36:58.833Z" }, - { url = "https://files.pythonhosted.org/packages/58/47/4a0ccea4ab9f5dcb6f79c0236d954acb382202721e704223a8aafa38b5c8/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9b79b7a16f7fedff2495d684f2b59b0457c3b493778c9eed31111be64d58279f", size = 24801, upload-time = "2025-09-27T18:36:59.739Z" }, - { url = "https://files.pythonhosted.org/packages/6a/70/3780e9b72180b6fecb83a4814d84c3bf4b4ae4bf0b19c27196104149734c/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:12c63dfb4a98206f045aa9563db46507995f7ef6d83b2f68eda65c307c6829eb", size = 22769, upload-time = "2025-09-27T18:37:00.719Z" }, - { url = "https://files.pythonhosted.org/packages/98/c5/c03c7f4125180fc215220c035beac6b9cb684bc7a067c84fc69414d315f5/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8f71bc33915be5186016f675cd83a1e08523649b0e33efdb898db577ef5bb009", size = 23642, upload-time = "2025-09-27T18:37:01.673Z" }, - { url = "https://files.pythonhosted.org/packages/80/d6/2d1b89f6ca4bff1036499b1e29a1d02d282259f3681540e16563f27ebc23/markupsafe-3.0.3-cp313-cp313t-win32.whl", hash = "sha256:69c0b73548bc525c8cb9a251cddf1931d1db4d2258e9599c28c07ef3580ef354", size = 14612, upload-time = "2025-09-27T18:37:02.639Z" }, - { url = "https://files.pythonhosted.org/packages/2b/98/e48a4bfba0a0ffcf9925fe2d69240bfaa19c6f7507b8cd09c70684a53c1e/markupsafe-3.0.3-cp313-cp313t-win_amd64.whl", hash = "sha256:1b4b79e8ebf6b55351f0d91fe80f893b4743f104bff22e90697db1590e47a218", size = 15200, upload-time = "2025-09-27T18:37:03.582Z" }, - { url = "https://files.pythonhosted.org/packages/0e/72/e3cc540f351f316e9ed0f092757459afbc595824ca724cbc5a5d4263713f/markupsafe-3.0.3-cp313-cp313t-win_arm64.whl", hash = "sha256:ad2cf8aa28b8c020ab2fc8287b0f823d0a7d8630784c31e9ee5edea20f406287", size = 13973, upload-time = "2025-09-27T18:37:04.929Z" }, - { url = "https://files.pythonhosted.org/packages/33/8a/8e42d4838cd89b7dde187011e97fe6c3af66d8c044997d2183fbd6d31352/markupsafe-3.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:eaa9599de571d72e2daf60164784109f19978b327a3910d3e9de8c97b5b70cfe", size = 11619, upload-time = "2025-09-27T18:37:06.342Z" }, - { url = "https://files.pythonhosted.org/packages/b5/64/7660f8a4a8e53c924d0fa05dc3a55c9cee10bbd82b11c5afb27d44b096ce/markupsafe-3.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c47a551199eb8eb2121d4f0f15ae0f923d31350ab9280078d1e5f12b249e0026", size = 12029, upload-time = "2025-09-27T18:37:07.213Z" }, - { url = "https://files.pythonhosted.org/packages/da/ef/e648bfd021127bef5fa12e1720ffed0c6cbb8310c8d9bea7266337ff06de/markupsafe-3.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f34c41761022dd093b4b6896d4810782ffbabe30f2d443ff5f083e0cbbb8c737", size = 24408, upload-time = "2025-09-27T18:37:09.572Z" }, - { url = "https://files.pythonhosted.org/packages/41/3c/a36c2450754618e62008bf7435ccb0f88053e07592e6028a34776213d877/markupsafe-3.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:457a69a9577064c05a97c41f4e65148652db078a3a509039e64d3467b9e7ef97", size = 23005, upload-time = "2025-09-27T18:37:10.58Z" }, - { url = "https://files.pythonhosted.org/packages/bc/20/b7fdf89a8456b099837cd1dc21974632a02a999ec9bf7ca3e490aacd98e7/markupsafe-3.0.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e8afc3f2ccfa24215f8cb28dcf43f0113ac3c37c2f0f0806d8c70e4228c5cf4d", size = 22048, upload-time = "2025-09-27T18:37:11.547Z" }, - { url = "https://files.pythonhosted.org/packages/9a/a7/591f592afdc734f47db08a75793a55d7fbcc6902a723ae4cfbab61010cc5/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:ec15a59cf5af7be74194f7ab02d0f59a62bdcf1a537677ce67a2537c9b87fcda", size = 23821, upload-time = "2025-09-27T18:37:12.48Z" }, - { url = "https://files.pythonhosted.org/packages/7d/33/45b24e4f44195b26521bc6f1a82197118f74df348556594bd2262bda1038/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:0eb9ff8191e8498cca014656ae6b8d61f39da5f95b488805da4bb029cccbfbaf", size = 21606, upload-time = "2025-09-27T18:37:13.485Z" }, - { url = "https://files.pythonhosted.org/packages/ff/0e/53dfaca23a69fbfbbf17a4b64072090e70717344c52eaaaa9c5ddff1e5f0/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:2713baf880df847f2bece4230d4d094280f4e67b1e813eec43b4c0e144a34ffe", size = 23043, upload-time = "2025-09-27T18:37:14.408Z" }, - { url = "https://files.pythonhosted.org/packages/46/11/f333a06fc16236d5238bfe74daccbca41459dcd8d1fa952e8fbd5dccfb70/markupsafe-3.0.3-cp314-cp314-win32.whl", hash = "sha256:729586769a26dbceff69f7a7dbbf59ab6572b99d94576a5592625d5b411576b9", size = 14747, upload-time = "2025-09-27T18:37:15.36Z" }, - { url = "https://files.pythonhosted.org/packages/28/52/182836104b33b444e400b14f797212f720cbc9ed6ba34c800639d154e821/markupsafe-3.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:bdc919ead48f234740ad807933cdf545180bfbe9342c2bb451556db2ed958581", size = 15341, upload-time = "2025-09-27T18:37:16.496Z" }, - { url = "https://files.pythonhosted.org/packages/6f/18/acf23e91bd94fd7b3031558b1f013adfa21a8e407a3fdb32745538730382/markupsafe-3.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:5a7d5dc5140555cf21a6fefbdbf8723f06fcd2f63ef108f2854de715e4422cb4", size = 14073, upload-time = "2025-09-27T18:37:17.476Z" }, - { url = "https://files.pythonhosted.org/packages/3c/f0/57689aa4076e1b43b15fdfa646b04653969d50cf30c32a102762be2485da/markupsafe-3.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:1353ef0c1b138e1907ae78e2f6c63ff67501122006b0f9abad68fda5f4ffc6ab", size = 11661, upload-time = "2025-09-27T18:37:18.453Z" }, - { url = "https://files.pythonhosted.org/packages/89/c3/2e67a7ca217c6912985ec766c6393b636fb0c2344443ff9d91404dc4c79f/markupsafe-3.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1085e7fbddd3be5f89cc898938f42c0b3c711fdcb37d75221de2666af647c175", size = 12069, upload-time = "2025-09-27T18:37:19.332Z" }, - { url = "https://files.pythonhosted.org/packages/f0/00/be561dce4e6ca66b15276e184ce4b8aec61fe83662cce2f7d72bd3249d28/markupsafe-3.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1b52b4fb9df4eb9ae465f8d0c228a00624de2334f216f178a995ccdcf82c4634", size = 25670, upload-time = "2025-09-27T18:37:20.245Z" }, - { url = "https://files.pythonhosted.org/packages/50/09/c419f6f5a92e5fadde27efd190eca90f05e1261b10dbd8cbcb39cd8ea1dc/markupsafe-3.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fed51ac40f757d41b7c48425901843666a6677e3e8eb0abcff09e4ba6e664f50", size = 23598, upload-time = "2025-09-27T18:37:21.177Z" }, - { url = "https://files.pythonhosted.org/packages/22/44/a0681611106e0b2921b3033fc19bc53323e0b50bc70cffdd19f7d679bb66/markupsafe-3.0.3-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f190daf01f13c72eac4efd5c430a8de82489d9cff23c364c3ea822545032993e", size = 23261, upload-time = "2025-09-27T18:37:22.167Z" }, - { url = "https://files.pythonhosted.org/packages/5f/57/1b0b3f100259dc9fffe780cfb60d4be71375510e435efec3d116b6436d43/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e56b7d45a839a697b5eb268c82a71bd8c7f6c94d6fd50c3d577fa39a9f1409f5", size = 24835, upload-time = "2025-09-27T18:37:23.296Z" }, - { url = "https://files.pythonhosted.org/packages/26/6a/4bf6d0c97c4920f1597cc14dd720705eca0bf7c787aebc6bb4d1bead5388/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:f3e98bb3798ead92273dc0e5fd0f31ade220f59a266ffd8a4f6065e0a3ce0523", size = 22733, upload-time = "2025-09-27T18:37:24.237Z" }, - { url = "https://files.pythonhosted.org/packages/14/c7/ca723101509b518797fedc2fdf79ba57f886b4aca8a7d31857ba3ee8281f/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5678211cb9333a6468fb8d8be0305520aa073f50d17f089b5b4b477ea6e67fdc", size = 23672, upload-time = "2025-09-27T18:37:25.271Z" }, - { url = "https://files.pythonhosted.org/packages/fb/df/5bd7a48c256faecd1d36edc13133e51397e41b73bb77e1a69deab746ebac/markupsafe-3.0.3-cp314-cp314t-win32.whl", hash = "sha256:915c04ba3851909ce68ccc2b8e2cd691618c4dc4c4232fb7982bca3f41fd8c3d", size = 14819, upload-time = "2025-09-27T18:37:26.285Z" }, - { url = "https://files.pythonhosted.org/packages/1a/8a/0402ba61a2f16038b48b39bccca271134be00c5c9f0f623208399333c448/markupsafe-3.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4faffd047e07c38848ce017e8725090413cd80cbc23d86e55c587bf979e579c9", size = 15426, upload-time = "2025-09-27T18:37:27.316Z" }, - { url = "https://files.pythonhosted.org/packages/70/bc/6f1c2f612465f5fa89b95bead1f44dcb607670fd42891d8fdcd5d039f4f4/markupsafe-3.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:32001d6a8fc98c8cb5c947787c5d08b0a50663d139f1305bac5885d98d9b40fa", size = 14146, upload-time = "2025-09-27T18:37:28.327Z" }, -] - -[[package]] -name = "matplotlib" -version = "3.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.2.1" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "traitlets" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/c7/74/97e72a36efd4ae2bccb3463284300f8953f199b5ffbc04cbbb0ec78f74b1/matplotlib_inline-0.2.1.tar.gz", hash = "sha256:e1ee949c340d771fc39e241ea75683deb94762c8fa5f2927ec57c83c4dffa9fe", size = 8110, upload-time = "2025-10-23T09:00:22.126Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/af/33/ee4519fa02ed11a94aef9559552f3b17bb863f2ecfe1a35dc7f548cde231/matplotlib_inline-0.2.1-py3-none-any.whl", hash = "sha256:d56ce5156ba6085e00a9d54fead6ed29a9c47e215cd1bba2e976ef39f5710a76", size = 9516, upload-time = "2025-10-23T09:00:20.675Z" }, -] - -[[package]] -name = "mistune" -version = "3.1.4" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/d7/02/a7fb8b21d4d55ac93cdcde9d3638da5dd0ebdd3a4fed76c7725e10b81cbe/mistune-3.1.4.tar.gz", hash = "sha256:b5a7f801d389f724ec702840c11d8fc48f2b33519102fc7ee739e8177b672164", size = 94588, upload-time = "2025-08-29T07:20:43.594Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/7a/f0/8282d9641415e9e33df173516226b404d367a0fc55e1a60424a152913abc/mistune-3.1.4-py3-none-any.whl", hash = "sha256:93691da911e5d9d2e23bc54472892aff676df27a75274962ff9edc210364266d", size = 53481, upload-time = "2025-08-29T07:20:42.218Z" }, -] - -[[package]] -name = "nbclient" -version = "0.10.2" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "jupyter-client" }, - { name = "jupyter-core" }, - { name = "nbformat" }, - { name = "traitlets" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/87/66/7ffd18d58eae90d5721f9f39212327695b749e23ad44b3881744eaf4d9e8/nbclient-0.10.2.tar.gz", hash = "sha256:90b7fc6b810630db87a6d0c2250b1f0ab4cf4d3c27a299b0cde78a4ed3fd9193", size = 62424, upload-time = "2024-12-19T10:32:27.164Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/34/6d/e7fa07f03a4a7b221d94b4d586edb754a9b0dc3c9e2c93353e9fa4e0d117/nbclient-0.10.2-py3-none-any.whl", hash = "sha256:4ffee11e788b4a27fabeb7955547e4318a5298f34342a4bfd01f2e1faaeadc3d", size = 25434, upload-time = "2024-12-19T10:32:24.139Z" }, -] - -[[package]] -name = "nbconvert" -version = "7.16.6" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "beautifulsoup4" }, - { name = "bleach", extra = ["css"] }, - { name = "defusedxml" }, - { name = "jinja2" }, - { name = "jupyter-core" }, - { name = "jupyterlab-pygments" }, - { name = "markupsafe" }, - { name = "mistune" }, - { name = "nbclient" }, - { name = "nbformat" }, - { name = "packaging" }, - { name = "pandocfilters" }, - { name = "pygments" }, - { name = "traitlets" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/a3/59/f28e15fc47ffb73af68a8d9b47367a8630d76e97ae85ad18271b9db96fdf/nbconvert-7.16.6.tar.gz", hash = "sha256:576a7e37c6480da7b8465eefa66c17844243816ce1ccc372633c6b71c3c0f582", size = 857715, upload-time = "2025-01-28T09:29:14.724Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/cc/9a/cd673b2f773a12c992f41309ef81b99da1690426bd2f96957a7ade0d3ed7/nbconvert-7.16.6-py3-none-any.whl", hash = "sha256:1375a7b67e0c2883678c48e506dc320febb57685e5ee67faa51b18a90f3a712b", size = 258525, upload-time = "2025-01-28T09:29:12.551Z" }, -] - -[[package]] -name = "nbformat" -version = "5.10.4" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "fastjsonschema" }, - { name = "jsonschema" }, - { name = "jupyter-core" }, - { name = "traitlets" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/6d/fd/91545e604bc3dad7dca9ed03284086039b294c6b3d75c0d2fa45f9e9caf3/nbformat-5.10.4.tar.gz", hash = "sha256:322168b14f937a5d11362988ecac2a4952d3d8e3a2cbeb2319584631226d5b3a", size = 142749, upload-time = "2024-04-04T11:20:37.371Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/a9/82/0340caa499416c78e5d8f5f05947ae4bc3cba53c9f038ab6e9ed964e22f1/nbformat-5.10.4-py3-none-any.whl", hash = "sha256:3b48d6c8fbca4b299bf3982ea7db1af21580e4fec269ad087b9e81588891200b", size = 78454, upload-time = "2024-04-04T11:20:34.895Z" }, -] - -[[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 = "notebook-shim" -version = "0.2.4" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "jupyter-server" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/54/d2/92fa3243712b9a3e8bafaf60aac366da1cada3639ca767ff4b5b3654ec28/notebook_shim-0.2.4.tar.gz", hash = "sha256:b4b2cfa1b65d98307ca24361f5b30fe785b53c3fd07b7a47e89acb5e6ac638cb", size = 13167, upload-time = "2024-02-14T23:35:18.353Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/f9/33/bd5b9137445ea4b680023eb0469b2bb969d61303dedb2aac6560ff3d14a1/notebook_shim-0.2.4-py3-none-any.whl", hash = "sha256:411a5be4e9dc882a074ccbcae671eda64cceb068767e9a3419096986560e1cef", size = 13307, upload-time = "2024-02-14T23:35:16.286Z" }, -] - -[[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 = "pandocfilters" -version = "1.5.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/70/6f/3dd4940bbe001c06a65f88e36bad298bc7a0de5036115639926b0c5c0458/pandocfilters-1.5.1.tar.gz", hash = "sha256:002b4a555ee4ebc03f8b66307e287fa492e4a77b4ea14d3f934328297bb4939e", size = 8454, upload-time = "2024-01-18T20:08:13.726Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/ef/af/4fbc8cab944db5d21b7e2a5b8e9211a03a79852b1157e2c102fcc61ac440/pandocfilters-1.5.1-py2.py3-none-any.whl", hash = "sha256:93be382804a9cdb0a7267585f157e5d1731bbe5545a85b268d6f5fe6232de2bc", size = 8663, upload-time = "2024-01-18T20:08:11.28Z" }, -] - -[[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 = "patsy" -version = "1.0.2" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "numpy" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/be/44/ed13eccdd0519eff265f44b670d46fbb0ec813e2274932dc1c0e48520f7d/patsy-1.0.2.tar.gz", hash = "sha256:cdc995455f6233e90e22de72c37fcadb344e7586fb83f06696f54d92f8ce74c0", size = 399942, upload-time = "2025-10-20T16:17:37.535Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/f1/70/ba4b949bdc0490ab78d545459acd7702b211dfccf7eb89bbc1060f52818d/patsy-1.0.2-py2.py3-none-any.whl", hash = "sha256:37bfddbc58fcf0362febb5f54f10743f8b21dd2aa73dec7e7ef59d1b02ae668a", size = 233301, upload-time = "2025-10-20T16:17:36.563Z" }, -] - -[[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 = "prometheus-client" -version = "0.23.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/23/53/3edb5d68ecf6b38fcbcc1ad28391117d2a322d9a1a3eff04bfdb184d8c3b/prometheus_client-0.23.1.tar.gz", hash = "sha256:6ae8f9081eaaaf153a2e959d2e6c4f4fb57b12ef76c8c7980202f1e57b48b2ce", size = 80481, upload-time = "2025-09-18T20:47:25.043Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/b8/db/14bafcb4af2139e046d03fd00dea7873e48eafe18b7d2797e73d6681f210/prometheus_client-0.23.1-py3-none-any.whl", hash = "sha256:dd1913e6e76b59cfe44e7a4b83e01afc9873c1bdfd2ed8739f1e76aeca115f99", size = 61145, upload-time = "2025-09-18T20:47:23.875Z" }, -] - -[[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.3" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/e1/88/bdd0a41e5857d5d703287598cbf08dad90aed56774ea52ae071bae9071b6/psutil-7.1.3.tar.gz", hash = "sha256:6c86281738d77335af7aec228328e944b30930899ea760ecf33a4dba66be5e74", size = 489059, upload-time = "2025-11-02T12:25:54.619Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/bd/93/0c49e776b8734fef56ec9c5c57f923922f2cf0497d62e0f419465f28f3d0/psutil-7.1.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0005da714eee687b4b8decd3d6cc7c6db36215c9e74e5ad2264b90c3df7d92dc", size = 239751, upload-time = "2025-11-02T12:25:58.161Z" }, - { url = "https://files.pythonhosted.org/packages/6f/8d/b31e39c769e70780f007969815195a55c81a63efebdd4dbe9e7a113adb2f/psutil-7.1.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:19644c85dcb987e35eeeaefdc3915d059dac7bd1167cdcdbf27e0ce2df0c08c0", size = 240368, upload-time = "2025-11-02T12:26:00.491Z" }, - { url = "https://files.pythonhosted.org/packages/62/61/23fd4acc3c9eebbf6b6c78bcd89e5d020cfde4acf0a9233e9d4e3fa698b4/psutil-7.1.3-cp313-cp313t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:95ef04cf2e5ba0ab9eaafc4a11eaae91b44f4ef5541acd2ee91d9108d00d59a7", size = 287134, upload-time = "2025-11-02T12:26:02.613Z" }, - { url = "https://files.pythonhosted.org/packages/30/1c/f921a009ea9ceb51aa355cb0cc118f68d354db36eae18174bab63affb3e6/psutil-7.1.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1068c303be3a72f8e18e412c5b2a8f6d31750fb152f9cb106b54090296c9d251", size = 289904, upload-time = "2025-11-02T12:26:05.207Z" }, - { url = "https://files.pythonhosted.org/packages/a6/82/62d68066e13e46a5116df187d319d1724b3f437ddd0f958756fc052677f4/psutil-7.1.3-cp313-cp313t-win_amd64.whl", hash = "sha256:18349c5c24b06ac5612c0428ec2a0331c26443d259e2a0144a9b24b4395b58fa", size = 249642, upload-time = "2025-11-02T12:26:07.447Z" }, - { url = "https://files.pythonhosted.org/packages/df/ad/c1cd5fe965c14a0392112f68362cfceb5230819dbb5b1888950d18a11d9f/psutil-7.1.3-cp313-cp313t-win_arm64.whl", hash = "sha256:c525ffa774fe4496282fb0b1187725793de3e7c6b29e41562733cae9ada151ee", size = 245518, upload-time = "2025-11-02T12:26:09.719Z" }, - { url = "https://files.pythonhosted.org/packages/2e/bb/6670bded3e3236eb4287c7bcdc167e9fae6e1e9286e437f7111caed2f909/psutil-7.1.3-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:b403da1df4d6d43973dc004d19cee3b848e998ae3154cc8097d139b77156c353", size = 239843, upload-time = "2025-11-02T12:26:11.968Z" }, - { url = "https://files.pythonhosted.org/packages/b8/66/853d50e75a38c9a7370ddbeefabdd3d3116b9c31ef94dc92c6729bc36bec/psutil-7.1.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ad81425efc5e75da3f39b3e636293360ad8d0b49bed7df824c79764fb4ba9b8b", size = 240369, upload-time = "2025-11-02T12:26:14.358Z" }, - { url = "https://files.pythonhosted.org/packages/41/bd/313aba97cb5bfb26916dc29cf0646cbe4dd6a89ca69e8c6edce654876d39/psutil-7.1.3-cp314-cp314t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8f33a3702e167783a9213db10ad29650ebf383946e91bc77f28a5eb083496bc9", size = 288210, upload-time = "2025-11-02T12:26:16.699Z" }, - { url = "https://files.pythonhosted.org/packages/c2/fa/76e3c06e760927a0cfb5705eb38164254de34e9bd86db656d4dbaa228b04/psutil-7.1.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fac9cd332c67f4422504297889da5ab7e05fd11e3c4392140f7370f4208ded1f", size = 291182, upload-time = "2025-11-02T12:26:18.848Z" }, - { url = "https://files.pythonhosted.org/packages/0f/1d/5774a91607035ee5078b8fd747686ebec28a962f178712de100d00b78a32/psutil-7.1.3-cp314-cp314t-win_amd64.whl", hash = "sha256:3792983e23b69843aea49c8f5b8f115572c5ab64c153bada5270086a2123c7e7", size = 250466, upload-time = "2025-11-02T12:26:21.183Z" }, - { url = "https://files.pythonhosted.org/packages/00/ca/e426584bacb43a5cb1ac91fae1937f478cd8fbe5e4ff96574e698a2c77cd/psutil-7.1.3-cp314-cp314t-win_arm64.whl", hash = "sha256:31d77fcedb7529f27bb3a0472bea9334349f9a04160e8e6e5020f22c59893264", size = 245756, upload-time = "2025-11-02T12:26:23.148Z" }, - { url = "https://files.pythonhosted.org/packages/ef/94/46b9154a800253e7ecff5aaacdf8ebf43db99de4a2dfa18575b02548654e/psutil-7.1.3-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:2bdbcd0e58ca14996a42adf3621a6244f1bb2e2e528886959c72cf1e326677ab", size = 238359, upload-time = "2025-11-02T12:26:25.284Z" }, - { url = "https://files.pythonhosted.org/packages/68/3a/9f93cff5c025029a36d9a92fef47220ab4692ee7f2be0fba9f92813d0cb8/psutil-7.1.3-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:bc31fa00f1fbc3c3802141eede66f3a2d51d89716a194bf2cd6fc68310a19880", size = 239171, upload-time = "2025-11-02T12:26:27.23Z" }, - { url = "https://files.pythonhosted.org/packages/ce/b1/5f49af514f76431ba4eea935b8ad3725cdeb397e9245ab919dbc1d1dc20f/psutil-7.1.3-cp36-abi3-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3bb428f9f05c1225a558f53e30ccbad9930b11c3fc206836242de1091d3e7dd3", size = 263261, upload-time = "2025-11-02T12:26:29.48Z" }, - { url = "https://files.pythonhosted.org/packages/e0/95/992c8816a74016eb095e73585d747e0a8ea21a061ed3689474fabb29a395/psutil-7.1.3-cp36-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:56d974e02ca2c8eb4812c3f76c30e28836fffc311d55d979f1465c1feeb2b68b", size = 264635, upload-time = "2025-11-02T12:26:31.74Z" }, - { url = "https://files.pythonhosted.org/packages/55/4c/c3ed1a622b6ae2fd3c945a366e64eb35247a31e4db16cf5095e269e8eb3c/psutil-7.1.3-cp37-abi3-win_amd64.whl", hash = "sha256:f39c2c19fe824b47484b96f9692932248a54c43799a84282cfe58d05a6449efd", size = 247633, upload-time = "2025-11-02T12:26:33.887Z" }, - { url = "https://files.pythonhosted.org/packages/c9/ad/33b2ccec09bf96c2b2ef3f9a6f66baac8253d7565d8839e024a6b905d45d/psutil-7.1.3-cp37-abi3-win_arm64.whl", hash = "sha256:bd0d69cee829226a761e92f28140bec9a5ee9d5b4fb4b0cc589068dbfff559b1", size = 244608, upload-time = "2025-11-02T12:26:36.136Z" }, -] - -[[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 = "pyarrow" -version = "22.0.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/30/53/04a7fdc63e6056116c9ddc8b43bc28c12cdd181b85cbeadb79278475f3ae/pyarrow-22.0.0.tar.gz", hash = "sha256:3d600dc583260d845c7d8a6db540339dd883081925da2bd1c5cb808f720b3cd9", size = 1151151, upload-time = "2025-10-24T12:30:00.762Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/af/63/ba23862d69652f85b615ca14ad14f3bcfc5bf1b99ef3f0cd04ff93fdad5a/pyarrow-22.0.0-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:bea79263d55c24a32b0d79c00a1c58bb2ee5f0757ed95656b01c0fb310c5af3d", size = 34211578, upload-time = "2025-10-24T10:05:21.583Z" }, - { url = "https://files.pythonhosted.org/packages/b1/d0/f9ad86fe809efd2bcc8be32032fa72e8b0d112b01ae56a053006376c5930/pyarrow-22.0.0-cp312-cp312-macosx_12_0_x86_64.whl", hash = "sha256:12fe549c9b10ac98c91cf791d2945e878875d95508e1a5d14091a7aaa66d9cf8", size = 35989906, upload-time = "2025-10-24T10:05:29.485Z" }, - { url = "https://files.pythonhosted.org/packages/b4/a8/f910afcb14630e64d673f15904ec27dd31f1e009b77033c365c84e8c1e1d/pyarrow-22.0.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:334f900ff08ce0423407af97e6c26ad5d4e3b0763645559ece6fbf3747d6a8f5", size = 45021677, upload-time = "2025-10-24T10:05:38.274Z" }, - { url = "https://files.pythonhosted.org/packages/13/95/aec81f781c75cd10554dc17a25849c720d54feafb6f7847690478dcf5ef8/pyarrow-22.0.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:c6c791b09c57ed76a18b03f2631753a4960eefbbca80f846da8baefc6491fcfe", size = 47726315, upload-time = "2025-10-24T10:05:47.314Z" }, - { url = "https://files.pythonhosted.org/packages/bb/d4/74ac9f7a54cfde12ee42734ea25d5a3c9a45db78f9def949307a92720d37/pyarrow-22.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:c3200cb41cdbc65156e5f8c908d739b0dfed57e890329413da2748d1a2cd1a4e", size = 47990906, upload-time = "2025-10-24T10:05:58.254Z" }, - { url = "https://files.pythonhosted.org/packages/2e/71/fedf2499bf7a95062eafc989ace56572f3343432570e1c54e6599d5b88da/pyarrow-22.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ac93252226cf288753d8b46280f4edf3433bf9508b6977f8dd8526b521a1bbb9", size = 50306783, upload-time = "2025-10-24T10:06:08.08Z" }, - { url = "https://files.pythonhosted.org/packages/68/ed/b202abd5a5b78f519722f3d29063dda03c114711093c1995a33b8e2e0f4b/pyarrow-22.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:44729980b6c50a5f2bfcc2668d36c569ce17f8b17bccaf470c4313dcbbf13c9d", size = 27972883, upload-time = "2025-10-24T10:06:14.204Z" }, - { url = "https://files.pythonhosted.org/packages/a6/d6/d0fac16a2963002fc22c8fa75180a838737203d558f0ed3b564c4a54eef5/pyarrow-22.0.0-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:e6e95176209257803a8b3d0394f21604e796dadb643d2f7ca21b66c9c0b30c9a", size = 34204629, upload-time = "2025-10-24T10:06:20.274Z" }, - { url = "https://files.pythonhosted.org/packages/c6/9c/1d6357347fbae062ad3f17082f9ebc29cc733321e892c0d2085f42a2212b/pyarrow-22.0.0-cp313-cp313-macosx_12_0_x86_64.whl", hash = "sha256:001ea83a58024818826a9e3f89bf9310a114f7e26dfe404a4c32686f97bd7901", size = 35985783, upload-time = "2025-10-24T10:06:27.301Z" }, - { url = "https://files.pythonhosted.org/packages/ff/c0/782344c2ce58afbea010150df07e3a2f5fdad299cd631697ae7bd3bac6e3/pyarrow-22.0.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:ce20fe000754f477c8a9125543f1936ea5b8867c5406757c224d745ed033e691", size = 45020999, upload-time = "2025-10-24T10:06:35.387Z" }, - { url = "https://files.pythonhosted.org/packages/1b/8b/5362443737a5307a7b67c1017c42cd104213189b4970bf607e05faf9c525/pyarrow-22.0.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:e0a15757fccb38c410947df156f9749ae4a3c89b2393741a50521f39a8cf202a", size = 47724601, upload-time = "2025-10-24T10:06:43.551Z" }, - { url = "https://files.pythonhosted.org/packages/69/4d/76e567a4fc2e190ee6072967cb4672b7d9249ac59ae65af2d7e3047afa3b/pyarrow-22.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:cedb9dd9358e4ea1d9bce3665ce0797f6adf97ff142c8e25b46ba9cdd508e9b6", size = 48001050, upload-time = "2025-10-24T10:06:52.284Z" }, - { url = "https://files.pythonhosted.org/packages/01/5e/5653f0535d2a1aef8223cee9d92944cb6bccfee5cf1cd3f462d7cb022790/pyarrow-22.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:252be4a05f9d9185bb8c18e83764ebcfea7185076c07a7a662253af3a8c07941", size = 50307877, upload-time = "2025-10-24T10:07:02.405Z" }, - { url = "https://files.pythonhosted.org/packages/2d/f8/1d0bd75bf9328a3b826e24a16e5517cd7f9fbf8d34a3184a4566ef5a7f29/pyarrow-22.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:a4893d31e5ef780b6edcaf63122df0f8d321088bb0dee4c8c06eccb1ca28d145", size = 27977099, upload-time = "2025-10-24T10:08:07.259Z" }, - { url = "https://files.pythonhosted.org/packages/90/81/db56870c997805bf2b0f6eeeb2d68458bf4654652dccdcf1bf7a42d80903/pyarrow-22.0.0-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:f7fe3dbe871294ba70d789be16b6e7e52b418311e166e0e3cba9522f0f437fb1", size = 34336685, upload-time = "2025-10-24T10:07:11.47Z" }, - { url = "https://files.pythonhosted.org/packages/1c/98/0727947f199aba8a120f47dfc229eeb05df15bcd7a6f1b669e9f882afc58/pyarrow-22.0.0-cp313-cp313t-macosx_12_0_x86_64.whl", hash = "sha256:ba95112d15fd4f1105fb2402c4eab9068f0554435e9b7085924bcfaac2cc306f", size = 36032158, upload-time = "2025-10-24T10:07:18.626Z" }, - { url = "https://files.pythonhosted.org/packages/96/b4/9babdef9c01720a0785945c7cf550e4acd0ebcd7bdd2e6f0aa7981fa85e2/pyarrow-22.0.0-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:c064e28361c05d72eed8e744c9605cbd6d2bb7481a511c74071fd9b24bc65d7d", size = 44892060, upload-time = "2025-10-24T10:07:26.002Z" }, - { url = "https://files.pythonhosted.org/packages/f8/ca/2f8804edd6279f78a37062d813de3f16f29183874447ef6d1aadbb4efa0f/pyarrow-22.0.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:6f9762274496c244d951c819348afbcf212714902742225f649cf02823a6a10f", size = 47504395, upload-time = "2025-10-24T10:07:34.09Z" }, - { url = "https://files.pythonhosted.org/packages/b9/f0/77aa5198fd3943682b2e4faaf179a674f0edea0d55d326d83cb2277d9363/pyarrow-22.0.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:a9d9ffdc2ab696f6b15b4d1f7cec6658e1d788124418cb30030afbae31c64746", size = 48066216, upload-time = "2025-10-24T10:07:43.528Z" }, - { url = "https://files.pythonhosted.org/packages/79/87/a1937b6e78b2aff18b706d738c9e46ade5bfcf11b294e39c87706a0089ac/pyarrow-22.0.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:ec1a15968a9d80da01e1d30349b2b0d7cc91e96588ee324ce1b5228175043e95", size = 50288552, upload-time = "2025-10-24T10:07:53.519Z" }, - { url = "https://files.pythonhosted.org/packages/60/ae/b5a5811e11f25788ccfdaa8f26b6791c9807119dffcf80514505527c384c/pyarrow-22.0.0-cp313-cp313t-win_amd64.whl", hash = "sha256:bba208d9c7decf9961998edf5c65e3ea4355d5818dd6cd0f6809bec1afb951cc", size = 28262504, upload-time = "2025-10-24T10:08:00.932Z" }, - { url = "https://files.pythonhosted.org/packages/bd/b0/0fa4d28a8edb42b0a7144edd20befd04173ac79819547216f8a9f36f9e50/pyarrow-22.0.0-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:9bddc2cade6561f6820d4cd73f99a0243532ad506bc510a75a5a65a522b2d74d", size = 34224062, upload-time = "2025-10-24T10:08:14.101Z" }, - { url = "https://files.pythonhosted.org/packages/0f/a8/7a719076b3c1be0acef56a07220c586f25cd24de0e3f3102b438d18ae5df/pyarrow-22.0.0-cp314-cp314-macosx_12_0_x86_64.whl", hash = "sha256:e70ff90c64419709d38c8932ea9fe1cc98415c4f87ea8da81719e43f02534bc9", size = 35990057, upload-time = "2025-10-24T10:08:21.842Z" }, - { url = "https://files.pythonhosted.org/packages/89/3c/359ed54c93b47fb6fe30ed16cdf50e3f0e8b9ccfb11b86218c3619ae50a8/pyarrow-22.0.0-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:92843c305330aa94a36e706c16209cd4df274693e777ca47112617db7d0ef3d7", size = 45068002, upload-time = "2025-10-24T10:08:29.034Z" }, - { url = "https://files.pythonhosted.org/packages/55/fc/4945896cc8638536ee787a3bd6ce7cec8ec9acf452d78ec39ab328efa0a1/pyarrow-22.0.0-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:6dda1ddac033d27421c20d7a7943eec60be44e0db4e079f33cc5af3b8280ccde", size = 47737765, upload-time = "2025-10-24T10:08:38.559Z" }, - { url = "https://files.pythonhosted.org/packages/cd/5e/7cb7edeb2abfaa1f79b5d5eb89432356155c8426f75d3753cbcb9592c0fd/pyarrow-22.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:84378110dd9a6c06323b41b56e129c504d157d1a983ce8f5443761eb5256bafc", size = 48048139, upload-time = "2025-10-24T10:08:46.784Z" }, - { url = "https://files.pythonhosted.org/packages/88/c6/546baa7c48185f5e9d6e59277c4b19f30f48c94d9dd938c2a80d4d6b067c/pyarrow-22.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:854794239111d2b88b40b6ef92aa478024d1e5074f364033e73e21e3f76b25e0", size = 50314244, upload-time = "2025-10-24T10:08:55.771Z" }, - { url = "https://files.pythonhosted.org/packages/3c/79/755ff2d145aafec8d347bf18f95e4e81c00127f06d080135dfc86aea417c/pyarrow-22.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:b883fe6fd85adad7932b3271c38ac289c65b7337c2c132e9569f9d3940620730", size = 28757501, upload-time = "2025-10-24T10:09:59.891Z" }, - { url = "https://files.pythonhosted.org/packages/0e/d2/237d75ac28ced3147912954e3c1a174df43a95f4f88e467809118a8165e0/pyarrow-22.0.0-cp314-cp314t-macosx_12_0_arm64.whl", hash = "sha256:7a820d8ae11facf32585507c11f04e3f38343c1e784c9b5a8b1da5c930547fe2", size = 34355506, upload-time = "2025-10-24T10:09:02.953Z" }, - { url = "https://files.pythonhosted.org/packages/1e/2c/733dfffe6d3069740f98e57ff81007809067d68626c5faef293434d11bd6/pyarrow-22.0.0-cp314-cp314t-macosx_12_0_x86_64.whl", hash = "sha256:c6ec3675d98915bf1ec8b3c7986422682f7232ea76cad276f4c8abd5b7319b70", size = 36047312, upload-time = "2025-10-24T10:09:10.334Z" }, - { url = "https://files.pythonhosted.org/packages/7c/2b/29d6e3782dc1f299727462c1543af357a0f2c1d3c160ce199950d9ca51eb/pyarrow-22.0.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:3e739edd001b04f654b166204fc7a9de896cf6007eaff33409ee9e50ceaff754", size = 45081609, upload-time = "2025-10-24T10:09:18.61Z" }, - { url = "https://files.pythonhosted.org/packages/8d/42/aa9355ecc05997915af1b7b947a7f66c02dcaa927f3203b87871c114ba10/pyarrow-22.0.0-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:7388ac685cab5b279a41dfe0a6ccd99e4dbf322edfb63e02fc0443bf24134e91", size = 47703663, upload-time = "2025-10-24T10:09:27.369Z" }, - { url = "https://files.pythonhosted.org/packages/ee/62/45abedde480168e83a1de005b7b7043fd553321c1e8c5a9a114425f64842/pyarrow-22.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:f633074f36dbc33d5c05b5dc75371e5660f1dbf9c8b1d95669def05e5425989c", size = 48066543, upload-time = "2025-10-24T10:09:34.908Z" }, - { url = "https://files.pythonhosted.org/packages/84/e9/7878940a5b072e4f3bf998770acafeae13b267f9893af5f6d4ab3904b67e/pyarrow-22.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:4c19236ae2402a8663a2c8f21f1870a03cc57f0bef7e4b6eb3238cc82944de80", size = 50288838, upload-time = "2025-10-24T10:09:44.394Z" }, - { url = "https://files.pythonhosted.org/packages/7b/03/f335d6c52b4a4761bcc83499789a1e2e16d9d201a58c327a9b5cc9a41bd9/pyarrow-22.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:0c34fe18094686194f204a3b1787a27456897d8a2d62caf84b61e8dfbc0252ae", size = 29185594, upload-time = "2025-10-24T10:09:53.111Z" }, -] - -[[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 = "python-json-logger" -version = "4.0.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/29/bf/eca6a3d43db1dae7070f70e160ab20b807627ba953663ba07928cdd3dc58/python_json_logger-4.0.0.tar.gz", hash = "sha256:f58e68eb46e1faed27e0f574a55a0455eecd7b8a5b88b85a784519ba3cff047f", size = 17683, upload-time = "2025-10-06T04:15:18.984Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/51/e5/fecf13f06e5e5f67e8837d777d1bc43fac0ed2b77a676804df5c34744727/python_json_logger-4.0.0-py3-none-any.whl", hash = "sha256:af09c9daf6a813aa4cc7180395f50f2a9e5fa056034c9953aec92e381c5ba1e2", size = 15548, upload-time = "2025-10-06T04:15:17.553Z" }, -] - -[[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 = "pywinpty" -version = "3.0.2" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/f3/bb/a7cc2967c5c4eceb6cc49cfe39447d4bfc56e6c865e7c2249b6eb978935f/pywinpty-3.0.2.tar.gz", hash = "sha256:1505cc4cb248af42cb6285a65c9c2086ee9e7e574078ee60933d5d7fa86fb004", size = 30669, upload-time = "2025-10-03T21:16:29.205Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/02/4e/1098484e042c9485f56f16eb2b69b43b874bd526044ee401512234cf9e04/pywinpty-3.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:99fdd9b455f0ad6419aba6731a7a0d2f88ced83c3c94a80ff9533d95fa8d8a9e", size = 2050391, upload-time = "2025-10-03T21:19:01.642Z" }, - { url = "https://files.pythonhosted.org/packages/fc/19/b757fe28008236a4a713e813283721b8a40aa60cd7d3f83549f2e25a3155/pywinpty-3.0.2-cp313-cp313-win_amd64.whl", hash = "sha256:18f78b81e4cfee6aabe7ea8688441d30247b73e52cd9657138015c5f4ee13a51", size = 2050057, upload-time = "2025-10-03T21:19:26.732Z" }, - { url = "https://files.pythonhosted.org/packages/cb/44/cbae12ecf6f4fa4129c36871fd09c6bef4f98d5f625ecefb5e2449765508/pywinpty-3.0.2-cp313-cp313t-win_amd64.whl", hash = "sha256:663383ecfab7fc382cc97ea5c4f7f0bb32c2f889259855df6ea34e5df42d305b", size = 2049874, upload-time = "2025-10-03T21:18:53.923Z" }, - { url = "https://files.pythonhosted.org/packages/ca/15/f12c6055e2d7a617d4d5820e8ac4ceaff849da4cb124640ef5116a230771/pywinpty-3.0.2-cp314-cp314-win_amd64.whl", hash = "sha256:28297cecc37bee9f24d8889e47231972d6e9e84f7b668909de54f36ca785029a", size = 2050386, upload-time = "2025-10-03T21:18:50.477Z" }, - { url = "https://files.pythonhosted.org/packages/de/24/c6907c5bb06043df98ad6a0a0ff5db2e0affcecbc3b15c42404393a3f72a/pywinpty-3.0.2-cp314-cp314t-win_amd64.whl", hash = "sha256:34b55ae9a1b671fe3eae071d86618110538e8eaad18fcb1531c0830b91a82767", size = 2049834, upload-time = "2025-10-03T21:19:25.688Z" }, -] - -[[package]] -name = "pyyaml" -version = "6.0.3" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/d1/33/422b98d2195232ca1826284a76852ad5a86fe23e31b009c9886b2d0fb8b2/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", size = 182063, upload-time = "2025-09-25T21:32:11.445Z" }, - { url = "https://files.pythonhosted.org/packages/89/a0/6cf41a19a1f2f3feab0e9c0b74134aa2ce6849093d5517a0c550fe37a648/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0", size = 173973, upload-time = "2025-09-25T21:32:12.492Z" }, - { url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116, upload-time = "2025-09-25T21:32:13.652Z" }, - { url = "https://files.pythonhosted.org/packages/65/30/d7353c338e12baef4ecc1b09e877c1970bd3382789c159b4f89d6a70dc09/pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c", size = 844011, upload-time = "2025-09-25T21:32:15.21Z" }, - { url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", size = 807870, upload-time = "2025-09-25T21:32:16.431Z" }, - { url = "https://files.pythonhosted.org/packages/05/c0/b3be26a015601b822b97d9149ff8cb5ead58c66f981e04fedf4e762f4bd4/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e", size = 761089, upload-time = "2025-09-25T21:32:17.56Z" }, - { url = "https://files.pythonhosted.org/packages/be/8e/98435a21d1d4b46590d5459a22d88128103f8da4c2d4cb8f14f2a96504e1/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", size = 790181, upload-time = "2025-09-25T21:32:18.834Z" }, - { url = "https://files.pythonhosted.org/packages/74/93/7baea19427dcfbe1e5a372d81473250b379f04b1bd3c4c5ff825e2327202/pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5", size = 137658, upload-time = "2025-09-25T21:32:20.209Z" }, - { url = "https://files.pythonhosted.org/packages/86/bf/899e81e4cce32febab4fb42bb97dcdf66bc135272882d1987881a4b519e9/pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b", size = 154003, upload-time = "2025-09-25T21:32:21.167Z" }, - { url = "https://files.pythonhosted.org/packages/1a/08/67bd04656199bbb51dbed1439b7f27601dfb576fb864099c7ef0c3e55531/pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd", size = 140344, upload-time = "2025-09-25T21:32:22.617Z" }, - { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669, upload-time = "2025-09-25T21:32:23.673Z" }, - { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252, upload-time = "2025-09-25T21:32:25.149Z" }, - { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081, upload-time = "2025-09-25T21:32:26.575Z" }, - { url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159, upload-time = "2025-09-25T21:32:27.727Z" }, - { url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626, upload-time = "2025-09-25T21:32:28.878Z" }, - { url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613, upload-time = "2025-09-25T21:32:30.178Z" }, - { url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115, upload-time = "2025-09-25T21:32:31.353Z" }, - { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427, upload-time = "2025-09-25T21:32:32.58Z" }, - { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090, upload-time = "2025-09-25T21:32:33.659Z" }, - { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246, upload-time = "2025-09-25T21:32:34.663Z" }, - { url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814, upload-time = "2025-09-25T21:32:35.712Z" }, - { url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809, upload-time = "2025-09-25T21:32:36.789Z" }, - { url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454, upload-time = "2025-09-25T21:32:37.966Z" }, - { url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355, upload-time = "2025-09-25T21:32:39.178Z" }, - { url = "https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175, upload-time = "2025-09-25T21:32:40.865Z" }, - { url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228, upload-time = "2025-09-25T21:32:42.084Z" }, - { url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194, upload-time = "2025-09-25T21:32:43.362Z" }, - { url = "https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", size = 156429, upload-time = "2025-09-25T21:32:57.844Z" }, - { url = "https://files.pythonhosted.org/packages/f4/f4/a4541072bb9422c8a883ab55255f918fa378ecf083f5b85e87fc2b4eda1b/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", size = 143912, upload-time = "2025-09-25T21:32:59.247Z" }, - { url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108, upload-time = "2025-09-25T21:32:44.377Z" }, - { url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641, upload-time = "2025-09-25T21:32:45.407Z" }, - { url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901, upload-time = "2025-09-25T21:32:48.83Z" }, - { url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132, upload-time = "2025-09-25T21:32:50.149Z" }, - { url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261, upload-time = "2025-09-25T21:32:51.808Z" }, - { url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272, upload-time = "2025-09-25T21:32:52.941Z" }, - { url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923, upload-time = "2025-09-25T21:32:54.537Z" }, - { url = "https://files.pythonhosted.org/packages/f0/7a/1c7270340330e575b92f397352af856a8c06f230aa3e76f86b39d01b416a/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", size = 174062, upload-time = "2025-09-25T21:32:55.767Z" }, - { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" }, -] - -[[package]] -name = "pyzmq" -version = "27.1.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "cffi", marker = "implementation_name == 'pypy'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/04/0b/3c9baedbdf613ecaa7aa07027780b8867f57b6293b6ee50de316c9f3222b/pyzmq-27.1.0.tar.gz", hash = "sha256:ac0765e3d44455adb6ddbf4417dcce460fc40a05978c08efdf2948072f6db540", size = 281750, upload-time = "2025-09-08T23:10:18.157Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/92/e7/038aab64a946d535901103da16b953c8c9cc9c961dadcbf3609ed6428d23/pyzmq-27.1.0-cp312-abi3-macosx_10_15_universal2.whl", hash = "sha256:452631b640340c928fa343801b0d07eb0c3789a5ffa843f6e1a9cee0ba4eb4fc", size = 1306279, upload-time = "2025-09-08T23:08:03.807Z" }, - { url = "https://files.pythonhosted.org/packages/e8/5e/c3c49fdd0f535ef45eefcc16934648e9e59dace4a37ee88fc53f6cd8e641/pyzmq-27.1.0-cp312-abi3-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:1c179799b118e554b66da67d88ed66cd37a169f1f23b5d9f0a231b4e8d44a113", size = 895645, upload-time = "2025-09-08T23:08:05.301Z" }, - { url = "https://files.pythonhosted.org/packages/f8/e5/b0b2504cb4e903a74dcf1ebae157f9e20ebb6ea76095f6cfffea28c42ecd/pyzmq-27.1.0-cp312-abi3-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3837439b7f99e60312f0c926a6ad437b067356dc2bc2ec96eb395fd0fe804233", size = 652574, upload-time = "2025-09-08T23:08:06.828Z" }, - { url = "https://files.pythonhosted.org/packages/f8/9b/c108cdb55560eaf253f0cbdb61b29971e9fb34d9c3499b0e96e4e60ed8a5/pyzmq-27.1.0-cp312-abi3-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:43ad9a73e3da1fab5b0e7e13402f0b2fb934ae1c876c51d0afff0e7c052eca31", size = 840995, upload-time = "2025-09-08T23:08:08.396Z" }, - { url = "https://files.pythonhosted.org/packages/c2/bb/b79798ca177b9eb0825b4c9998c6af8cd2a7f15a6a1a4272c1d1a21d382f/pyzmq-27.1.0-cp312-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:0de3028d69d4cdc475bfe47a6128eb38d8bc0e8f4d69646adfbcd840facbac28", size = 1642070, upload-time = "2025-09-08T23:08:09.989Z" }, - { url = "https://files.pythonhosted.org/packages/9c/80/2df2e7977c4ede24c79ae39dcef3899bfc5f34d1ca7a5b24f182c9b7a9ca/pyzmq-27.1.0-cp312-abi3-musllinux_1_2_i686.whl", hash = "sha256:cf44a7763aea9298c0aa7dbf859f87ed7012de8bda0f3977b6fb1d96745df856", size = 2021121, upload-time = "2025-09-08T23:08:11.907Z" }, - { url = "https://files.pythonhosted.org/packages/46/bd/2d45ad24f5f5ae7e8d01525eb76786fa7557136555cac7d929880519e33a/pyzmq-27.1.0-cp312-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:f30f395a9e6fbca195400ce833c731e7b64c3919aa481af4d88c3759e0cb7496", size = 1878550, upload-time = "2025-09-08T23:08:13.513Z" }, - { url = "https://files.pythonhosted.org/packages/e6/2f/104c0a3c778d7c2ab8190e9db4f62f0b6957b53c9d87db77c284b69f33ea/pyzmq-27.1.0-cp312-abi3-win32.whl", hash = "sha256:250e5436a4ba13885494412b3da5d518cd0d3a278a1ae640e113c073a5f88edd", size = 559184, upload-time = "2025-09-08T23:08:15.163Z" }, - { url = "https://files.pythonhosted.org/packages/fc/7f/a21b20d577e4100c6a41795842028235998a643b1ad406a6d4163ea8f53e/pyzmq-27.1.0-cp312-abi3-win_amd64.whl", hash = "sha256:9ce490cf1d2ca2ad84733aa1d69ce6855372cb5ce9223802450c9b2a7cba0ccf", size = 619480, upload-time = "2025-09-08T23:08:17.192Z" }, - { url = "https://files.pythonhosted.org/packages/78/c2/c012beae5f76b72f007a9e91ee9401cb88c51d0f83c6257a03e785c81cc2/pyzmq-27.1.0-cp312-abi3-win_arm64.whl", hash = "sha256:75a2f36223f0d535a0c919e23615fc85a1e23b71f40c7eb43d7b1dedb4d8f15f", size = 552993, upload-time = "2025-09-08T23:08:18.926Z" }, - { url = "https://files.pythonhosted.org/packages/60/cb/84a13459c51da6cec1b7b1dc1a47e6db6da50b77ad7fd9c145842750a011/pyzmq-27.1.0-cp313-cp313-android_24_arm64_v8a.whl", hash = "sha256:93ad4b0855a664229559e45c8d23797ceac03183c7b6f5b4428152a6b06684a5", size = 1122436, upload-time = "2025-09-08T23:08:20.801Z" }, - { url = "https://files.pythonhosted.org/packages/dc/b6/94414759a69a26c3dd674570a81813c46a078767d931a6c70ad29fc585cb/pyzmq-27.1.0-cp313-cp313-android_24_x86_64.whl", hash = "sha256:fbb4f2400bfda24f12f009cba62ad5734148569ff4949b1b6ec3b519444342e6", size = 1156301, upload-time = "2025-09-08T23:08:22.47Z" }, - { url = "https://files.pythonhosted.org/packages/a5/ad/15906493fd40c316377fd8a8f6b1f93104f97a752667763c9b9c1b71d42d/pyzmq-27.1.0-cp313-cp313t-macosx_10_15_universal2.whl", hash = "sha256:e343d067f7b151cfe4eb3bb796a7752c9d369eed007b91231e817071d2c2fec7", size = 1341197, upload-time = "2025-09-08T23:08:24.286Z" }, - { url = "https://files.pythonhosted.org/packages/14/1d/d343f3ce13db53a54cb8946594e567410b2125394dafcc0268d8dda027e0/pyzmq-27.1.0-cp313-cp313t-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:08363b2011dec81c354d694bdecaef4770e0ae96b9afea70b3f47b973655cc05", size = 897275, upload-time = "2025-09-08T23:08:26.063Z" }, - { url = "https://files.pythonhosted.org/packages/69/2d/d83dd6d7ca929a2fc67d2c3005415cdf322af7751d773524809f9e585129/pyzmq-27.1.0-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d54530c8c8b5b8ddb3318f481297441af102517602b569146185fa10b63f4fa9", size = 660469, upload-time = "2025-09-08T23:08:27.623Z" }, - { url = "https://files.pythonhosted.org/packages/3e/cd/9822a7af117f4bc0f1952dbe9ef8358eb50a24928efd5edf54210b850259/pyzmq-27.1.0-cp313-cp313t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6f3afa12c392f0a44a2414056d730eebc33ec0926aae92b5ad5cf26ebb6cc128", size = 847961, upload-time = "2025-09-08T23:08:29.672Z" }, - { url = "https://files.pythonhosted.org/packages/9a/12/f003e824a19ed73be15542f172fd0ec4ad0b60cf37436652c93b9df7c585/pyzmq-27.1.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:c65047adafe573ff023b3187bb93faa583151627bc9c51fc4fb2c561ed689d39", size = 1650282, upload-time = "2025-09-08T23:08:31.349Z" }, - { url = "https://files.pythonhosted.org/packages/d5/4a/e82d788ed58e9a23995cee70dbc20c9aded3d13a92d30d57ec2291f1e8a3/pyzmq-27.1.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:90e6e9441c946a8b0a667356f7078d96411391a3b8f80980315455574177ec97", size = 2024468, upload-time = "2025-09-08T23:08:33.543Z" }, - { url = "https://files.pythonhosted.org/packages/d9/94/2da0a60841f757481e402b34bf4c8bf57fa54a5466b965de791b1e6f747d/pyzmq-27.1.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:add071b2d25f84e8189aaf0882d39a285b42fa3853016ebab234a5e78c7a43db", size = 1885394, upload-time = "2025-09-08T23:08:35.51Z" }, - { url = "https://files.pythonhosted.org/packages/4f/6f/55c10e2e49ad52d080dc24e37adb215e5b0d64990b57598abc2e3f01725b/pyzmq-27.1.0-cp313-cp313t-win32.whl", hash = "sha256:7ccc0700cfdf7bd487bea8d850ec38f204478681ea02a582a8da8171b7f90a1c", size = 574964, upload-time = "2025-09-08T23:08:37.178Z" }, - { url = "https://files.pythonhosted.org/packages/87/4d/2534970ba63dd7c522d8ca80fb92777f362c0f321900667c615e2067cb29/pyzmq-27.1.0-cp313-cp313t-win_amd64.whl", hash = "sha256:8085a9fba668216b9b4323be338ee5437a235fe275b9d1610e422ccc279733e2", size = 641029, upload-time = "2025-09-08T23:08:40.595Z" }, - { url = "https://files.pythonhosted.org/packages/f6/fa/f8aea7a28b0641f31d40dea42d7ef003fded31e184ef47db696bc74cd610/pyzmq-27.1.0-cp313-cp313t-win_arm64.whl", hash = "sha256:6bb54ca21bcfe361e445256c15eedf083f153811c37be87e0514934d6913061e", size = 561541, upload-time = "2025-09-08T23:08:42.668Z" }, - { url = "https://files.pythonhosted.org/packages/87/45/19efbb3000956e82d0331bafca5d9ac19ea2857722fa2caacefb6042f39d/pyzmq-27.1.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:ce980af330231615756acd5154f29813d553ea555485ae712c491cd483df6b7a", size = 1341197, upload-time = "2025-09-08T23:08:44.973Z" }, - { url = "https://files.pythonhosted.org/packages/48/43/d72ccdbf0d73d1343936296665826350cb1e825f92f2db9db3e61c2162a2/pyzmq-27.1.0-cp314-cp314t-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:1779be8c549e54a1c38f805e56d2a2e5c009d26de10921d7d51cfd1c8d4632ea", size = 897175, upload-time = "2025-09-08T23:08:46.601Z" }, - { url = "https://files.pythonhosted.org/packages/2f/2e/a483f73a10b65a9ef0161e817321d39a770b2acf8bcf3004a28d90d14a94/pyzmq-27.1.0-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7200bb0f03345515df50d99d3db206a0a6bee1955fbb8c453c76f5bf0e08fb96", size = 660427, upload-time = "2025-09-08T23:08:48.187Z" }, - { url = "https://files.pythonhosted.org/packages/f5/d2/5f36552c2d3e5685abe60dfa56f91169f7a2d99bbaf67c5271022ab40863/pyzmq-27.1.0-cp314-cp314t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:01c0e07d558b06a60773744ea6251f769cd79a41a97d11b8bf4ab8f034b0424d", size = 847929, upload-time = "2025-09-08T23:08:49.76Z" }, - { url = "https://files.pythonhosted.org/packages/c4/2a/404b331f2b7bf3198e9945f75c4c521f0c6a3a23b51f7a4a401b94a13833/pyzmq-27.1.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:80d834abee71f65253c91540445d37c4c561e293ba6e741b992f20a105d69146", size = 1650193, upload-time = "2025-09-08T23:08:51.7Z" }, - { url = "https://files.pythonhosted.org/packages/1c/0b/f4107e33f62a5acf60e3ded67ed33d79b4ce18de432625ce2fc5093d6388/pyzmq-27.1.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:544b4e3b7198dde4a62b8ff6685e9802a9a1ebf47e77478a5eb88eca2a82f2fd", size = 2024388, upload-time = "2025-09-08T23:08:53.393Z" }, - { url = "https://files.pythonhosted.org/packages/0d/01/add31fe76512642fd6e40e3a3bd21f4b47e242c8ba33efb6809e37076d9b/pyzmq-27.1.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:cedc4c68178e59a4046f97eca31b148ddcf51e88677de1ef4e78cf06c5376c9a", size = 1885316, upload-time = "2025-09-08T23:08:55.702Z" }, - { url = "https://files.pythonhosted.org/packages/c4/59/a5f38970f9bf07cee96128de79590bb354917914a9be11272cfc7ff26af0/pyzmq-27.1.0-cp314-cp314t-win32.whl", hash = "sha256:1f0b2a577fd770aa6f053211a55d1c47901f4d537389a034c690291485e5fe92", size = 587472, upload-time = "2025-09-08T23:08:58.18Z" }, - { url = "https://files.pythonhosted.org/packages/70/d8/78b1bad170f93fcf5e3536e70e8fadac55030002275c9a29e8f5719185de/pyzmq-27.1.0-cp314-cp314t-win_amd64.whl", hash = "sha256:19c9468ae0437f8074af379e986c5d3d7d7bfe033506af442e8c879732bedbe0", size = 661401, upload-time = "2025-09-08T23:08:59.802Z" }, - { url = "https://files.pythonhosted.org/packages/81/d6/4bfbb40c9a0b42fc53c7cf442f6385db70b40f74a783130c5d0a5aa62228/pyzmq-27.1.0-cp314-cp314t-win_arm64.whl", hash = "sha256:dc5dbf68a7857b59473f7df42650c621d7e8923fb03fa74a526890f4d33cc4d7", size = 575170, upload-time = "2025-09-08T23:09:01.418Z" }, -] - -[[package]] -name = "referencing" -version = "0.37.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "attrs" }, - { name = "rpds-py" }, - { name = "typing-extensions", marker = "python_full_version < '3.13'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/22/f5/df4e9027acead3ecc63e50fe1e36aca1523e1719559c499951bb4b53188f/referencing-0.37.0.tar.gz", hash = "sha256:44aefc3142c5b842538163acb373e24cce6632bd54bdb01b21ad5863489f50d8", size = 78036, upload-time = "2025-10-13T15:30:48.871Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/2c/58/ca301544e1fa93ed4f80d724bf5b194f6e4b945841c5bfd555878eea9fcb/referencing-0.37.0-py3-none-any.whl", hash = "sha256:381329a9f99628c9069361716891d34ad94af76e461dcb0335825aecc7692231", size = 26766, upload-time = "2025-10-13T15:30:47.625Z" }, -] - -[[package]] -name = "requests" -version = "2.32.5" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "certifi" }, - { name = "charset-normalizer" }, - { name = "idna" }, - { name = "urllib3" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/c9/74/b3ff8e6c8446842c3f5c837e9c3dfcfe2018ea6ecef224c710c85ef728f4/requests-2.32.5.tar.gz", hash = "sha256:dbba0bac56e100853db0ea71b82b4dfd5fe2bf6d3754a8893c3af500cec7d7cf", size = 134517, upload-time = "2025-08-18T20:46:02.573Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/1e/db/4254e3eabe8020b458f1a747140d32277ec7a271daf1d235b70dc0b4e6e3/requests-2.32.5-py3-none-any.whl", hash = "sha256:2462f94637a34fd532264295e186976db0f5d453d1cdd31473c85a6a161affb6", size = 64738, upload-time = "2025-08-18T20:46:00.542Z" }, -] - -[[package]] -name = "rfc3339-validator" -version = "0.1.4" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "six" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/28/ea/a9387748e2d111c3c2b275ba970b735e04e15cdb1eb30693b6b5708c4dbd/rfc3339_validator-0.1.4.tar.gz", hash = "sha256:138a2abdf93304ad60530167e51d2dfb9549521a836871b88d7f4695d0022f6b", size = 5513, upload-time = "2021-05-12T16:37:54.178Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/7b/44/4e421b96b67b2daff264473f7465db72fbdf36a07e05494f50300cc7b0c6/rfc3339_validator-0.1.4-py2.py3-none-any.whl", hash = "sha256:24f6ec1eda14ef823da9e36ec7113124b39c04d50a4d3d3a3c2859577e7791fa", size = 3490, upload-time = "2021-05-12T16:37:52.536Z" }, -] - -[[package]] -name = "rfc3986-validator" -version = "0.1.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/da/88/f270de456dd7d11dcc808abfa291ecdd3f45ff44e3b549ffa01b126464d0/rfc3986_validator-0.1.1.tar.gz", hash = "sha256:3d44bde7921b3b9ec3ae4e3adca370438eccebc676456449b145d533b240d055", size = 6760, upload-time = "2019-10-28T16:00:19.144Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/9e/51/17023c0f8f1869d8806b979a2bffa3f861f26a3f1a66b094288323fba52f/rfc3986_validator-0.1.1-py2.py3-none-any.whl", hash = "sha256:2f235c432ef459970b4306369336b9d5dbdda31b510ca1e327636e01f528bfa9", size = 4242, upload-time = "2019-10-28T16:00:13.976Z" }, -] - -[[package]] -name = "rfc3987-syntax" -version = "1.1.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "lark" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/2c/06/37c1a5557acf449e8e406a830a05bf885ac47d33270aec454ef78675008d/rfc3987_syntax-1.1.0.tar.gz", hash = "sha256:717a62cbf33cffdd16dfa3a497d81ce48a660ea691b1ddd7be710c22f00b4a0d", size = 14239, upload-time = "2025-07-18T01:05:05.015Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/7e/71/44ce230e1b7fadd372515a97e32a83011f906ddded8d03e3c6aafbdedbb7/rfc3987_syntax-1.1.0-py3-none-any.whl", hash = "sha256:6c3d97604e4c5ce9f714898e05401a0445a641cfa276432b0a648c80856f6a3f", size = 8046, upload-time = "2025-07-18T01:05:03.843Z" }, -] - -[[package]] -name = "rpds-py" -version = "0.28.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/48/dc/95f074d43452b3ef5d06276696ece4b3b5d696e7c9ad7173c54b1390cd70/rpds_py-0.28.0.tar.gz", hash = "sha256:abd4df20485a0983e2ca334a216249b6186d6e3c1627e106651943dbdb791aea", size = 27419, upload-time = "2025-10-22T22:24:29.327Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/b8/5c/6c3936495003875fe7b14f90ea812841a08fca50ab26bd840e924097d9c8/rpds_py-0.28.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:6b4f28583a4f247ff60cd7bdda83db8c3f5b05a7a82ff20dd4b078571747708f", size = 366439, upload-time = "2025-10-22T22:22:04.525Z" }, - { url = "https://files.pythonhosted.org/packages/56/f9/a0f1ca194c50aa29895b442771f036a25b6c41a35e4f35b1a0ea713bedae/rpds_py-0.28.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:d678e91b610c29c4b3d52a2c148b641df2b4676ffe47c59f6388d58b99cdc424", size = 348170, upload-time = "2025-10-22T22:22:06.397Z" }, - { url = "https://files.pythonhosted.org/packages/18/ea/42d243d3a586beb72c77fa5def0487daf827210069a95f36328e869599ea/rpds_py-0.28.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e819e0e37a44a78e1383bf1970076e2ccc4dc8c2bbaa2f9bd1dc987e9afff628", size = 378838, upload-time = "2025-10-22T22:22:07.932Z" }, - { url = "https://files.pythonhosted.org/packages/e7/78/3de32e18a94791af8f33601402d9d4f39613136398658412a4e0b3047327/rpds_py-0.28.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5ee514e0f0523db5d3fb171f397c54875dbbd69760a414dccf9d4d7ad628b5bd", size = 393299, upload-time = "2025-10-22T22:22:09.435Z" }, - { url = "https://files.pythonhosted.org/packages/13/7e/4bdb435afb18acea2eb8a25ad56b956f28de7c59f8a1d32827effa0d4514/rpds_py-0.28.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5f3fa06d27fdcee47f07a39e02862da0100cb4982508f5ead53ec533cd5fe55e", size = 518000, upload-time = "2025-10-22T22:22:11.326Z" }, - { url = "https://files.pythonhosted.org/packages/31/d0/5f52a656875cdc60498ab035a7a0ac8f399890cc1ee73ebd567bac4e39ae/rpds_py-0.28.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:46959ef2e64f9e4a41fc89aa20dbca2b85531f9a72c21099a3360f35d10b0d5a", size = 408746, upload-time = "2025-10-22T22:22:13.143Z" }, - { url = "https://files.pythonhosted.org/packages/3e/cd/49ce51767b879cde77e7ad9fae164ea15dce3616fe591d9ea1df51152706/rpds_py-0.28.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8455933b4bcd6e83fde3fefc987a023389c4b13f9a58c8d23e4b3f6d13f78c84", size = 386379, upload-time = "2025-10-22T22:22:14.602Z" }, - { url = "https://files.pythonhosted.org/packages/6a/99/e4e1e1ee93a98f72fc450e36c0e4d99c35370220e815288e3ecd2ec36a2a/rpds_py-0.28.0-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:ad50614a02c8c2962feebe6012b52f9802deec4263946cddea37aaf28dd25a66", size = 401280, upload-time = "2025-10-22T22:22:16.063Z" }, - { url = "https://files.pythonhosted.org/packages/61/35/e0c6a57488392a8b319d2200d03dad2b29c0db9996f5662c3b02d0b86c02/rpds_py-0.28.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:e5deca01b271492553fdb6c7fd974659dce736a15bae5dad7ab8b93555bceb28", size = 412365, upload-time = "2025-10-22T22:22:17.504Z" }, - { url = "https://files.pythonhosted.org/packages/ff/6a/841337980ea253ec797eb084665436007a1aad0faac1ba097fb906c5f69c/rpds_py-0.28.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:735f8495a13159ce6a0d533f01e8674cec0c57038c920495f87dcb20b3ddb48a", size = 559573, upload-time = "2025-10-22T22:22:19.108Z" }, - { url = "https://files.pythonhosted.org/packages/e7/5e/64826ec58afd4c489731f8b00729c5f6afdb86f1df1df60bfede55d650bb/rpds_py-0.28.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:961ca621ff10d198bbe6ba4957decca61aa2a0c56695384c1d6b79bf61436df5", size = 583973, upload-time = "2025-10-22T22:22:20.768Z" }, - { url = "https://files.pythonhosted.org/packages/b6/ee/44d024b4843f8386a4eeaa4c171b3d31d55f7177c415545fd1a24c249b5d/rpds_py-0.28.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:2374e16cc9131022e7d9a8f8d65d261d9ba55048c78f3b6e017971a4f5e6353c", size = 553800, upload-time = "2025-10-22T22:22:22.25Z" }, - { url = "https://files.pythonhosted.org/packages/7d/89/33e675dccff11a06d4d85dbb4d1865f878d5020cbb69b2c1e7b2d3f82562/rpds_py-0.28.0-cp312-cp312-win32.whl", hash = "sha256:d15431e334fba488b081d47f30f091e5d03c18527c325386091f31718952fe08", size = 216954, upload-time = "2025-10-22T22:22:24.105Z" }, - { url = "https://files.pythonhosted.org/packages/af/36/45f6ebb3210887e8ee6dbf1bc710ae8400bb417ce165aaf3024b8360d999/rpds_py-0.28.0-cp312-cp312-win_amd64.whl", hash = "sha256:a410542d61fc54710f750d3764380b53bf09e8c4edbf2f9141a82aa774a04f7c", size = 227844, upload-time = "2025-10-22T22:22:25.551Z" }, - { url = "https://files.pythonhosted.org/packages/57/91/f3fb250d7e73de71080f9a221d19bd6a1c1eb0d12a1ea26513f6c1052ad6/rpds_py-0.28.0-cp312-cp312-win_arm64.whl", hash = "sha256:1f0cfd1c69e2d14f8c892b893997fa9a60d890a0c8a603e88dca4955f26d1edd", size = 217624, upload-time = "2025-10-22T22:22:26.914Z" }, - { url = "https://files.pythonhosted.org/packages/d3/03/ce566d92611dfac0085c2f4b048cd53ed7c274a5c05974b882a908d540a2/rpds_py-0.28.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:e9e184408a0297086f880556b6168fa927d677716f83d3472ea333b42171ee3b", size = 366235, upload-time = "2025-10-22T22:22:28.397Z" }, - { url = "https://files.pythonhosted.org/packages/00/34/1c61da1b25592b86fd285bd7bd8422f4c9d748a7373b46126f9ae792a004/rpds_py-0.28.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:edd267266a9b0448f33dc465a97cfc5d467594b600fe28e7fa2f36450e03053a", size = 348241, upload-time = "2025-10-22T22:22:30.171Z" }, - { url = "https://files.pythonhosted.org/packages/fc/00/ed1e28616848c61c493a067779633ebf4b569eccaacf9ccbdc0e7cba2b9d/rpds_py-0.28.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:85beb8b3f45e4e32f6802fb6cd6b17f615ef6c6a52f265371fb916fae02814aa", size = 378079, upload-time = "2025-10-22T22:22:31.644Z" }, - { url = "https://files.pythonhosted.org/packages/11/b2/ccb30333a16a470091b6e50289adb4d3ec656fd9951ba8c5e3aaa0746a67/rpds_py-0.28.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d2412be8d00a1b895f8ad827cc2116455196e20ed994bb704bf138fe91a42724", size = 393151, upload-time = "2025-10-22T22:22:33.453Z" }, - { url = "https://files.pythonhosted.org/packages/8c/d0/73e2217c3ee486d555cb84920597480627d8c0240ff3062005c6cc47773e/rpds_py-0.28.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:cf128350d384b777da0e68796afdcebc2e9f63f0e9f242217754e647f6d32491", size = 517520, upload-time = "2025-10-22T22:22:34.949Z" }, - { url = "https://files.pythonhosted.org/packages/c4/91/23efe81c700427d0841a4ae7ea23e305654381831e6029499fe80be8a071/rpds_py-0.28.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a2036d09b363aa36695d1cc1a97b36865597f4478470b0697b5ee9403f4fe399", size = 408699, upload-time = "2025-10-22T22:22:36.584Z" }, - { url = "https://files.pythonhosted.org/packages/ca/ee/a324d3198da151820a326c1f988caaa4f37fc27955148a76fff7a2d787a9/rpds_py-0.28.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b8e1e9be4fa6305a16be628959188e4fd5cd6f1b0e724d63c6d8b2a8adf74ea6", size = 385720, upload-time = "2025-10-22T22:22:38.014Z" }, - { url = "https://files.pythonhosted.org/packages/19/ad/e68120dc05af8b7cab4a789fccd8cdcf0fe7e6581461038cc5c164cd97d2/rpds_py-0.28.0-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:0a403460c9dd91a7f23fc3188de6d8977f1d9603a351d5db6cf20aaea95b538d", size = 401096, upload-time = "2025-10-22T22:22:39.869Z" }, - { url = "https://files.pythonhosted.org/packages/99/90/c1e070620042459d60df6356b666bb1f62198a89d68881816a7ed121595a/rpds_py-0.28.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d7366b6553cdc805abcc512b849a519167db8f5e5c3472010cd1228b224265cb", size = 411465, upload-time = "2025-10-22T22:22:41.395Z" }, - { url = "https://files.pythonhosted.org/packages/68/61/7c195b30d57f1b8d5970f600efee72a4fad79ec829057972e13a0370fd24/rpds_py-0.28.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:5b43c6a3726efd50f18d8120ec0551241c38785b68952d240c45ea553912ac41", size = 558832, upload-time = "2025-10-22T22:22:42.871Z" }, - { url = "https://files.pythonhosted.org/packages/b0/3d/06f3a718864773f69941d4deccdf18e5e47dd298b4628062f004c10f3b34/rpds_py-0.28.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:0cb7203c7bc69d7c1585ebb33a2e6074492d2fc21ad28a7b9d40457ac2a51ab7", size = 583230, upload-time = "2025-10-22T22:22:44.877Z" }, - { url = "https://files.pythonhosted.org/packages/66/df/62fc783781a121e77fee9a21ead0a926f1b652280a33f5956a5e7833ed30/rpds_py-0.28.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:7a52a5169c664dfb495882adc75c304ae1d50df552fbd68e100fdc719dee4ff9", size = 553268, upload-time = "2025-10-22T22:22:46.441Z" }, - { url = "https://files.pythonhosted.org/packages/84/85/d34366e335140a4837902d3dea89b51f087bd6a63c993ebdff59e93ee61d/rpds_py-0.28.0-cp313-cp313-win32.whl", hash = "sha256:2e42456917b6687215b3e606ab46aa6bca040c77af7df9a08a6dcfe8a4d10ca5", size = 217100, upload-time = "2025-10-22T22:22:48.342Z" }, - { url = "https://files.pythonhosted.org/packages/3c/1c/f25a3f3752ad7601476e3eff395fe075e0f7813fbb9862bd67c82440e880/rpds_py-0.28.0-cp313-cp313-win_amd64.whl", hash = "sha256:e0a0311caedc8069d68fc2bf4c9019b58a2d5ce3cd7cb656c845f1615b577e1e", size = 227759, upload-time = "2025-10-22T22:22:50.219Z" }, - { url = "https://files.pythonhosted.org/packages/e0/d6/5f39b42b99615b5bc2f36ab90423ea404830bdfee1c706820943e9a645eb/rpds_py-0.28.0-cp313-cp313-win_arm64.whl", hash = "sha256:04c1b207ab8b581108801528d59ad80aa83bb170b35b0ddffb29c20e411acdc1", size = 217326, upload-time = "2025-10-22T22:22:51.647Z" }, - { url = "https://files.pythonhosted.org/packages/5c/8b/0c69b72d1cee20a63db534be0df271effe715ef6c744fdf1ff23bb2b0b1c/rpds_py-0.28.0-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:f296ea3054e11fc58ad42e850e8b75c62d9a93a9f981ad04b2e5ae7d2186ff9c", size = 355736, upload-time = "2025-10-22T22:22:53.211Z" }, - { url = "https://files.pythonhosted.org/packages/f7/6d/0c2ee773cfb55c31a8514d2cece856dd299170a49babd50dcffb15ddc749/rpds_py-0.28.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:5a7306c19b19005ad98468fcefeb7100b19c79fc23a5f24a12e06d91181193fa", size = 342677, upload-time = "2025-10-22T22:22:54.723Z" }, - { url = "https://files.pythonhosted.org/packages/e2/1c/22513ab25a27ea205144414724743e305e8153e6abe81833b5e678650f5a/rpds_py-0.28.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e5d9b86aa501fed9862a443c5c3116f6ead8bc9296185f369277c42542bd646b", size = 371847, upload-time = "2025-10-22T22:22:56.295Z" }, - { url = "https://files.pythonhosted.org/packages/60/07/68e6ccdb4b05115ffe61d31afc94adef1833d3a72f76c9632d4d90d67954/rpds_py-0.28.0-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e5bbc701eff140ba0e872691d573b3d5d30059ea26e5785acba9132d10c8c31d", size = 381800, upload-time = "2025-10-22T22:22:57.808Z" }, - { url = "https://files.pythonhosted.org/packages/73/bf/6d6d15df80781d7f9f368e7c1a00caf764436518c4877fb28b029c4624af/rpds_py-0.28.0-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9a5690671cd672a45aa8616d7374fdf334a1b9c04a0cac3c854b1136e92374fe", size = 518827, upload-time = "2025-10-22T22:22:59.826Z" }, - { url = "https://files.pythonhosted.org/packages/7b/d3/2decbb2976cc452cbf12a2b0aaac5f1b9dc5dd9d1f7e2509a3ee00421249/rpds_py-0.28.0-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9f1d92ecea4fa12f978a367c32a5375a1982834649cdb96539dcdc12e609ab1a", size = 399471, upload-time = "2025-10-22T22:23:01.968Z" }, - { url = "https://files.pythonhosted.org/packages/b1/2c/f30892f9e54bd02e5faca3f6a26d6933c51055e67d54818af90abed9748e/rpds_py-0.28.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8d252db6b1a78d0a3928b6190156042d54c93660ce4d98290d7b16b5296fb7cc", size = 377578, upload-time = "2025-10-22T22:23:03.52Z" }, - { url = "https://files.pythonhosted.org/packages/f0/5d/3bce97e5534157318f29ac06bf2d279dae2674ec12f7cb9c12739cee64d8/rpds_py-0.28.0-cp313-cp313t-manylinux_2_31_riscv64.whl", hash = "sha256:d61b355c3275acb825f8777d6c4505f42b5007e357af500939d4a35b19177259", size = 390482, upload-time = "2025-10-22T22:23:05.391Z" }, - { url = "https://files.pythonhosted.org/packages/e3/f0/886bd515ed457b5bd93b166175edb80a0b21a210c10e993392127f1e3931/rpds_py-0.28.0-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:acbe5e8b1026c0c580d0321c8aae4b0a1e1676861d48d6e8c6586625055b606a", size = 402447, upload-time = "2025-10-22T22:23:06.93Z" }, - { url = "https://files.pythonhosted.org/packages/42/b5/71e8777ac55e6af1f4f1c05b47542a1eaa6c33c1cf0d300dca6a1c6e159a/rpds_py-0.28.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:8aa23b6f0fc59b85b4c7d89ba2965af274346f738e8d9fc2455763602e62fd5f", size = 552385, upload-time = "2025-10-22T22:23:08.557Z" }, - { url = "https://files.pythonhosted.org/packages/5d/cb/6ca2d70cbda5a8e36605e7788c4aa3bea7c17d71d213465a5a675079b98d/rpds_py-0.28.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:7b14b0c680286958817c22d76fcbca4800ddacef6f678f3a7c79a1fe7067fe37", size = 575642, upload-time = "2025-10-22T22:23:10.348Z" }, - { url = "https://files.pythonhosted.org/packages/4a/d4/407ad9960ca7856d7b25c96dcbe019270b5ffdd83a561787bc682c797086/rpds_py-0.28.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:bcf1d210dfee61a6c86551d67ee1031899c0fdbae88b2d44a569995d43797712", size = 544507, upload-time = "2025-10-22T22:23:12.434Z" }, - { url = "https://files.pythonhosted.org/packages/51/31/2f46fe0efcac23fbf5797c6b6b7e1c76f7d60773e525cb65fcbc582ee0f2/rpds_py-0.28.0-cp313-cp313t-win32.whl", hash = "sha256:3aa4dc0fdab4a7029ac63959a3ccf4ed605fee048ba67ce89ca3168da34a1342", size = 205376, upload-time = "2025-10-22T22:23:13.979Z" }, - { url = "https://files.pythonhosted.org/packages/92/e4/15947bda33cbedfc134490a41841ab8870a72a867a03d4969d886f6594a2/rpds_py-0.28.0-cp313-cp313t-win_amd64.whl", hash = "sha256:7b7d9d83c942855e4fdcfa75d4f96f6b9e272d42fffcb72cd4bb2577db2e2907", size = 215907, upload-time = "2025-10-22T22:23:15.5Z" }, - { url = "https://files.pythonhosted.org/packages/08/47/ffe8cd7a6a02833b10623bf765fbb57ce977e9a4318ca0e8cf97e9c3d2b3/rpds_py-0.28.0-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:dcdcb890b3ada98a03f9f2bb108489cdc7580176cb73b4f2d789e9a1dac1d472", size = 353830, upload-time = "2025-10-22T22:23:17.03Z" }, - { url = "https://files.pythonhosted.org/packages/f9/9f/890f36cbd83a58491d0d91ae0db1702639edb33fb48eeb356f80ecc6b000/rpds_py-0.28.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:f274f56a926ba2dc02976ca5b11c32855cbd5925534e57cfe1fda64e04d1add2", size = 341819, upload-time = "2025-10-22T22:23:18.57Z" }, - { url = "https://files.pythonhosted.org/packages/09/e3/921eb109f682aa24fb76207698fbbcf9418738f35a40c21652c29053f23d/rpds_py-0.28.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4fe0438ac4a29a520ea94c8c7f1754cdd8feb1bc490dfda1bfd990072363d527", size = 373127, upload-time = "2025-10-22T22:23:20.216Z" }, - { url = "https://files.pythonhosted.org/packages/23/13/bce4384d9f8f4989f1a9599c71b7a2d877462e5fd7175e1f69b398f729f4/rpds_py-0.28.0-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:8a358a32dd3ae50e933347889b6af9a1bdf207ba5d1a3f34e1a38cd3540e6733", size = 382767, upload-time = "2025-10-22T22:23:21.787Z" }, - { url = "https://files.pythonhosted.org/packages/23/e1/579512b2d89a77c64ccef5a0bc46a6ef7f72ae0cf03d4b26dcd52e57ee0a/rpds_py-0.28.0-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e80848a71c78aa328fefaba9c244d588a342c8e03bda518447b624ea64d1ff56", size = 517585, upload-time = "2025-10-22T22:23:23.699Z" }, - { url = "https://files.pythonhosted.org/packages/62/3c/ca704b8d324a2591b0b0adcfcaadf9c862375b11f2f667ac03c61b4fd0a6/rpds_py-0.28.0-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f586db2e209d54fe177e58e0bc4946bea5fb0102f150b1b2f13de03e1f0976f8", size = 399828, upload-time = "2025-10-22T22:23:25.713Z" }, - { url = "https://files.pythonhosted.org/packages/da/37/e84283b9e897e3adc46b4c88bb3f6ec92a43bd4d2f7ef5b13459963b2e9c/rpds_py-0.28.0-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5ae8ee156d6b586e4292491e885d41483136ab994e719a13458055bec14cf370", size = 375509, upload-time = "2025-10-22T22:23:27.32Z" }, - { url = "https://files.pythonhosted.org/packages/1a/c2/a980beab869d86258bf76ec42dec778ba98151f253a952b02fe36d72b29c/rpds_py-0.28.0-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:a805e9b3973f7e27f7cab63a6b4f61d90f2e5557cff73b6e97cd5b8540276d3d", size = 392014, upload-time = "2025-10-22T22:23:29.332Z" }, - { url = "https://files.pythonhosted.org/packages/da/b5/b1d3c5f9d3fa5aeef74265f9c64de3c34a0d6d5cd3c81c8b17d5c8f10ed4/rpds_py-0.28.0-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:5d3fd16b6dc89c73a4da0b4ac8b12a7ecc75b2864b95c9e5afed8003cb50a728", size = 402410, upload-time = "2025-10-22T22:23:31.14Z" }, - { url = "https://files.pythonhosted.org/packages/74/ae/cab05ff08dfcc052afc73dcb38cbc765ffc86f94e966f3924cd17492293c/rpds_py-0.28.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:6796079e5d24fdaba6d49bda28e2c47347e89834678f2bc2c1b4fc1489c0fb01", size = 553593, upload-time = "2025-10-22T22:23:32.834Z" }, - { url = "https://files.pythonhosted.org/packages/70/80/50d5706ea2a9bfc9e9c5f401d91879e7c790c619969369800cde202da214/rpds_py-0.28.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:76500820c2af232435cbe215e3324c75b950a027134e044423f59f5b9a1ba515", size = 576925, upload-time = "2025-10-22T22:23:34.47Z" }, - { url = "https://files.pythonhosted.org/packages/ab/12/85a57d7a5855a3b188d024b099fd09c90db55d32a03626d0ed16352413ff/rpds_py-0.28.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:bbdc5640900a7dbf9dd707fe6388972f5bbd883633eb68b76591044cfe346f7e", size = 542444, upload-time = "2025-10-22T22:23:36.093Z" }, - { url = "https://files.pythonhosted.org/packages/6c/65/10643fb50179509150eb94d558e8837c57ca8b9adc04bd07b98e57b48f8c/rpds_py-0.28.0-cp314-cp314-win32.whl", hash = "sha256:adc8aa88486857d2b35d75f0640b949759f79dc105f50aa2c27816b2e0dd749f", size = 207968, upload-time = "2025-10-22T22:23:37.638Z" }, - { url = "https://files.pythonhosted.org/packages/b4/84/0c11fe4d9aaea784ff4652499e365963222481ac647bcd0251c88af646eb/rpds_py-0.28.0-cp314-cp314-win_amd64.whl", hash = "sha256:66e6fa8e075b58946e76a78e69e1a124a21d9a48a5b4766d15ba5b06869d1fa1", size = 218876, upload-time = "2025-10-22T22:23:39.179Z" }, - { url = "https://files.pythonhosted.org/packages/0f/e0/3ab3b86ded7bb18478392dc3e835f7b754cd446f62f3fc96f4fe2aca78f6/rpds_py-0.28.0-cp314-cp314-win_arm64.whl", hash = "sha256:a6fe887c2c5c59413353b7c0caff25d0e566623501ccfff88957fa438a69377d", size = 212506, upload-time = "2025-10-22T22:23:40.755Z" }, - { url = "https://files.pythonhosted.org/packages/51/ec/d5681bb425226c3501eab50fc30e9d275de20c131869322c8a1729c7b61c/rpds_py-0.28.0-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:7a69df082db13c7070f7b8b1f155fa9e687f1d6aefb7b0e3f7231653b79a067b", size = 355433, upload-time = "2025-10-22T22:23:42.259Z" }, - { url = "https://files.pythonhosted.org/packages/be/ec/568c5e689e1cfb1ea8b875cffea3649260955f677fdd7ddc6176902d04cd/rpds_py-0.28.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b1cde22f2c30ebb049a9e74c5374994157b9b70a16147d332f89c99c5960737a", size = 342601, upload-time = "2025-10-22T22:23:44.372Z" }, - { url = "https://files.pythonhosted.org/packages/32/fe/51ada84d1d2a1d9d8f2c902cfddd0133b4a5eb543196ab5161d1c07ed2ad/rpds_py-0.28.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5338742f6ba7a51012ea470bd4dc600a8c713c0c72adaa0977a1b1f4327d6592", size = 372039, upload-time = "2025-10-22T22:23:46.025Z" }, - { url = "https://files.pythonhosted.org/packages/07/c1/60144a2f2620abade1a78e0d91b298ac2d9b91bc08864493fa00451ef06e/rpds_py-0.28.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e1460ebde1bcf6d496d80b191d854adedcc619f84ff17dc1c6d550f58c9efbba", size = 382407, upload-time = "2025-10-22T22:23:48.098Z" }, - { url = "https://files.pythonhosted.org/packages/45/ed/091a7bbdcf4038a60a461df50bc4c82a7ed6d5d5e27649aab61771c17585/rpds_py-0.28.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e3eb248f2feba84c692579257a043a7699e28a77d86c77b032c1d9fbb3f0219c", size = 518172, upload-time = "2025-10-22T22:23:50.16Z" }, - { url = "https://files.pythonhosted.org/packages/54/dd/02cc90c2fd9c2ef8016fd7813bfacd1c3a1325633ec8f244c47b449fc868/rpds_py-0.28.0-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bd3bbba5def70b16cd1c1d7255666aad3b290fbf8d0fe7f9f91abafb73611a91", size = 399020, upload-time = "2025-10-22T22:23:51.81Z" }, - { url = "https://files.pythonhosted.org/packages/ab/81/5d98cc0329bbb911ccecd0b9e19fbf7f3a5de8094b4cda5e71013b2dd77e/rpds_py-0.28.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3114f4db69ac5a1f32e7e4d1cbbe7c8f9cf8217f78e6e002cedf2d54c2a548ed", size = 377451, upload-time = "2025-10-22T22:23:53.711Z" }, - { url = "https://files.pythonhosted.org/packages/b4/07/4d5bcd49e3dfed2d38e2dcb49ab6615f2ceb9f89f5a372c46dbdebb4e028/rpds_py-0.28.0-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:4b0cb8a906b1a0196b863d460c0222fb8ad0f34041568da5620f9799b83ccf0b", size = 390355, upload-time = "2025-10-22T22:23:55.299Z" }, - { url = "https://files.pythonhosted.org/packages/3f/79/9f14ba9010fee74e4f40bf578735cfcbb91d2e642ffd1abe429bb0b96364/rpds_py-0.28.0-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:cf681ac76a60b667106141e11a92a3330890257e6f559ca995fbb5265160b56e", size = 403146, upload-time = "2025-10-22T22:23:56.929Z" }, - { url = "https://files.pythonhosted.org/packages/39/4c/f08283a82ac141331a83a40652830edd3a4a92c34e07e2bbe00baaea2f5f/rpds_py-0.28.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:1e8ee6413cfc677ce8898d9cde18cc3a60fc2ba756b0dec5b71eb6eb21c49fa1", size = 552656, upload-time = "2025-10-22T22:23:58.62Z" }, - { url = "https://files.pythonhosted.org/packages/61/47/d922fc0666f0dd8e40c33990d055f4cc6ecff6f502c2d01569dbed830f9b/rpds_py-0.28.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:b3072b16904d0b5572a15eb9d31c1954e0d3227a585fc1351aa9878729099d6c", size = 576782, upload-time = "2025-10-22T22:24:00.312Z" }, - { url = "https://files.pythonhosted.org/packages/d3/0c/5bafdd8ccf6aa9d3bfc630cfece457ff5b581af24f46a9f3590f790e3df2/rpds_py-0.28.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:b670c30fd87a6aec281c3c9896d3bae4b205fd75d79d06dc87c2503717e46092", size = 544671, upload-time = "2025-10-22T22:24:02.297Z" }, - { url = "https://files.pythonhosted.org/packages/2c/37/dcc5d8397caa924988693519069d0beea077a866128719351a4ad95e82fc/rpds_py-0.28.0-cp314-cp314t-win32.whl", hash = "sha256:8014045a15b4d2b3476f0a287fcc93d4f823472d7d1308d47884ecac9e612be3", size = 205749, upload-time = "2025-10-22T22:24:03.848Z" }, - { url = "https://files.pythonhosted.org/packages/d7/69/64d43b21a10d72b45939a28961216baeb721cc2a430f5f7c3bfa21659a53/rpds_py-0.28.0-cp314-cp314t-win_amd64.whl", hash = "sha256:7a4e59c90d9c27c561eb3160323634a9ff50b04e4f7820600a2beb0ac90db578", size = 216233, upload-time = "2025-10-22T22:24:05.471Z" }, -] - -[[package]] -name = "scipy" -version = "1.16.3" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "numpy" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/0a/ca/d8ace4f98322d01abcd52d381134344bf7b431eba7ed8b42bdea5a3c2ac9/scipy-1.16.3.tar.gz", hash = "sha256:01e87659402762f43bd2fee13370553a17ada367d42e7487800bf2916535aecb", size = 30597883, upload-time = "2025-10-28T17:38:54.068Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/40/41/5bf55c3f386b1643812f3a5674edf74b26184378ef0f3e7c7a09a7e2ca7f/scipy-1.16.3-cp312-cp312-macosx_10_14_x86_64.whl", hash = "sha256:81fc5827606858cf71446a5e98715ba0e11f0dbc83d71c7409d05486592a45d6", size = 36659043, upload-time = "2025-10-28T17:32:40.285Z" }, - { url = "https://files.pythonhosted.org/packages/1e/0f/65582071948cfc45d43e9870bf7ca5f0e0684e165d7c9ef4e50d783073eb/scipy-1.16.3-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:c97176013d404c7346bf57874eaac5187d969293bf40497140b0a2b2b7482e07", size = 28898986, upload-time = "2025-10-28T17:32:45.325Z" }, - { url = "https://files.pythonhosted.org/packages/96/5e/36bf3f0ac298187d1ceadde9051177d6a4fe4d507e8f59067dc9dd39e650/scipy-1.16.3-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:2b71d93c8a9936046866acebc915e2af2e292b883ed6e2cbe5c34beb094b82d9", size = 20889814, upload-time = "2025-10-28T17:32:49.277Z" }, - { url = "https://files.pythonhosted.org/packages/80/35/178d9d0c35394d5d5211bbff7ac4f2986c5488b59506fef9e1de13ea28d3/scipy-1.16.3-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:3d4a07a8e785d80289dfe66b7c27d8634a773020742ec7187b85ccc4b0e7b686", size = 23565795, upload-time = "2025-10-28T17:32:53.337Z" }, - { url = "https://files.pythonhosted.org/packages/fa/46/d1146ff536d034d02f83c8afc3c4bab2eddb634624d6529a8512f3afc9da/scipy-1.16.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:0553371015692a898e1aa858fed67a3576c34edefa6b7ebdb4e9dde49ce5c203", size = 33349476, upload-time = "2025-10-28T17:32:58.353Z" }, - { url = "https://files.pythonhosted.org/packages/79/2e/415119c9ab3e62249e18c2b082c07aff907a273741b3f8160414b0e9193c/scipy-1.16.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:72d1717fd3b5e6ec747327ce9bda32d5463f472c9dce9f54499e81fbd50245a1", size = 35676692, upload-time = "2025-10-28T17:33:03.88Z" }, - { url = "https://files.pythonhosted.org/packages/27/82/df26e44da78bf8d2aeaf7566082260cfa15955a5a6e96e6a29935b64132f/scipy-1.16.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1fb2472e72e24d1530debe6ae078db70fb1605350c88a3d14bc401d6306dbffe", size = 36019345, upload-time = "2025-10-28T17:33:09.773Z" }, - { url = "https://files.pythonhosted.org/packages/82/31/006cbb4b648ba379a95c87262c2855cd0d09453e500937f78b30f02fa1cd/scipy-1.16.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:c5192722cffe15f9329a3948c4b1db789fbb1f05c97899187dcf009b283aea70", size = 38678975, upload-time = "2025-10-28T17:33:15.809Z" }, - { url = "https://files.pythonhosted.org/packages/c2/7f/acbd28c97e990b421af7d6d6cd416358c9c293fc958b8529e0bd5d2a2a19/scipy-1.16.3-cp312-cp312-win_amd64.whl", hash = "sha256:56edc65510d1331dae01ef9b658d428e33ed48b4f77b1d51caf479a0253f96dc", size = 38555926, upload-time = "2025-10-28T17:33:21.388Z" }, - { url = "https://files.pythonhosted.org/packages/ce/69/c5c7807fd007dad4f48e0a5f2153038dc96e8725d3345b9ee31b2b7bed46/scipy-1.16.3-cp312-cp312-win_arm64.whl", hash = "sha256:a8a26c78ef223d3e30920ef759e25625a0ecdd0d60e5a8818b7513c3e5384cf2", size = 25463014, upload-time = "2025-10-28T17:33:25.975Z" }, - { url = "https://files.pythonhosted.org/packages/72/f1/57e8327ab1508272029e27eeef34f2302ffc156b69e7e233e906c2a5c379/scipy-1.16.3-cp313-cp313-macosx_10_14_x86_64.whl", hash = "sha256:d2ec56337675e61b312179a1ad124f5f570c00f920cc75e1000025451b88241c", size = 36617856, upload-time = "2025-10-28T17:33:31.375Z" }, - { url = "https://files.pythonhosted.org/packages/44/13/7e63cfba8a7452eb756306aa2fd9b37a29a323b672b964b4fdeded9a3f21/scipy-1.16.3-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:16b8bc35a4cc24db80a0ec836a9286d0e31b2503cb2fd7ff7fb0e0374a97081d", size = 28874306, upload-time = "2025-10-28T17:33:36.516Z" }, - { url = "https://files.pythonhosted.org/packages/15/65/3a9400efd0228a176e6ec3454b1fa998fbbb5a8defa1672c3f65706987db/scipy-1.16.3-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:5803c5fadd29de0cf27fa08ccbfe7a9e5d741bf63e4ab1085437266f12460ff9", size = 20865371, upload-time = "2025-10-28T17:33:42.094Z" }, - { url = "https://files.pythonhosted.org/packages/33/d7/eda09adf009a9fb81827194d4dd02d2e4bc752cef16737cc4ef065234031/scipy-1.16.3-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:b81c27fc41954319a943d43b20e07c40bdcd3ff7cf013f4fb86286faefe546c4", size = 23524877, upload-time = "2025-10-28T17:33:48.483Z" }, - { url = "https://files.pythonhosted.org/packages/7d/6b/3f911e1ebc364cb81320223a3422aab7d26c9c7973109a9cd0f27c64c6c0/scipy-1.16.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:0c3b4dd3d9b08dbce0f3440032c52e9e2ab9f96ade2d3943313dfe51a7056959", size = 33342103, upload-time = "2025-10-28T17:33:56.495Z" }, - { url = "https://files.pythonhosted.org/packages/21/f6/4bfb5695d8941e5c570a04d9fcd0d36bce7511b7d78e6e75c8f9791f82d0/scipy-1.16.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7dc1360c06535ea6116a2220f760ae572db9f661aba2d88074fe30ec2aa1ff88", size = 35697297, upload-time = "2025-10-28T17:34:04.722Z" }, - { url = "https://files.pythonhosted.org/packages/04/e1/6496dadbc80d8d896ff72511ecfe2316b50313bfc3ebf07a3f580f08bd8c/scipy-1.16.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:663b8d66a8748051c3ee9c96465fb417509315b99c71550fda2591d7dd634234", size = 36021756, upload-time = "2025-10-28T17:34:13.482Z" }, - { url = "https://files.pythonhosted.org/packages/fe/bd/a8c7799e0136b987bda3e1b23d155bcb31aec68a4a472554df5f0937eef7/scipy-1.16.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eab43fae33a0c39006a88096cd7b4f4ef545ea0447d250d5ac18202d40b6611d", size = 38696566, upload-time = "2025-10-28T17:34:22.384Z" }, - { url = "https://files.pythonhosted.org/packages/cd/01/1204382461fcbfeb05b6161b594f4007e78b6eba9b375382f79153172b4d/scipy-1.16.3-cp313-cp313-win_amd64.whl", hash = "sha256:062246acacbe9f8210de8e751b16fc37458213f124bef161a5a02c7a39284304", size = 38529877, upload-time = "2025-10-28T17:35:51.076Z" }, - { url = "https://files.pythonhosted.org/packages/7f/14/9d9fbcaa1260a94f4bb5b64ba9213ceb5d03cd88841fe9fd1ffd47a45b73/scipy-1.16.3-cp313-cp313-win_arm64.whl", hash = "sha256:50a3dbf286dbc7d84f176f9a1574c705f277cb6565069f88f60db9eafdbe3ee2", size = 25455366, upload-time = "2025-10-28T17:35:59.014Z" }, - { url = "https://files.pythonhosted.org/packages/e2/a3/9ec205bd49f42d45d77f1730dbad9ccf146244c1647605cf834b3a8c4f36/scipy-1.16.3-cp313-cp313t-macosx_10_14_x86_64.whl", hash = "sha256:fb4b29f4cf8cc5a8d628bc8d8e26d12d7278cd1f219f22698a378c3d67db5e4b", size = 37027931, upload-time = "2025-10-28T17:34:31.451Z" }, - { url = "https://files.pythonhosted.org/packages/25/06/ca9fd1f3a4589cbd825b1447e5db3a8ebb969c1eaf22c8579bd286f51b6d/scipy-1.16.3-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:8d09d72dc92742988b0e7750bddb8060b0c7079606c0d24a8cc8e9c9c11f9079", size = 29400081, upload-time = "2025-10-28T17:34:39.087Z" }, - { url = "https://files.pythonhosted.org/packages/6a/56/933e68210d92657d93fb0e381683bc0e53a965048d7358ff5fbf9e6a1b17/scipy-1.16.3-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:03192a35e661470197556de24e7cb1330d84b35b94ead65c46ad6f16f6b28f2a", size = 21391244, upload-time = "2025-10-28T17:34:45.234Z" }, - { url = "https://files.pythonhosted.org/packages/a8/7e/779845db03dc1418e215726329674b40576879b91814568757ff0014ad65/scipy-1.16.3-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:57d01cb6f85e34f0946b33caa66e892aae072b64b034183f3d87c4025802a119", size = 23929753, upload-time = "2025-10-28T17:34:51.793Z" }, - { url = "https://files.pythonhosted.org/packages/4c/4b/f756cf8161d5365dcdef9e5f460ab226c068211030a175d2fc7f3f41ca64/scipy-1.16.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:96491a6a54e995f00a28a3c3badfff58fd093bf26cd5fb34a2188c8c756a3a2c", size = 33496912, upload-time = "2025-10-28T17:34:59.8Z" }, - { url = "https://files.pythonhosted.org/packages/09/b5/222b1e49a58668f23839ca1542a6322bb095ab8d6590d4f71723869a6c2c/scipy-1.16.3-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:cd13e354df9938598af2be05822c323e97132d5e6306b83a3b4ee6724c6e522e", size = 35802371, upload-time = "2025-10-28T17:35:08.173Z" }, - { url = "https://files.pythonhosted.org/packages/c1/8d/5964ef68bb31829bde27611f8c9deeac13764589fe74a75390242b64ca44/scipy-1.16.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:63d3cdacb8a824a295191a723ee5e4ea7768ca5ca5f2838532d9f2e2b3ce2135", size = 36190477, upload-time = "2025-10-28T17:35:16.7Z" }, - { url = "https://files.pythonhosted.org/packages/ab/f2/b31d75cb9b5fa4dd39a0a931ee9b33e7f6f36f23be5ef560bf72e0f92f32/scipy-1.16.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:e7efa2681ea410b10dde31a52b18b0154d66f2485328830e45fdf183af5aefc6", size = 38796678, upload-time = "2025-10-28T17:35:26.354Z" }, - { url = "https://files.pythonhosted.org/packages/b4/1e/b3723d8ff64ab548c38d87055483714fefe6ee20e0189b62352b5e015bb1/scipy-1.16.3-cp313-cp313t-win_amd64.whl", hash = "sha256:2d1ae2cf0c350e7705168ff2429962a89ad90c2d49d1dd300686d8b2a5af22fc", size = 38640178, upload-time = "2025-10-28T17:35:35.304Z" }, - { url = "https://files.pythonhosted.org/packages/8e/f3/d854ff38789aca9b0cc23008d607ced9de4f7ab14fa1ca4329f86b3758ca/scipy-1.16.3-cp313-cp313t-win_arm64.whl", hash = "sha256:0c623a54f7b79dd88ef56da19bc2873afec9673a48f3b85b18e4d402bdd29a5a", size = 25803246, upload-time = "2025-10-28T17:35:42.155Z" }, - { url = "https://files.pythonhosted.org/packages/99/f6/99b10fd70f2d864c1e29a28bbcaa0c6340f9d8518396542d9ea3b4aaae15/scipy-1.16.3-cp314-cp314-macosx_10_14_x86_64.whl", hash = "sha256:875555ce62743e1d54f06cdf22c1e0bc47b91130ac40fe5d783b6dfa114beeb6", size = 36606469, upload-time = "2025-10-28T17:36:08.741Z" }, - { url = "https://files.pythonhosted.org/packages/4d/74/043b54f2319f48ea940dd025779fa28ee360e6b95acb7cd188fad4391c6b/scipy-1.16.3-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:bb61878c18a470021fb515a843dc7a76961a8daceaaaa8bad1332f1bf4b54657", size = 28872043, upload-time = "2025-10-28T17:36:16.599Z" }, - { url = "https://files.pythonhosted.org/packages/4d/e1/24b7e50cc1c4ee6ffbcb1f27fe9f4c8b40e7911675f6d2d20955f41c6348/scipy-1.16.3-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:f2622206f5559784fa5c4b53a950c3c7c1cf3e84ca1b9c4b6c03f062f289ca26", size = 20862952, upload-time = "2025-10-28T17:36:22.966Z" }, - { url = "https://files.pythonhosted.org/packages/dd/3a/3e8c01a4d742b730df368e063787c6808597ccb38636ed821d10b39ca51b/scipy-1.16.3-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:7f68154688c515cdb541a31ef8eb66d8cd1050605be9dcd74199cbd22ac739bc", size = 23508512, upload-time = "2025-10-28T17:36:29.731Z" }, - { url = "https://files.pythonhosted.org/packages/1f/60/c45a12b98ad591536bfe5330cb3cfe1850d7570259303563b1721564d458/scipy-1.16.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:8b3c820ddb80029fe9f43d61b81d8b488d3ef8ca010d15122b152db77dc94c22", size = 33413639, upload-time = "2025-10-28T17:36:37.982Z" }, - { url = "https://files.pythonhosted.org/packages/71/bc/35957d88645476307e4839712642896689df442f3e53b0fa016ecf8a3357/scipy-1.16.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d3837938ae715fc0fe3c39c0202de3a8853aff22ca66781ddc2ade7554b7e2cc", size = 35704729, upload-time = "2025-10-28T17:36:46.547Z" }, - { url = "https://files.pythonhosted.org/packages/3b/15/89105e659041b1ca11c386e9995aefacd513a78493656e57789f9d9eab61/scipy-1.16.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:aadd23f98f9cb069b3bd64ddc900c4d277778242e961751f77a8cb5c4b946fb0", size = 36086251, upload-time = "2025-10-28T17:36:55.161Z" }, - { url = "https://files.pythonhosted.org/packages/1a/87/c0ea673ac9c6cc50b3da2196d860273bc7389aa69b64efa8493bdd25b093/scipy-1.16.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:b7c5f1bda1354d6a19bc6af73a649f8285ca63ac6b52e64e658a5a11d4d69800", size = 38716681, upload-time = "2025-10-28T17:37:04.1Z" }, - { url = "https://files.pythonhosted.org/packages/91/06/837893227b043fb9b0d13e4bd7586982d8136cb249ffb3492930dab905b8/scipy-1.16.3-cp314-cp314-win_amd64.whl", hash = "sha256:e5d42a9472e7579e473879a1990327830493a7047506d58d73fc429b84c1d49d", size = 39358423, upload-time = "2025-10-28T17:38:20.005Z" }, - { url = "https://files.pythonhosted.org/packages/95/03/28bce0355e4d34a7c034727505a02d19548549e190bedd13a721e35380b7/scipy-1.16.3-cp314-cp314-win_arm64.whl", hash = "sha256:6020470b9d00245926f2d5bb93b119ca0340f0d564eb6fbaad843eaebf9d690f", size = 26135027, upload-time = "2025-10-28T17:38:24.966Z" }, - { url = "https://files.pythonhosted.org/packages/b2/6f/69f1e2b682efe9de8fe9f91040f0cd32f13cfccba690512ba4c582b0bc29/scipy-1.16.3-cp314-cp314t-macosx_10_14_x86_64.whl", hash = "sha256:e1d27cbcb4602680a49d787d90664fa4974063ac9d4134813332a8c53dbe667c", size = 37028379, upload-time = "2025-10-28T17:37:14.061Z" }, - { url = "https://files.pythonhosted.org/packages/7c/2d/e826f31624a5ebbab1cd93d30fd74349914753076ed0593e1d56a98c4fb4/scipy-1.16.3-cp314-cp314t-macosx_12_0_arm64.whl", hash = "sha256:9b9c9c07b6d56a35777a1b4cc8966118fb16cfd8daf6743867d17d36cfad2d40", size = 29400052, upload-time = "2025-10-28T17:37:21.709Z" }, - { url = "https://files.pythonhosted.org/packages/69/27/d24feb80155f41fd1f156bf144e7e049b4e2b9dd06261a242905e3bc7a03/scipy-1.16.3-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:3a4c460301fb2cffb7f88528f30b3127742cff583603aa7dc964a52c463b385d", size = 21391183, upload-time = "2025-10-28T17:37:29.559Z" }, - { url = "https://files.pythonhosted.org/packages/f8/d3/1b229e433074c5738a24277eca520a2319aac7465eea7310ea6ae0e98ae2/scipy-1.16.3-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:f667a4542cc8917af1db06366d3f78a5c8e83badd56409f94d1eac8d8d9133fa", size = 23930174, upload-time = "2025-10-28T17:37:36.306Z" }, - { url = "https://files.pythonhosted.org/packages/16/9d/d9e148b0ec680c0f042581a2be79a28a7ab66c0c4946697f9e7553ead337/scipy-1.16.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f379b54b77a597aa7ee5e697df0d66903e41b9c85a6dd7946159e356319158e8", size = 33497852, upload-time = "2025-10-28T17:37:42.228Z" }, - { url = "https://files.pythonhosted.org/packages/2f/22/4e5f7561e4f98b7bea63cf3fd7934bff1e3182e9f1626b089a679914d5c8/scipy-1.16.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4aff59800a3b7f786b70bfd6ab551001cb553244988d7d6b8299cb1ea653b353", size = 35798595, upload-time = "2025-10-28T17:37:48.102Z" }, - { url = "https://files.pythonhosted.org/packages/83/42/6644d714c179429fc7196857866f219fef25238319b650bb32dde7bf7a48/scipy-1.16.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:da7763f55885045036fabcebd80144b757d3db06ab0861415d1c3b7c69042146", size = 36186269, upload-time = "2025-10-28T17:37:53.72Z" }, - { url = "https://files.pythonhosted.org/packages/ac/70/64b4d7ca92f9cf2e6fc6aaa2eecf80bb9b6b985043a9583f32f8177ea122/scipy-1.16.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ffa6eea95283b2b8079b821dc11f50a17d0571c92b43e2b5b12764dc5f9b285d", size = 38802779, upload-time = "2025-10-28T17:37:59.393Z" }, - { url = "https://files.pythonhosted.org/packages/61/82/8d0e39f62764cce5ffd5284131e109f07cf8955aef9ab8ed4e3aa5e30539/scipy-1.16.3-cp314-cp314t-win_amd64.whl", hash = "sha256:d9f48cafc7ce94cf9b15c6bffdc443a81a27bf7075cf2dcd5c8b40f85d10c4e7", size = 39471128, upload-time = "2025-10-28T17:38:05.259Z" }, - { url = "https://files.pythonhosted.org/packages/64/47/a494741db7280eae6dc033510c319e34d42dd41b7ac0c7ead39354d1a2b5/scipy-1.16.3-cp314-cp314t-win_arm64.whl", hash = "sha256:21d9d6b197227a12dcbf9633320a4e34c6b0e51c57268df255a0942983bac562", size = 26464127, upload-time = "2025-10-28T17:38:11.34Z" }, -] - -[[package]] -name = "send2trash" -version = "1.8.3" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/fd/3a/aec9b02217bb79b87bbc1a21bc6abc51e3d5dcf65c30487ac96c0908c722/Send2Trash-1.8.3.tar.gz", hash = "sha256:b18e7a3966d99871aefeb00cfbcfdced55ce4871194810fc71f4aa484b953abf", size = 17394, upload-time = "2024-04-07T00:01:09.267Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/40/b0/4562db6223154aa4e22f939003cb92514c79f3d4dccca3444253fd17f902/Send2Trash-1.8.3-py3-none-any.whl", hash = "sha256:0c31227e0bd08961c7665474a3d1ef7193929fedda4233843689baa056be46c9", size = 18072, upload-time = "2024-04-07T00:01:07.438Z" }, -] - -[[package]] -name = "setuptools" -version = "80.9.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/18/5d/3bf57dcd21979b887f014ea83c24ae194cfcd12b9e0fda66b957c69d1fca/setuptools-80.9.0.tar.gz", hash = "sha256:f36b47402ecde768dbfafc46e8e4207b4360c654f1f3bb84475f0a28628fb19c", size = 1319958, upload-time = "2025-05-27T00:56:51.443Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/a3/dc/17031897dae0efacfea57dfd3a82fdd2a2aeb58e0ff71b77b87e44edc772/setuptools-80.9.0-py3-none-any.whl", hash = "sha256:062d34222ad13e0cc312a4c02d73f059e86a4acbfbdea8f8f76b28c99f306922", size = 1201486, upload-time = "2025-05-27T00:56:49.664Z" }, -] - -[[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 = "sniffio" -version = "1.3.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/a2/87/a6771e1546d97e7e041b6ae58d80074f81b7d5121207425c964ddf5cfdbd/sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc", size = 20372, upload-time = "2024-02-25T23:20:04.057Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235, upload-time = "2024-02-25T23:20:01.196Z" }, -] - -[[package]] -name = "soupsieve" -version = "2.8" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/6d/e6/21ccce3262dd4889aa3332e5a119a3491a95e8f60939870a3a035aabac0d/soupsieve-2.8.tar.gz", hash = "sha256:e2dd4a40a628cb5f28f6d4b0db8800b8f581b65bb380b97de22ba5ca8d72572f", size = 103472, upload-time = "2025-08-27T15:39:51.78Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/14/a0/bb38d3b76b8cae341dad93a2dd83ab7462e6dbcdd84d43f54ee60a8dc167/soupsieve-2.8-py3-none-any.whl", hash = "sha256:0cc76456a30e20f5d7f2e14a98a4ae2ee4e5abdc7c5ea0aafe795f344bc7984c", size = 36679, upload-time = "2025-08-27T15:39:50.179Z" }, -] - -[[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 = "statsmodels" -version = "0.14.5" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "numpy" }, - { name = "packaging" }, - { name = "pandas" }, - { name = "patsy" }, - { name = "scipy" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/64/cc/8c1bf59bf8203dea1bf2ea811cfe667d7bcc6909c83d8afb02b08e30f50b/statsmodels-0.14.5.tar.gz", hash = "sha256:de260e58cccfd2ceddf835b55a357233d6ca853a1aa4f90f7553a52cc71c6ddf", size = 20525016, upload-time = "2025-07-07T12:14:23.195Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/5f/a5/fcc4f5f16355660ce7a1742e28a43e3a9391b492fc4ff29fdd6893e81c05/statsmodels-0.14.5-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:37e7364a39f9aa3b51d15a208c2868b90aadb8412f868530f5cba9197cb00eaa", size = 10042891, upload-time = "2025-07-07T12:13:41.671Z" }, - { url = "https://files.pythonhosted.org/packages/1c/6f/db0cf5efa48277ac6218d9b981c8fd5e63c4c43e0d9d65015fdc38eed0ef/statsmodels-0.14.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:4263d7f4d0f1d5ac6eb4db22e1ee34264a14d634b9332c975c9d9109b6b46e12", size = 9698912, upload-time = "2025-07-07T12:07:54.674Z" }, - { url = "https://files.pythonhosted.org/packages/4a/93/4ddc3bc4a59c51e6a57c49df1b889882c40d9e141e855b3517f6a8de3232/statsmodels-0.14.5-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:86224f6e36f38486e471e75759d241fe2912d8bc25ab157d54ee074c6aedbf45", size = 10237801, upload-time = "2025-07-07T14:23:12.593Z" }, - { url = "https://files.pythonhosted.org/packages/66/de/dc6bf2f6e8c8eb4c5815560ebdbdf2d69a767bc0f65fde34bc086cf5b36d/statsmodels-0.14.5-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c3dd760a6fa80cd5e0371685c697bb9c2c0e6e1f394d975e596a1e6d0bbb9372", size = 10424154, upload-time = "2025-07-07T14:23:25.365Z" }, - { url = "https://files.pythonhosted.org/packages/16/4f/2d5a8d14bebdf2b03b3ea89b8c6a2c837bb406ba5b7a41add8bd303bce29/statsmodels-0.14.5-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:6264fb00e02f858b86bd01ef2dc05055a71d4a0cc7551b9976b07b0f0e6cf24f", size = 10652915, upload-time = "2025-07-07T14:23:39.337Z" }, - { url = "https://files.pythonhosted.org/packages/df/4c/2feda3a9f0e17444a84ba5398ada6a4d2e1b8f832760048f04e2b8ea0c41/statsmodels-0.14.5-cp312-cp312-win_amd64.whl", hash = "sha256:b2ed065bfbaf8bb214c7201656df840457c2c8c65e1689e3eb09dc7440f9c61c", size = 9611236, upload-time = "2025-07-07T12:08:06.794Z" }, - { url = "https://files.pythonhosted.org/packages/84/fd/4c374108cf108b3130240a5b45847a61f70ddf973429044a81a05189b046/statsmodels-0.14.5-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:906263134dd1a640e55ecb01fda4a9be7b9e08558dba9e4c4943a486fdb0c9c8", size = 10013958, upload-time = "2025-07-07T14:35:01.04Z" }, - { url = "https://files.pythonhosted.org/packages/5a/36/bf3d7f0e36acd3ba9ec0babd79ace25506b6872780cbd710fb7cd31f0fa2/statsmodels-0.14.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:9118f76344f77cffbb3a9cbcff8682b325be5eed54a4b3253e09da77a74263d3", size = 9674243, upload-time = "2025-07-07T12:08:22.571Z" }, - { url = "https://files.pythonhosted.org/packages/90/ce/a55a6f37b5277683ceccd965a5828b24672bbc427db6b3969ae0b0fc29fb/statsmodels-0.14.5-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9dc4ee159070557c9a6c000625d85f653de437772fe7086857cff68f501afe45", size = 10219521, upload-time = "2025-07-07T14:23:52.646Z" }, - { url = "https://files.pythonhosted.org/packages/1e/48/973da1ee8bc0743519759e74c3615b39acdc3faf00e0a0710f8c856d8c9d/statsmodels-0.14.5-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5a085d47c8ef5387279a991633883d0e700de2b0acc812d7032d165888627bef", size = 10453538, upload-time = "2025-07-07T14:24:06.959Z" }, - { url = "https://files.pythonhosted.org/packages/c7/d6/18903fb707afd31cf1edaec5201964dbdacb2bfae9a22558274647a7c88f/statsmodels-0.14.5-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9f866b2ebb2904b47c342d00def83c526ef2eb1df6a9a3c94ba5fe63d0005aec", size = 10681584, upload-time = "2025-07-07T14:24:21.038Z" }, - { url = "https://files.pythonhosted.org/packages/44/d6/80df1bbbfcdc50bff4152f43274420fa9856d56e234d160d6206eb1f5827/statsmodels-0.14.5-cp313-cp313-win_amd64.whl", hash = "sha256:2a06bca03b7a492f88c8106103ab75f1a5ced25de90103a89f3a287518017939", size = 9604641, upload-time = "2025-07-07T12:08:36.23Z" }, - { url = "https://files.pythonhosted.org/packages/fd/6c/0fb40a89d715412160097c6f3387049ed88c9bd866c8838a8852c705ae2f/statsmodels-0.14.5-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:07c4dad25bbb15864a31b4917a820f6d104bdc24e5ddadcda59027390c3bed9e", size = 10211256, upload-time = "2025-10-30T13:46:58.591Z" }, - { url = "https://files.pythonhosted.org/packages/88/4a/e36fe8b19270ab3e80df357da924c6c029cab0fb9a0fbd28aaf49341707d/statsmodels-0.14.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:babb067c852e966c2c933b79dbb5d0240919d861941a2ef6c0e13321c255528d", size = 10110933, upload-time = "2025-10-30T13:47:11.774Z" }, - { url = "https://files.pythonhosted.org/packages/8a/bf/1b7e7b1a6c09a88a9c5c9e60622c050dfd08af11c2e6d4a42dbc71b32ee1/statsmodels-0.14.5-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:110194b137286173cc676d7bad0119a197778de6478fc6cbdc3b33571165ac1e", size = 10253981, upload-time = "2025-10-30T16:32:22.399Z" }, - { url = "https://files.pythonhosted.org/packages/b8/d0/f95da95524bdd99613923ca61a3036d1308cee1290e5e8acb89f51736a8c/statsmodels-0.14.5-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9c8a9c384a60c80731b278e7fd18764364c8817f4995b13a175d636f967823d1", size = 10460450, upload-time = "2025-10-30T16:32:44.985Z" }, - { url = "https://files.pythonhosted.org/packages/28/bb/59e7be0271be264b7b541baf3973f97747740950bfd5115de731f63da8ab/statsmodels-0.14.5-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:557df3a870a57248df744fdfcc444ecbc5bdbf1c042b8a8b5d8e3e797830dc2a", size = 10694060, upload-time = "2025-10-30T16:33:07.656Z" }, - { url = "https://files.pythonhosted.org/packages/8b/c0/b28d0fd0347ea38d3610052f479e4b922eb33bb8790817f93cd89e6e08ba/statsmodels-0.14.5-cp314-cp314-win_amd64.whl", hash = "sha256:95af7a9c4689d514f4341478b891f867766f3da297f514b8c4adf08f4fa61d03", size = 9648961, upload-time = "2025-10-30T13:47:24.303Z" }, -] - -[[package]] -name = "terminado" -version = "0.18.1" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "ptyprocess", marker = "os_name != 'nt'" }, - { name = "pywinpty", marker = "os_name == 'nt'" }, - { name = "tornado" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/8a/11/965c6fd8e5cc254f1fe142d547387da17a8ebfd75a3455f637c663fb38a0/terminado-0.18.1.tar.gz", hash = "sha256:de09f2c4b85de4765f7714688fff57d3e75bad1f909b589fde880460c753fd2e", size = 32701, upload-time = "2024-03-12T14:34:39.026Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/6a/9e/2064975477fdc887e47ad42157e214526dcad8f317a948dee17e1659a62f/terminado-0.18.1-py3-none-any.whl", hash = "sha256:a4468e1b37bb318f8a86514f65814e1afc977cf29b3992a4500d9dd305dcceb0", size = 14154, upload-time = "2024-03-12T14:34:36.569Z" }, -] - -[[package]] -name = "tinycss2" -version = "1.4.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "webencodings" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/7a/fd/7a5ee21fd08ff70d3d33a5781c255cbe779659bd03278feb98b19ee550f4/tinycss2-1.4.0.tar.gz", hash = "sha256:10c0972f6fc0fbee87c3edb76549357415e94548c1ae10ebccdea16fb404a9b7", size = 87085, upload-time = "2024-10-24T14:58:29.895Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/e6/34/ebdc18bae6aa14fbee1a08b63c015c72b64868ff7dae68808ab500c492e2/tinycss2-1.4.0-py3-none-any.whl", hash = "sha256:3a49cf47b7675da0b15d0c6e1df8df4ebd96e9394bb905a5775adb0d884c5289", size = 26610, upload-time = "2024-10-24T14:58:28.029Z" }, -] - -[[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 = "typing-extensions" -version = "4.15.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" }, -] - -[[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 = "uri-template" -version = "1.3.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/31/c7/0336f2bd0bcbada6ccef7aaa25e443c118a704f828a0620c6fa0207c1b64/uri-template-1.3.0.tar.gz", hash = "sha256:0e00f8eb65e18c7de20d595a14336e9f337ead580c70934141624b6d1ffdacc7", size = 21678, upload-time = "2023-06-21T01:49:05.374Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/e7/00/3fca040d7cf8a32776d3d81a00c8ee7457e00f80c649f1e4a863c8321ae9/uri_template-1.3.0-py3-none-any.whl", hash = "sha256:a44a133ea12d44a0c0f06d7d42a52d71282e77e2f937d8abd5655b8d56fc1363", size = 11140, upload-time = "2023-06-21T01:49:03.467Z" }, -] - -[[package]] -name = "urllib3" -version = "2.5.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/15/22/9ee70a2574a4f4599c47dd506532914ce044817c7752a79b6a51286319bc/urllib3-2.5.0.tar.gz", hash = "sha256:3fc47733c7e419d4bc3f6b3dc2b4f890bb743906a30d56ba4a5bfa4bbff92760", size = 393185, upload-time = "2025-06-18T14:07:41.644Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/a7/c2/fe1e52489ae3122415c51f387e221dd0773709bad6c6cdaa599e8a2c5185/urllib3-2.5.0-py3-none-any.whl", hash = "sha256:e6b01673c0fa6a13e374b50871808eb3bf7046c4b125b216f6bf1cc604cff0dc", size = 129795, upload-time = "2025-06-18T14:07:40.39Z" }, -] - -[[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" }, -] - -[[package]] -name = "webcolors" -version = "25.10.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/1d/7a/eb316761ec35664ea5174709a68bbd3389de60d4a1ebab8808bfc264ed67/webcolors-25.10.0.tar.gz", hash = "sha256:62abae86504f66d0f6364c2a8520de4a0c47b80c03fc3a5f1815fedbef7c19bf", size = 53491, upload-time = "2025-10-31T07:51:03.977Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/e2/cc/e097523dd85c9cf5d354f78310927f1656c422bd7b2613b2db3e3f9a0f2c/webcolors-25.10.0-py3-none-any.whl", hash = "sha256:032c727334856fc0b968f63daa252a1ac93d33db2f5267756623c210e57a4f1d", size = 14905, upload-time = "2025-10-31T07:51:01.778Z" }, -] - -[[package]] -name = "webencodings" -version = "0.5.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/0b/02/ae6ceac1baeda530866a85075641cec12989bd8d31af6d5ab4a3e8c92f47/webencodings-0.5.1.tar.gz", hash = "sha256:b36a1c245f2d304965eb4e0a82848379241dc04b865afcc4aab16748587e1923", size = 9721, upload-time = "2017-04-05T20:21:34.189Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/f4/24/2a3e3df732393fed8b3ebf2ec078f05546de641fe1b667ee316ec1dcf3b7/webencodings-0.5.1-py2.py3-none-any.whl", hash = "sha256:a0af1213f3c2226497a97e2b3aa01a7e4bee4f403f95be16fc9acd2947514a78", size = 11774, upload-time = "2017-04-05T20:21:32.581Z" }, -] - -[[package]] -name = "websocket-client" -version = "1.9.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/2c/41/aa4bf9664e4cda14c3b39865b12251e8e7d239f4cd0e3cc1b6c2ccde25c1/websocket_client-1.9.0.tar.gz", hash = "sha256:9e813624b6eb619999a97dc7958469217c3176312b3a16a4bd1bc7e08a46ec98", size = 70576, upload-time = "2025-10-07T21:16:36.495Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/34/db/b10e48aa8fff7407e67470363eac595018441cf32d5e1001567a7aeba5d2/websocket_client-1.9.0-py3-none-any.whl", hash = "sha256:af248a825037ef591efbf6ed20cc5faa03d3b47b9e5a2230a529eeee1c1fc3ef", size = 82616, upload-time = "2025-10-07T21:16:34.951Z" }, -] From 24906106f07bbd26bb37f41e48e524e3f8b974a8 Mon Sep 17 00:00:00 2001 From: Andrei Chernov Date: Wed, 5 Nov 2025 17:22:17 +0100 Subject: [PATCH 06/10] added new tests --- examples/flowstate_simple_example.ipynb | 716 ------------------------ examples/model_comparison_example.ipynb | 687 ----------------------- faim_sdk/client.py | 175 +++++- faim_sdk/models.py | 14 +- tests/unit/test_client.py | 225 ++++++++ tests/unit/test_eval_metrics.py | 2 +- tests/unit/test_utils.py | 405 ++++++++++++++ 7 files changed, 813 insertions(+), 1411 deletions(-) delete mode 100644 examples/flowstate_simple_example.ipynb delete mode 100644 examples/model_comparison_example.ipynb diff --git a/examples/flowstate_simple_example.ipynb b/examples/flowstate_simple_example.ipynb deleted file mode 100644 index ed22993..0000000 --- a/examples/flowstate_simple_example.ipynb +++ /dev/null @@ -1,716 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": "# FAIM SDK Example: FlowState Forecasting with Sunspots Dataset\n\nThis notebook demonstrates how to use the FAIM SDK to forecast time-series data using the FlowState model.\n\n**Dataset**: Sunspots - Annual sunspot activity observations (1700-2008)" - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 1. Setup and Installation" - ] - }, - { - "cell_type": "code", - "metadata": { - "ExecuteTime": { - "end_time": "2025-11-03T19:29:40.434952Z", - "start_time": "2025-11-03T19:29:40.353462Z" - } - }, - "source": [ - "# Install dependencies if needed\n", - "# !pip install numpy pandas matplotlib statsmodels" - ], - "outputs": [], - "execution_count": 31 - }, - { - "cell_type": "code", - "metadata": { - "ExecuteTime": { - "end_time": "2025-11-03T19:29:40.621780Z", - "start_time": "2025-11-03T19:29:40.615481Z" - } - }, - "source": "import os\n\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport pandas as pd\n\n# Import FAIM SDK\nfrom faim_sdk import FlowStateForecastRequest, ForecastClient\n\n# Import evaluation tools\nfrom faim_sdk.eval import mase, plot_forecast", - "outputs": [], - "execution_count": null - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": "## 2. Load Sunspots Dataset\n\nThe Sunspots dataset is built into statsmodels - no downloads needed!" - }, - { - "cell_type": "code", - "metadata": { - "ExecuteTime": { - "end_time": "2025-11-03T19:29:41.140539Z", - "start_time": "2025-11-03T19:29:41.029672Z" - } - }, - "source": [ - "# Load Sunspots dataset from statsmodels\n", - "import statsmodels.api as sm\n", - "\n", - "# Load the dataset\n", - "sunspots_data = sm.datasets.sunspots.load_pandas()\n", - "df = sunspots_data.data\n", - "\n", - "print(\"✓ Dataset loaded successfully\")\n", - "print(\" Dataset: Yearly sunspots (1700-2008)\")\n", - "print(f\" Shape: {df.shape}\")\n", - "print(\"\\nDataset preview:\")\n", - "print(df.head())\n", - "\n", - "# Display basic info\n", - "print(f\"\\nColumns: {df.columns.tolist()}\")\n", - "print(f\"Data types:\\n{df.dtypes}\")" - ], - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "✓ Dataset loaded successfully\n", - " Dataset: Yearly sunspots (1700-2008)\n", - " Shape: (309, 2)\n", - "\n", - "Dataset preview:\n", - " YEAR SUNACTIVITY\n", - "0 1700.0 5.0\n", - "1 1701.0 11.0\n", - "2 1702.0 16.0\n", - "3 1703.0 23.0\n", - "4 1704.0 36.0\n", - "\n", - "Columns: ['YEAR', 'SUNACTIVITY']\n", - "Data types:\n", - "YEAR float64\n", - "SUNACTIVITY float64\n", - "dtype: object\n" - ] - } - ], - "execution_count": 33 - }, - { - "cell_type": "code", - "metadata": { - "ExecuteTime": { - "end_time": "2025-11-03T19:29:41.299827Z", - "start_time": "2025-11-03T19:29:41.283178Z" - } - }, - "source": [ - "df.head()" - ], - "outputs": [ - { - "data": { - "text/plain": [ - " YEAR SUNACTIVITY\n", - "0 1700.0 5.0\n", - "1 1701.0 11.0\n", - "2 1702.0 16.0\n", - "3 1703.0 23.0\n", - "4 1704.0 36.0" - ], - "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", - "
YEARSUNACTIVITY
01700.05.0
11701.011.0
21702.016.0
31703.023.0
41704.036.0
\n", - "
" - ] - }, - "execution_count": 34, - "metadata": {}, - "output_type": "execute_result" - } - ], - "execution_count": 34 - }, - { - "cell_type": "code", - "metadata": { - "ExecuteTime": { - "end_time": "2025-11-03T19:29:41.702640Z", - "start_time": "2025-11-03T19:29:41.673551Z" - } - }, - "source": [ - "# Inspect the dataset\n", - "print(f\"Dataset shape: {df.shape}\")\n", - "print(f\"Columns: {df.columns.tolist()}\")\n", - "print(\"\\nBasic statistics:\")\n", - "print(df.describe())" - ], - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Dataset shape: (309, 2)\n", - "Columns: ['YEAR', 'SUNACTIVITY']\n", - "\n", - "Basic statistics:\n", - " YEAR SUNACTIVITY\n", - "count 309.000000 309.000000\n", - "mean 1854.000000 49.752104\n", - "std 89.344838 40.452595\n", - "min 1700.000000 0.000000\n", - "25% 1777.000000 16.000000\n", - "50% 1854.000000 40.000000\n", - "75% 1931.000000 69.800000\n", - "max 2008.000000 190.200000\n" - ] - } - ], - "execution_count": 35 - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 3. Data Preprocessing" - ] - }, - { - "cell_type": "code", - "metadata": { - "ExecuteTime": { - "end_time": "2025-11-03T19:29:42.713916Z", - "start_time": "2025-11-03T19:29:42.595488Z" - } - }, - "source": [ - "# Extract sunspot activity as numpy array\n", - "# Column name is 'SUNACTIVITY' in sunspots dataset\n", - "sunspots = df[\"SUNACTIVITY\"].values.astype(np.float32)\n", - "\n", - "print(f\"Time series length: {len(sunspots)}\")\n", - "print(f\"Value range: [{sunspots.min():.1f}, {sunspots.max():.1f}]\")\n", - "print(\"Period: 1700-2008 (annual observations)\")\n", - "\n", - "# Visualize the time series\n", - "plt.figure(figsize=(14, 4))\n", - "plt.plot(sunspots)\n", - "plt.title(\"Sunspot Activity Time Series (1700-2008)\", fontsize=14)\n", - "plt.xlabel(\"Year Index\")\n", - "plt.ylabel(\"Sunspot Activity\")\n", - "plt.grid(True, alpha=0.3)\n", - "plt.tight_layout()\n", - "plt.show()" - ], - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Time series length: 309\n", - "Value range: [0.0, 190.2]\n", - "Period: 1700-2008 (annual observations)\n" - ] - }, - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "execution_count": 36 - }, - { - "cell_type": "code", - "metadata": { - "ExecuteTime": { - "end_time": "2025-11-03T19:31:32.637040Z", - "start_time": "2025-11-03T19:31:31.666740Z" - } - }, - "source": [ - "# Prepare data for forecasting\n", - "# FlowState expects shape: (batch_size, sequence_length, features)\n", - "# For univariate time series, features = 1\n", - "\n", - "# Use last 200 years for context, forecast next 10 years\n", - "context_length = 2048\n", - "horizon = 50\n", - "\n", - "# Use data from index -110 to -10 for context\n", - "x = sunspots[-context_length - horizon : -horizon].reshape(1, context_length, 1)\n", - "\n", - "# Ground truth for comparison (last 10 years)\n", - "y_true = sunspots[-horizon:]\n", - "\n", - "print(f\"Input shape: {x.shape}\")\n", - "print(f\"Context period: {context_length} years\")\n", - "print(f\"Forecasting {horizon} years ahead\")\n", - "print(f\"Ground truth available: {len(y_true)} points\")" - ], - "outputs": [ - { - "ename": "ValueError", - "evalue": "cannot reshape array of size 259 into shape (1,2048,1)", - "output_type": "error", - "traceback": [ - "\u001b[31m---------------------------------------------------------------------------\u001b[39m", - "\u001b[31mValueError\u001b[39m Traceback (most recent call last)", - "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[52]\u001b[39m\u001b[32m, line 10\u001b[39m\n\u001b[32m 7\u001b[39m horizon = \u001b[32m50\u001b[39m\n\u001b[32m 9\u001b[39m \u001b[38;5;66;03m# Use data from index -110 to -10 for context\u001b[39;00m\n\u001b[32m---> \u001b[39m\u001b[32m10\u001b[39m x = \u001b[43msunspots\u001b[49m\u001b[43m[\u001b[49m\u001b[43m-\u001b[49m\u001b[43mcontext_length\u001b[49m\u001b[43m \u001b[49m\u001b[43m-\u001b[49m\u001b[43m \u001b[49m\u001b[43mhorizon\u001b[49m\u001b[43m \u001b[49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43m-\u001b[49m\u001b[43mhorizon\u001b[49m\u001b[43m]\u001b[49m\u001b[43m.\u001b[49m\u001b[43mreshape\u001b[49m\u001b[43m(\u001b[49m\u001b[32;43m1\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcontext_length\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[32;43m1\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[32m 12\u001b[39m \u001b[38;5;66;03m# Ground truth for comparison (last 10 years)\u001b[39;00m\n\u001b[32m 13\u001b[39m y_true = sunspots[-horizon:]\n", - "\u001b[31mValueError\u001b[39m: cannot reshape array of size 259 into shape (1,2048,1)" - ] - } - ], - "execution_count": 52 - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 4. Initialize FAIM Client\n", - "\n", - "**Note**: Replace `base_url` with your actual FAIM inference API endpoint." - ] - }, - { - "metadata": { - "ExecuteTime": { - "end_time": "2025-11-03T19:31:32.642179Z", - "start_time": "2025-11-03T19:29:48.452251Z" - } - }, - "cell_type": "code", - "source": "", - "outputs": [], - "execution_count": null - }, - { - "cell_type": "code", - "metadata": { - "ExecuteTime": { - "end_time": "2025-11-03T19:31:32.642728Z", - "start_time": "2025-11-03T19:29:49.488109Z" - } - }, - "source": [ - "# Initialize the client\n", - "# TODO: Replace with your actual FAIM API endpoint and API key\n", - "# BASE_URL = \"http://localhost:8003\" # Example: \"https://api.faim.example.com\"\n", - "# BASE_URL = (\"http://34.141.187.117\") # Example: \"https://api.faim.example.com\"\n", - "BASE_URL = (\"https://api.faim.it.com\") # Example: \"https://api.faim.example.com\"\n", - "FAIM_API_KEY = os.environ[\"FAIM_API_KEY\"] # \"your-secret-api-key\"\n", - "client = ForecastClient(\n", - " base_url=BASE_URL,\n", - " api_key=FAIM_API_KEY, # Optional: API key for authentication\n", - " timeout=60.0, # 60 seconds timeout\n", - " verify_ssl=True,\n", - ")\n", - "\n", - "print(f\"✓ ForecastClient initialized: {BASE_URL}\")\n", - "if FAIM_API_KEY:\n", - " print(\" Authentication: Enabled\")\n", - "else:\n", - " print(\" Authentication: Disabled\")\n", - " assert False, 'you need to set up your API key'" - ], - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "✓ ForecastClient initialized: https://api.faim.it.com\n", - " Authentication: Enabled\n" - ] - } - ], - "execution_count": 38 - }, - { - "cell_type": "code", - "metadata": { - "ExecuteTime": { - "end_time": "2025-11-03T19:31:32.977320Z", - "start_time": "2025-11-03T19:31:32.974722Z" - } - }, - "source": [ - "import logging\n", - "\n", - "# Enable debug logging\n", - "# logging.basicConfig(level=logging.DEBUG)\n" - ], - "outputs": [], - "execution_count": 53 - }, - { - "metadata": { - "ExecuteTime": { - "end_time": "2025-11-03T19:43:27.826683Z", - "start_time": "2025-11-03T19:43:27.816494Z" - } - }, - "cell_type": "code", - "source": "x =np.concat([x,x])", - "outputs": [], - "execution_count": 63 - }, - { - "cell_type": "code", - "metadata": { - "ExecuteTime": { - "end_time": "2025-11-03T19:43:28.320481Z", - "start_time": "2025-11-03T19:43:28.313023Z" - } - }, - "source": [ - "# Create FlowState forecast request\n", - "request = FlowStateForecastRequest(\n", - " x=x,\n", - " horizon=horizon, # or specific version like \"1.0\"\n", - " scale_factor=1.0, # Optional: normalization factor\n", - " prediction_type=\"mean\", # Optional: prediction mode\n", - " # compression=None\n", - " # compression=\"zstd\", # Use compression for efficiency\n", - ")\n", - "\n", - "print(\"Request created:\")\n", - "print(f\" - Input shape: {request.x.shape}\")\n", - "print(f\" - Horizon: {request.horizon}\")\n", - "print(f\" - Model version: {request.model_version}\")\n", - "print(f\" - Compression: {request.compression}\")" - ], - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Request created:\n", - " - Input shape: (2, 250, 1)\n", - " - Horizon: 50\n", - " - Model version: 1\n", - " - Compression: zstd\n" - ] - } - ], - "execution_count": 64 - }, - { - "metadata": { - "ExecuteTime": { - "end_time": "2025-11-03T19:43:29.752799Z", - "start_time": "2025-11-03T19:43:29.750764Z" - } - }, - "cell_type": "code", - "source": "", - "outputs": [], - "execution_count": null - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 6. Generate Forecast" - ] - }, - { - "cell_type": "code", - "metadata": { - "ExecuteTime": { - "end_time": "2025-11-03T19:43:30.813101Z", - "start_time": "2025-11-03T19:43:30.625141Z" - } - }, - "source": "try:\n # Make forecast request\n response = client.forecast(request)\n\n print(\"✓ Forecast successful!\")\n print(f\"\\nResponse: {response}\")\n print(\"\\nResponse details:\")\n print(f\" - Point predictions shape: {response.point.shape}\")\n print(f\" - Metadata: {response.metadata}\")\n \nexcept Exception as e:\n print(f\"✗ Forecast failed: {e}\")\n print(f\" Error type: {type(e).__name__}\")", - "outputs": [], - "execution_count": null - }, - { - "metadata": { - "ExecuteTime": { - "end_time": "2025-11-03T19:31:47.317564Z", - "start_time": "2025-11-03T19:31:47.311049Z" - } - }, - "cell_type": "code", - "source": "response", - "outputs": [ - { - "data": { - "text/plain": [ - "ForecastResponse(outputs=[point.shape=(1, 50, 1)], metadata={'model_name': 'flowstate', 'model_version': '1', 'transaction_id': '18d320eb-f487-4860-b137-f232ce9ab76e', 'cost_amount': 300, 'cost_currency': 'USD'})" - ] - }, - "execution_count": 58, - "metadata": {}, - "output_type": "execute_result" - } - ], - "execution_count": 58 - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 7. Visualize Results" - ] - }, - { - "cell_type": "code", - "metadata": { - "ExecuteTime": { - "end_time": "2025-11-03T11:09:48.631852Z", - "start_time": "2025-11-03T11:09:48.521954Z" - } - }, - "source": [ - "# Plot forecast vs ground truth\n", - "plt.figure(figsize=(14, 6))\n", - "\n", - "# Historical data (context) - last 100 years before forecast\n", - "historical_start = len(sunspots) - context_length - horizon\n", - "plt.plot(\n", - " range(historical_start, historical_start + context_length),\n", - " sunspots[-context_length - horizon : -horizon],\n", - " label=\"Historical Context\",\n", - " color=\"blue\",\n", - " linewidth=2,\n", - ")\n", - "\n", - "# Ground truth (actual future values - last 10 years)\n", - "plt.plot(\n", - " range(historical_start + context_length, historical_start + context_length + horizon),\n", - " y_true,\n", - " label=\"Ground Truth\",\n", - " color=\"green\",\n", - " linewidth=2,\n", - " linestyle=\"--\",\n", - ")\n", - "\n", - "# Predictions\n", - "plt.plot(\n", - " range(historical_start + context_length, historical_start + context_length + horizon),\n", - " predictions,\n", - " label=\"FlowState Forecast\",\n", - " color=\"red\",\n", - " linewidth=2,\n", - " marker=\"o\",\n", - ")\n", - "\n", - "# Formatting\n", - "plt.axvline(x=historical_start + context_length, color=\"gray\", linestyle=\":\", alpha=0.5, label=\"Forecast Start\")\n", - "plt.title(\"Sunspot Activity Forecast: FlowState Model\", fontsize=14, fontweight=\"bold\")\n", - "plt.xlabel(\"Year Index\", fontsize=12)\n", - "plt.ylabel(\"Sunspot Activity\", fontsize=12)\n", - "plt.legend(loc=\"upper left\", fontsize=10)\n", - "plt.grid(True, alpha=0.3)\n", - "plt.tight_layout()\n", - "plt.show()" - ], - "outputs": [ - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "execution_count": 28 - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 8. Evaluate Forecast Accuracy" - ] - }, - { - "cell_type": "code", - "metadata": { - "ExecuteTime": { - "end_time": "2025-11-03T11:09:48.657990Z", - "start_time": "2025-11-03T11:09:48.647876Z" - } - }, - "source": [ - "# Calculate error metrics\n", - "mae = np.mean(np.abs(predictions - y_true))\n", - "rmse = np.sqrt(np.mean((predictions - y_true) ** 2))\n", - "mape = np.mean(np.abs((predictions - y_true) / (y_true + 1e-8))) * 100 # Add small epsilon to avoid division by zero\n", - "\n", - "print(\"Forecast Accuracy Metrics:\")\n", - "print(f\" MAE (Mean Absolute Error): {mae:.2f}\")\n", - "print(f\" RMSE (Root Mean Squared Error): {rmse:.2f}\")\n", - "print(f\" MAPE (Mean Absolute % Error): {mape:.2f}%\")\n", - "\n", - "# Show point-by-point comparison\n", - "comparison_df = pd.DataFrame(\n", - " {\n", - " \"Year\": range(1, horizon + 1),\n", - " \"Ground Truth\": y_true,\n", - " \"Predicted\": predictions,\n", - " \"Error\": predictions - y_true,\n", - " \"Abs Error\": np.abs(predictions - y_true),\n", - " \"Error %\": np.abs((predictions - y_true) / (y_true + 1e-8)) * 100,\n", - " }\n", - ")\n", - "\n", - "print(\"\\nPoint-by-point comparison:\")\n", - "print(comparison_df.to_string(index=False))" - ], - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Forecast Accuracy Metrics:\n", - " MAE (Mean Absolute Error): 47.77\n", - " RMSE (Root Mean Squared Error): 53.50\n", - " MAPE (Mean Absolute % Error): 270.81%\n", - "\n", - "Point-by-point comparison:\n", - " Year Ground Truth Predicted Error Abs Error Error %\n", - " 1 157.600006 109.040283 -48.559723 48.559723 30.812008\n", - " 2 142.600006 102.783310 -39.816696 39.816696 27.921946\n", - " 3 145.699997 105.247070 -40.452927 40.452927 27.764534\n", - " 4 94.300003 106.716339 12.416336 12.416336 13.166846\n", - " 5 54.599998 109.298645 54.698647 54.698647 100.180672\n", - " 6 29.900000 113.787292 83.887291 83.887291 280.559509\n", - " 7 17.500000 99.867477 82.367477 82.367477 470.671326\n", - " 8 8.600000 89.409088 80.809090 80.809090 939.640503\n", - " 9 21.500000 70.229668 48.729668 48.729668 226.649612\n", - " 10 64.300003 59.482063 -4.817940 4.817940 7.492908\n", - " 11 93.300003 51.612942 -41.687061 41.687061 44.680664\n", - " 12 119.599998 45.011467 -74.588531 74.588531 62.364994\n", - " 13 111.000000 39.899113 -71.100891 71.100891 64.054855\n", - " 14 104.000000 36.814964 -67.185036 67.185036 64.600998\n", - " 15 63.700001 36.436573 -27.263428 27.263428 42.799728\n", - " 16 40.400002 46.089672 5.689671 5.689671 14.083343\n", - " 17 29.799999 50.359055 20.559055 20.559055 68.990120\n", - " 18 15.200000 56.709183 41.509182 41.509182 273.086731\n", - " 19 7.500000 60.124245 52.624245 52.624245 701.656555\n", - " 20 2.900000 59.597107 56.697105 56.697105 1955.072632\n" - ] - } - ], - "execution_count": 29 - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 9. Cleanup" - ] - }, - { - "cell_type": "code", - "metadata": { - "ExecuteTime": { - "end_time": "2025-11-03T11:09:48.698517Z", - "start_time": "2025-11-03T11:09:48.696624Z" - } - }, - "source": [ - "# Close the client connection\n", - "# client.close()\n", - "# print(\"✓ Client connection closed\")" - ], - "outputs": [], - "execution_count": 30 - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Next Steps\n", - "\n", - "Try experimenting with:\n", - "- Different `context_length` values\n", - "- Different `horizon` values\n", - "- Different `scale_factor` for normalization\n", - "- The ToTo model with `ToToForecastRequest` for probabilistic forecasts\n", - "- Multiple time series in a batch (increase batch_size dimension)" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "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.11.0" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} \ No newline at end of file diff --git a/examples/model_comparison_example.ipynb b/examples/model_comparison_example.ipynb deleted file mode 100644 index 0ecb0b0..0000000 --- a/examples/model_comparison_example.ipynb +++ /dev/null @@ -1,687 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# FAIM SDK: Complete Model Comparison with Evaluation Metrics\n", - "\n", - "This notebook demonstrates:\n", - "- Synthetic data generation for testing\n", - "- Forecasting with all available models (FlowState, Chronos2, TiRex)\n", - "- Both point and probabilistic forecasts\n", - "- Comprehensive evaluation with MSE, MASE, and CRPS metrics\n", - "- Visualization of results" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 1. Setup and Imports" - ] - }, - { - "cell_type": "code", - "metadata": { - "ExecuteTime": { - "end_time": "2025-11-03T21:34:44.766466Z", - "start_time": "2025-11-03T21:34:43.895562Z" - } - }, - "source": "import os\nimport sys\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport pandas as pd\n\n# Import FAIM SDK\nfrom faim_sdk import (\n ForecastClient,\n FlowStateForecastRequest,\n Chronos2ForecastRequest,\n TiRexForecastRequest,\n)\n\n# Import evaluation tools\nfrom faim_sdk.eval import mse, mase, crps_from_quantiles, plot_forecast\n\n# Import data generation utilities\nfrom generate_data import generate_linear_trend_series, generate_correlated_multi_series\n\nprint(\"✓ All imports successful\")", - "outputs": [], - "execution_count": null - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 2. Initialize FAIM Client\n", - "\n", - "**Note**: Update the `BASE_URL` and `FAIM_API_KEY` with your actual endpoint and API key." - ] - }, - { - "cell_type": "code", - "metadata": { - "ExecuteTime": { - "end_time": "2025-11-03T21:34:44.785954Z", - "start_time": "2025-11-03T21:34:44.783436Z" - } - }, - "source": [ - "# Configuration\n", - "BASE_URL = \"https://api.faim.it.com\"\n", - "FAIM_API_KEY = os.environ[\"FAIM_API_KEY\"] # \"your-secret-api-key\"\n", - "# Initialize client\n", - "client = ForecastClient(\n", - " base_url=BASE_URL,\n", - " api_key=FAIM_API_KEY,\n", - " timeout=120.0,\n", - " verify_ssl=True,\n", - ")\n", - "\n", - "print(f\"✓ ForecastClient initialized: {BASE_URL}\")\n", - "print(f\" Authentication: {'Enabled' if FAIM_API_KEY else 'Disabled'}\")" - ], - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "✓ ForecastClient initialized: https://api.faim.it.com\n", - " Authentication: Enabled\n" - ] - } - ], - "execution_count": 2 - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 3. Generate Synthetic Data\n", - "\n", - "We'll test with two datasets:\n", - "1. **Linear Trend**: Simple single-feature time series\n", - "2. **Correlated Multi-Series**: Two correlated features with seasonality" - ] - }, - { - "cell_type": "code", - "metadata": { - "ExecuteTime": { - "end_time": "2025-11-03T21:34:44.935793Z", - "start_time": "2025-11-03T21:34:44.930324Z" - } - }, - "source": [ - "# Configuration\n", - "BATCH_SIZE = 8\n", - "CONTEXT_LENGTH = 2000\n", - "HORIZON = 48\n", - "SEED = 42\n", - "\n", - "# Generate linear trend dataset (single feature)\n", - "print(\"Generating linear trend dataset...\")\n", - "linear_full = generate_linear_trend_series(\n", - " batch_size=BATCH_SIZE,\n", - " context_length=CONTEXT_LENGTH + HORIZON,\n", - " trend_slope=0.05,\n", - " noise_std=0.5,\n", - " seed=SEED\n", - ")\n", - "\n", - "# Split into train and test\n", - "linear_train = linear_full[:, :CONTEXT_LENGTH, :]\n", - "linear_test = linear_full[:, CONTEXT_LENGTH:, :]\n", - "\n", - "print(f\" Train shape: {linear_train.shape}\")\n", - "print(f\" Test shape: {linear_test.shape}\")\n", - "\n", - "# Generate correlated multi-series dataset (2 features)\n", - "print(\"\\nGenerating correlated multi-series dataset...\")\n", - "multi_full = generate_correlated_multi_series(\n", - " batch_size=BATCH_SIZE,\n", - " context_length=CONTEXT_LENGTH + HORIZON,\n", - " correlation=0.8,\n", - " seasonal_period=24,\n", - " seasonal_amplitude=2.0,\n", - " trend_slope=0.02,\n", - " noise_std=0.3,\n", - " seed=SEED\n", - ")\n", - "\n", - "# Split into train and test\n", - "multi_train = multi_full[:, :CONTEXT_LENGTH, :]\n", - "multi_test = multi_full[:, CONTEXT_LENGTH:, :]\n", - "\n", - "print(f\" Train shape: {multi_train.shape}\")\n", - "print(f\" Test shape: {multi_test.shape}\")\n", - "\n", - "# Calculate correlation for verification\n", - "corr = np.corrcoef(multi_train[0, :, 0], multi_train[0, :, 1])[0, 1]\n", - "print(f\" Correlation between features: {corr:.3f}\")" - ], - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Generating linear trend dataset...\n", - " Train shape: (8, 2000, 1)\n", - " Test shape: (8, 48, 1)\n", - "\n", - "Generating correlated multi-series dataset...\n", - " Train shape: (8, 2000, 2)\n", - " Test shape: (8, 48, 2)\n", - " Correlation between features: 0.999\n" - ] - } - ], - "execution_count": 3 - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 4. Visualize Training Data" - ] - }, - { - "cell_type": "code", - "metadata": { - "ExecuteTime": { - "end_time": "2025-11-03T21:34:45.315534Z", - "start_time": "2025-11-03T21:34:44.988210Z" - } - }, - "source": [ - "fig, axes = plt.subplots(2, 2, figsize=(15, 8))\n", - "\n", - "# Plot linear trend samples\n", - "for i in range(2):\n", - " axes[0, i].plot(linear_train[i, :, 0], label=\"Training Data\", linewidth=1.5)\n", - " axes[0, i].axvline(x=CONTEXT_LENGTH-1, color='red', linestyle='--', alpha=0.5, label='Forecast Start')\n", - " axes[0, i].set_title(f\"Linear Trend - Sample {i+1}\")\n", - " axes[0, i].set_xlabel(\"Time Step\")\n", - " axes[0, i].set_ylabel(\"Value\")\n", - " axes[0, i].legend()\n", - " axes[0, i].grid(True, alpha=0.3)\n", - "\n", - "# Plot multi-series samples\n", - "for i in range(2):\n", - " axes[1, i].plot(multi_train[i, :, 0], label=\"Feature 1\", linewidth=1.5)\n", - " axes[1, i].plot(multi_train[i, :, 1], label=\"Feature 2\", linewidth=1.5, alpha=0.7)\n", - " axes[1, i].axvline(x=CONTEXT_LENGTH-1, color='red', linestyle='--', alpha=0.5, label='Forecast Start')\n", - " axes[1, i].set_title(f\"Correlated Multi-Series - Sample {i+1}\")\n", - " axes[1, i].set_xlabel(\"Time Step\")\n", - " axes[1, i].set_ylabel(\"Value\")\n", - " axes[1, i].legend()\n", - " axes[1, i].grid(True, alpha=0.3)\n", - "\n", - "plt.tight_layout()\n", - "plt.show()\n", - "\n", - "print(\"✓ Training data visualization complete\")" - ], - "outputs": [ - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "✓ Training data visualization complete\n" - ] - } - ], - "execution_count": 4 - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 5. Forecast with All Models\n", - "\n", - "We'll test each model with both datasets and evaluate their performance." - ] - }, - { - "metadata": { - "ExecuteTime": { - "end_time": "2025-11-03T21:34:45.342253Z", - "start_time": "2025-11-03T21:34:45.338511Z" - } - }, - "cell_type": "code", - "source": "linear_train.shape", - "outputs": [ - { - "data": { - "text/plain": [ - "(8, 2000, 1)" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "execution_count": 5 - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### 5.1 FlowState (Point Forecasts)" - ] - }, - { - "cell_type": "code", - "metadata": { - "ExecuteTime": { - "end_time": "2025-11-03T21:38:53.736782Z", - "start_time": "2025-11-03T21:38:49.145028Z" - } - }, - "source": "print(\"=\" * 60)\nprint(\"FLOWSTATE MODEL\")\nprint(\"=\" * 60)\n\n# Linear trend dataset\nprint(\"\\n1. Linear Trend Dataset (single feature)\")\nrequest_linear_fs = FlowStateForecastRequest(\n x=linear_train,\n horizon=HORIZON,\n scale_factor=1.0,\n prediction_type=\"mean\",\n output_type=\"point\"\n)\n\nresponse_linear_fs = client.forecast(request_linear_fs)\nprint(f\" Response shape: {response_linear_fs.point.shape}\")\nprint(f\" Metadata: {response_linear_fs.metadata}\")\n\n# Evaluate\nmse_linear_fs = mse(linear_test, response_linear_fs.point)\nmase_linear_fs = mase(linear_test, response_linear_fs.point, linear_train)\nprint(f\" MSE: {mse_linear_fs:.4f}\")\nprint(f\" MASE: {mase_linear_fs:.4f}\")\n\n# Multi-series dataset\nprint(\"\\n2. Correlated Multi-Series Dataset (2 features)\")\nrequest_multi_fs = FlowStateForecastRequest(\n x=multi_train,\n horizon=HORIZON,\n scale_factor=1.0,\n prediction_type=\"mean\",\n output_type=\"point\"\n)\n\nresponse_multi_fs = client.forecast(request_multi_fs)\nprint(f\" Response shape: {response_multi_fs.point.shape}\")\nprint(f\" Metadata: {response_multi_fs.metadata}\")\n\n# Evaluate\nmse_multi_fs = mse(multi_test, response_multi_fs.point)\nmase_multi_fs = mase(multi_test, response_multi_fs.point, multi_train)\nprint(f\" MSE: {mse_multi_fs:.4f}\")\nprint(f\" MASE: {mase_multi_fs:.4f}\")\n\nprint(\"\\n✓ FlowState forecasts complete\")", - "outputs": [], - "execution_count": null - }, - { - "metadata": { - "ExecuteTime": { - "end_time": "2025-11-03T21:35:39.140343Z", - "start_time": "2025-11-03T21:35:39.134862Z" - } - }, - "cell_type": "code", - "source": "HORIZON", - "outputs": [ - { - "data": { - "text/plain": [ - "48" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "execution_count": 11 - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### 5.2 Chronos2 (Probabilistic Forecasts)" - ] - }, - { - "cell_type": "code", - "metadata": { - "ExecuteTime": { - "end_time": "2025-11-03T21:41:55.149090Z", - "start_time": "2025-11-03T21:41:24.860415Z" - } - }, - "source": "print(\"=\" * 60)\nprint(\"CHRONOS2 MODEL\")\nprint(\"=\" * 60)\n\n# Quantile levels for probabilistic forecasting\nQUANTILES = [0.1, 0.25, 0.5, 0.75, 0.9]\n\n# Linear trend dataset\nprint(\"\\n1. Linear Trend Dataset (single feature)\")\nrequest_linear_c2 = Chronos2ForecastRequest(\n x=linear_train,\n horizon=HORIZON,\n output_type=\"quantiles\",\n quantiles=QUANTILES\n)\n\nresponse_linear_c2 = client.forecast(request_linear_c2)\nprint(f\" Response shape: {response_linear_c2.quantiles.shape}\")\nprint(f\" Metadata: {response_linear_c2.metadata}\")\n\n# Evaluate point forecast (use median)\npoint_linear_c2 = response_linear_c2.quantiles[:, :, 2:3] # Median (0.5 quantile), keep 3D\nmse_linear_c2 = mse(linear_test, point_linear_c2)\nmase_linear_c2 = mase(linear_test, point_linear_c2, linear_train)\ncrps_linear_c2 = crps_from_quantiles(linear_test, response_linear_c2.quantiles, QUANTILES)\nprint(f\" MSE (median): {mse_linear_c2:.4f}\")\nprint(f\" MASE (median): {mase_linear_c2:.4f}\")\nprint(f\" CRPS: {crps_linear_c2:.4f}\")\n\n# Multi-series dataset\nprint(\"\\n2. Correlated Multi-Series Dataset (2 features)\")\nrequest_multi_c2 = Chronos2ForecastRequest(\n x=multi_train,\n horizon=HORIZON,\n output_type=\"quantiles\",\n quantiles=QUANTILES\n)\n\nresponse_multi_c2 = client.forecast(request_multi_c2)\nprint(f\" Response shape: {response_multi_c2.quantiles.shape}\")\nprint(f\" Metadata: {response_multi_c2.metadata}\")\n\n# Evaluate point forecast (use median)\npoint_multi_c2 = response_multi_c2.quantiles[:, :, 2:3] # Median, keep 3D\nmse_multi_c2 = mse(multi_test, point_multi_c2)\nmase_multi_c2 = mase(multi_test, point_multi_c2, multi_train)\n# Note: CRPS expects single feature, so we'll compute per feature\ncrps_multi_c2_f1 = crps_from_quantiles(multi_test[:, :, 0:1], response_multi_c2.quantiles, QUANTILES)\ncrps_multi_c2_f2 = crps_from_quantiles(multi_test[:, :, 1:2], response_multi_c2.quantiles, QUANTILES)\nprint(f\" MSE (median): {mse_multi_c2:.4f}\")\nprint(f\" MASE (median): {mase_multi_c2:.4f}\")\nprint(f\" CRPS (feature 1): {crps_multi_c2_f1:.4f}\")\nprint(f\" CRPS (feature 2): {crps_multi_c2_f2:.4f}\")\n\nprint(\"\\n✓ Chronos2 forecasts complete\")", - "outputs": [], - "execution_count": null - }, - { - "metadata": { - "ExecuteTime": { - "end_time": "2025-11-03T21:35:47.146150Z", - "start_time": "2025-11-03T21:35:47.129053Z" - } - }, - "cell_type": "code", - "source": "response_linear_c2", - "outputs": [ - { - "ename": "NameError", - "evalue": "name 'response_linear_c2' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[31m---------------------------------------------------------------------------\u001b[39m", - "\u001b[31mNameError\u001b[39m Traceback (most recent call last)", - "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[13]\u001b[39m\u001b[32m, line 1\u001b[39m\n\u001b[32m----> \u001b[39m\u001b[32m1\u001b[39m \u001b[43mresponse_linear_c2\u001b[49m\n", - "\u001b[31mNameError\u001b[39m: name 'response_linear_c2' is not defined" - ] - } - ], - "execution_count": 13 - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### 5.3 TiRex (Point Forecasts)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": "print(\"=\" * 60)\nprint(\"TIREX MODEL\")\nprint(\"=\" * 60)\n\n# Linear trend dataset\nprint(\"\\n1. Linear Trend Dataset (single feature)\")\nrequest_linear_tr = TiRexForecastRequest(\n x=linear_train,\n horizon=HORIZON,\n output_type=\"point\"\n)\n\nresponse_linear_tr = client.forecast(request_linear_tr)\nprint(f\" Response shape: {response_linear_tr.point.shape}\")\nprint(f\" Metadata: {response_linear_tr.metadata}\")\n\n# Evaluate\nmse_linear_tr = mse(linear_test, response_linear_tr.point)\nmase_linear_tr = mase(linear_test, response_linear_tr.point, linear_train)\nprint(f\" MSE: {mse_linear_tr:.4f}\")\nprint(f\" MASE: {mase_linear_tr:.4f}\")\n\n# Multi-series dataset\nprint(\"\\n2. Correlated Multi-Series Dataset (2 features)\")\nrequest_multi_tr = TiRexForecastRequest(\n x=multi_train,\n horizon=HORIZON,\n output_type=\"point\"\n)\n\nresponse_multi_tr = client.forecast(request_multi_tr)\nprint(f\" Response shape: {response_multi_tr.point.shape}\")\nprint(f\" Metadata: {response_multi_tr.metadata}\")\n\n# Evaluate\nmse_multi_tr = mse(multi_test, response_multi_tr.point)\nmase_multi_tr = mase(multi_test, response_multi_tr.point, multi_train)\nprint(f\" MSE: {mse_multi_tr:.4f}\")\nprint(f\" MASE: {mase_multi_tr:.4f}\")\n\nprint(\"\\n✓ TiRex forecasts complete\")" - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 6. Model Comparison Summary" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Create comparison table\n", - "comparison_data = {\n", - " \"Model\": [\"FlowState\", \"Chronos2\", \"TiRex\"],\n", - " \"Linear_MSE\": [mse_linear_fs, mse_linear_c2, mse_linear_tr],\n", - " \"Linear_MASE\": [mase_linear_fs, mase_linear_c2, mase_linear_tr],\n", - " \"Linear_CRPS\": [\"-\", crps_linear_c2, \"-\"],\n", - " \"Multi_MSE\": [mse_multi_fs, mse_multi_c2, mse_multi_tr],\n", - " \"Multi_MASE\": [mase_multi_fs, mase_multi_c2, mase_multi_tr],\n", - "}\n", - "\n", - "comparison_df = pd.DataFrame(comparison_data)\n", - "\n", - "print(\"\\n\" + \"=\" * 80)\n", - "print(\"MODEL COMPARISON SUMMARY\")\n", - "print(\"=\" * 80)\n", - "print(\"\\nLinear Trend Dataset (Single Feature):\")\n", - "print(comparison_df[[\"Model\", \"Linear_MSE\", \"Linear_MASE\", \"Linear_CRPS\"]].to_string(index=False))\n", - "\n", - "print(\"\\n\\nCorrelated Multi-Series Dataset (2 Features):\")\n", - "print(comparison_df[[\"Model\", \"Multi_MSE\", \"Multi_MASE\"]].to_string(index=False))\n", - "\n", - "# Identify best models\n", - "print(\"\\n\\n\" + \"=\" * 80)\n", - "print(\"BEST MODELS BY METRIC\")\n", - "print(\"=\" * 80)\n", - "\n", - "# Linear dataset\n", - "best_linear_mse_idx = np.argmin([mse_linear_fs, mse_linear_c2, mse_linear_tr])\n", - "best_linear_mase_idx = np.argmin([mase_linear_fs, mase_linear_c2, mase_linear_tr])\n", - "models = [\"FlowState\", \"Chronos2\", \"TiRex\"]\n", - "\n", - "print(\"\\nLinear Trend Dataset:\")\n", - "print(f\" Best MSE: {models[best_linear_mse_idx]} ({[mse_linear_fs, mse_linear_c2, mse_linear_tr][best_linear_mse_idx]:.4f})\")\n", - "print(f\" Best MASE: {models[best_linear_mase_idx]} ({[mase_linear_fs, mase_linear_c2, mase_linear_tr][best_linear_mase_idx]:.4f})\")\n", - "\n", - "# Multi-series dataset\n", - "best_multi_mse_idx = np.argmin([mse_multi_fs, mse_multi_c2, mse_multi_tr])\n", - "best_multi_mase_idx = np.argmin([mase_multi_fs, mase_multi_c2, mase_multi_tr])\n", - "\n", - "print(\"\\nCorrelated Multi-Series Dataset:\")\n", - "print(f\" Best MSE: {models[best_multi_mse_idx]} ({[mse_multi_fs, mse_multi_c2, mse_multi_tr][best_multi_mse_idx]:.4f})\")\n", - "print(f\" Best MASE: {models[best_multi_mase_idx]} ({[mase_multi_fs, mase_multi_c2, mase_multi_tr][best_multi_mase_idx]:.4f})\")\n", - "\n", - "print(\"\\n\" + \"=\" * 80)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 7. Visualize Forecasts - Linear Trend Dataset" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Pick a sample to visualize (index 0)\n", - "sample_idx = 0\n", - "\n", - "fig, axes = plt.subplots(3, 1, figsize=(14, 12))\n", - "\n", - "# FlowState\n", - "axes[0].plot(np.arange(CONTEXT_LENGTH), linear_train[sample_idx, :, 0], \n", - " label=\"Training Data\", color=\"blue\", linewidth=2)\n", - "axes[0].plot(np.arange(CONTEXT_LENGTH, CONTEXT_LENGTH + HORIZON), linear_test[sample_idx, :, 0], \n", - " label=\"Ground Truth\", color=\"green\", linewidth=2, linestyle=\"--\")\n", - "axes[0].plot(np.arange(CONTEXT_LENGTH, CONTEXT_LENGTH + HORIZON), response_linear_fs.point[sample_idx, :, 0], \n", - " label=\"FlowState Forecast\", color=\"red\", linewidth=2, marker=\"o\", markersize=3)\n", - "axes[0].axvline(x=CONTEXT_LENGTH, color=\"gray\", linestyle=\":\", alpha=0.5)\n", - "axes[0].set_title(f\"FlowState - Linear Trend Forecast (MSE: {mse_linear_fs:.4f}, MASE: {mase_linear_fs:.4f})\", fontweight=\"bold\")\n", - "axes[0].set_xlabel(\"Time Step\")\n", - "axes[0].set_ylabel(\"Value\")\n", - "axes[0].legend(loc=\"best\")\n", - "axes[0].grid(True, alpha=0.3)\n", - "\n", - "# Chronos2 (with uncertainty bands)\n", - "axes[1].plot(np.arange(CONTEXT_LENGTH), linear_train[sample_idx, :, 0], \n", - " label=\"Training Data\", color=\"blue\", linewidth=2)\n", - "axes[1].plot(np.arange(CONTEXT_LENGTH, CONTEXT_LENGTH + HORIZON), linear_test[sample_idx, :, 0], \n", - " label=\"Ground Truth\", color=\"green\", linewidth=2, linestyle=\"--\")\n", - "axes[1].plot(np.arange(CONTEXT_LENGTH, CONTEXT_LENGTH + HORIZON), response_linear_c2.quantiles[sample_idx, :, 2], \n", - " label=\"Chronos2 Median\", color=\"red\", linewidth=2, marker=\"o\", markersize=3)\n", - "# Add uncertainty bands\n", - "axes[1].fill_between(\n", - " np.arange(CONTEXT_LENGTH, CONTEXT_LENGTH + HORIZON),\n", - " response_linear_c2.quantiles[sample_idx, :, 0], # 10th percentile\n", - " response_linear_c2.quantiles[sample_idx, :, 4], # 90th percentile\n", - " alpha=0.2, color=\"red\", label=\"10th-90th Percentile\"\n", - ")\n", - "axes[1].axvline(x=CONTEXT_LENGTH, color=\"gray\", linestyle=\":\", alpha=0.5)\n", - "axes[1].set_title(f\"Chronos2 - Probabilistic Forecast (MSE: {mse_linear_c2:.4f}, MASE: {mase_linear_c2:.4f}, CRPS: {crps_linear_c2:.4f})\", fontweight=\"bold\")\n", - "axes[1].set_xlabel(\"Time Step\")\n", - "axes[1].set_ylabel(\"Value\")\n", - "axes[1].legend(loc=\"best\")\n", - "axes[1].grid(True, alpha=0.3)\n", - "\n", - "# TiRex\n", - "axes[2].plot(np.arange(CONTEXT_LENGTH), linear_train[sample_idx, :, 0], \n", - " label=\"Training Data\", color=\"blue\", linewidth=2)\n", - "axes[2].plot(np.arange(CONTEXT_LENGTH, CONTEXT_LENGTH + HORIZON), linear_test[sample_idx, :, 0], \n", - " label=\"Ground Truth\", color=\"green\", linewidth=2, linestyle=\"--\")\n", - "axes[2].plot(np.arange(CONTEXT_LENGTH, CONTEXT_LENGTH + HORIZON), response_linear_tr.point[sample_idx, :, 0], \n", - " label=\"TiRex Forecast\", color=\"red\", linewidth=2, marker=\"o\", markersize=3)\n", - "axes[2].axvline(x=CONTEXT_LENGTH, color=\"gray\", linestyle=\":\", alpha=0.5)\n", - "axes[2].set_title(f\"TiRex - Linear Trend Forecast (MSE: {mse_linear_tr:.4f}, MASE: {mase_linear_tr:.4f})\", fontweight=\"bold\")\n", - "axes[2].set_xlabel(\"Time Step\")\n", - "axes[2].set_ylabel(\"Value\")\n", - "axes[2].legend(loc=\"best\")\n", - "axes[2].grid(True, alpha=0.3)\n", - "\n", - "plt.tight_layout()\n", - "plt.show()\n", - "\n", - "print(\"✓ Linear trend visualization complete\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 8. Visualize Forecasts - Multi-Series Dataset" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Pick a sample to visualize (index 0)\n", - "sample_idx = 0\n", - "\n", - "fig, axes = plt.subplots(3, 2, figsize=(16, 12))\n", - "\n", - "# FlowState - Feature 1 and 2\n", - "for feat_idx in range(2):\n", - " ax = axes[0, feat_idx]\n", - " ax.plot(np.arange(CONTEXT_LENGTH), multi_train[sample_idx, :, feat_idx], \n", - " label=\"Training Data\", color=\"blue\", linewidth=2)\n", - " ax.plot(np.arange(CONTEXT_LENGTH, CONTEXT_LENGTH + HORIZON), multi_test[sample_idx, :, feat_idx], \n", - " label=\"Ground Truth\", color=\"green\", linewidth=2, linestyle=\"--\")\n", - " ax.plot(np.arange(CONTEXT_LENGTH, CONTEXT_LENGTH + HORIZON), response_multi_fs.point[sample_idx, :, feat_idx], \n", - " label=\"FlowState Forecast\", color=\"red\", linewidth=2, marker=\"o\", markersize=3)\n", - " ax.axvline(x=CONTEXT_LENGTH, color=\"gray\", linestyle=\":\", alpha=0.5)\n", - " ax.set_title(f\"FlowState - Feature {feat_idx+1}\", fontweight=\"bold\")\n", - " ax.set_xlabel(\"Time Step\")\n", - " ax.set_ylabel(\"Value\")\n", - " ax.legend(loc=\"best\")\n", - " ax.grid(True, alpha=0.3)\n", - "\n", - "# Chronos2 - Feature 1 and 2\n", - "for feat_idx in range(2):\n", - " ax = axes[1, feat_idx]\n", - " ax.plot(np.arange(CONTEXT_LENGTH), multi_train[sample_idx, :, feat_idx], \n", - " label=\"Training Data\", color=\"blue\", linewidth=2)\n", - " ax.plot(np.arange(CONTEXT_LENGTH, CONTEXT_LENGTH + HORIZON), multi_test[sample_idx, :, feat_idx], \n", - " label=\"Ground Truth\", color=\"green\", linewidth=2, linestyle=\"--\")\n", - " ax.plot(np.arange(CONTEXT_LENGTH, CONTEXT_LENGTH + HORIZON), response_multi_c2.quantiles[sample_idx, :, 2], \n", - " label=\"Chronos2 Median\", color=\"red\", linewidth=2, marker=\"o\", markersize=3)\n", - " # Add uncertainty bands\n", - " ax.fill_between(\n", - " np.arange(CONTEXT_LENGTH, CONTEXT_LENGTH + HORIZON),\n", - " response_multi_c2.quantiles[sample_idx, :, 0],\n", - " response_multi_c2.quantiles[sample_idx, :, 4],\n", - " alpha=0.2, color=\"red\", label=\"10th-90th Percentile\"\n", - " )\n", - " ax.axvline(x=CONTEXT_LENGTH, color=\"gray\", linestyle=\":\", alpha=0.5)\n", - " ax.set_title(f\"Chronos2 - Feature {feat_idx+1}\", fontweight=\"bold\")\n", - " ax.set_xlabel(\"Time Step\")\n", - " ax.set_ylabel(\"Value\")\n", - " ax.legend(loc=\"best\")\n", - " ax.grid(True, alpha=0.3)\n", - "\n", - "# TiRex - Feature 1 and 2\n", - "for feat_idx in range(2):\n", - " ax = axes[2, feat_idx]\n", - " ax.plot(np.arange(CONTEXT_LENGTH), multi_train[sample_idx, :, feat_idx], \n", - " label=\"Training Data\", color=\"blue\", linewidth=2)\n", - " ax.plot(np.arange(CONTEXT_LENGTH, CONTEXT_LENGTH + HORIZON), multi_test[sample_idx, :, feat_idx], \n", - " label=\"Ground Truth\", color=\"green\", linewidth=2, linestyle=\"--\")\n", - " ax.plot(np.arange(CONTEXT_LENGTH, CONTEXT_LENGTH + HORIZON), response_multi_tr.point[sample_idx, :, feat_idx], \n", - " label=\"TiRex Forecast\", color=\"red\", linewidth=2, marker=\"o\", markersize=3)\n", - " ax.axvline(x=CONTEXT_LENGTH, color=\"gray\", linestyle=\":\", alpha=0.5)\n", - " ax.set_title(f\"TiRex - Feature {feat_idx+1}\", fontweight=\"bold\")\n", - " ax.set_xlabel(\"Time Step\")\n", - " ax.set_ylabel(\"Value\")\n", - " ax.legend(loc=\"best\")\n", - " ax.grid(True, alpha=0.3)\n", - "\n", - "plt.tight_layout()\n", - "plt.show()\n", - "\n", - "print(\"✓ Multi-series visualization complete\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 9. Per-Sample Error Analysis" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Calculate per-sample errors for linear dataset\n", - "mse_per_sample_fs = mse(linear_test, response_linear_fs.point, reduction='none')\n", - "mse_per_sample_c2 = mse(linear_test, point_linear_c2, reduction='none')\n", - "mse_per_sample_tr = mse(linear_test, response_linear_tr.point, reduction='none')\n", - "\n", - "# Visualize per-sample errors\n", - "fig, axes = plt.subplots(1, 2, figsize=(14, 5))\n", - "\n", - "# Bar plot\n", - "x = np.arange(BATCH_SIZE)\n", - "width = 0.25\n", - "axes[0].bar(x - width, mse_per_sample_fs, width, label='FlowState', alpha=0.8)\n", - "axes[0].bar(x, mse_per_sample_c2, width, label='Chronos2', alpha=0.8)\n", - "axes[0].bar(x + width, mse_per_sample_tr, width, label='TiRex', alpha=0.8)\n", - "axes[0].set_xlabel('Sample Index')\n", - "axes[0].set_ylabel('MSE')\n", - "axes[0].set_title('Per-Sample MSE Comparison (Linear Trend)', fontweight='bold')\n", - "axes[0].set_xticks(x)\n", - "axes[0].legend()\n", - "axes[0].grid(True, alpha=0.3, axis='y')\n", - "\n", - "# Box plot\n", - "axes[1].boxplot([mse_per_sample_fs, mse_per_sample_c2, mse_per_sample_tr],\n", - " labels=['FlowState', 'Chronos2', 'TiRex'])\n", - "axes[1].set_ylabel('MSE')\n", - "axes[1].set_title('MSE Distribution Across Samples', fontweight='bold')\n", - "axes[1].grid(True, alpha=0.3, axis='y')\n", - "\n", - "plt.tight_layout()\n", - "plt.show()\n", - "\n", - "print(\"\\nPer-Sample Statistics (Linear Trend):\")\n", - "print(f\"FlowState - Mean: {mse_per_sample_fs.mean():.4f}, Std: {mse_per_sample_fs.std():.4f}, Min: {mse_per_sample_fs.min():.4f}, Max: {mse_per_sample_fs.max():.4f}\")\n", - "print(f\"Chronos2 - Mean: {mse_per_sample_c2.mean():.4f}, Std: {mse_per_sample_c2.std():.4f}, Min: {mse_per_sample_c2.min():.4f}, Max: {mse_per_sample_c2.max():.4f}\")\n", - "print(f\"TiRex - Mean: {mse_per_sample_tr.mean():.4f}, Std: {mse_per_sample_tr.std():.4f}, Min: {mse_per_sample_tr.min():.4f}, Max: {mse_per_sample_tr.max():.4f}\")\n", - "\n", - "print(\"\\n✓ Per-sample error analysis complete\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 10. Key Insights and Conclusions" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "print(\"\\n\" + \"=\"*80)\n", - "print(\"KEY INSIGHTS\")\n", - "print(\"=\"*80)\n", - "\n", - "print(\"\\n1. Model Performance:\")\n", - "print(\" - All models successfully handled both single and multi-feature datasets\")\n", - "print(f\" - Best overall for linear trend: {models[best_linear_mse_idx]}\")\n", - "print(f\" - Best overall for multi-series: {models[best_multi_mse_idx]}\")\n", - "\n", - "print(\"\\n2. Probabilistic Forecasting:\")\n", - "print(f\" - Chronos2 provided uncertainty quantification with CRPS: {crps_linear_c2:.4f}\")\n", - "print(\" - Uncertainty bands captured ground truth well in most samples\")\n", - "\n", - "print(\"\\n3. Metrics Comparison:\")\n", - "print(\" - MSE: Measures average squared error (sensitive to outliers)\")\n", - "print(\" - MASE: Scale-independent, compares to naive baseline\")\n", - "print(\" - CRPS: Evaluates probabilistic forecast quality\")\n", - "\n", - "print(\"\\n4. Recommendations:\")\n", - "print(\" - Use FlowState for: Fast point forecasts with known patterns\")\n", - "print(\" - Use Chronos2 for: Uncertainty quantification and probabilistic forecasts\")\n", - "print(\" - Use TiRex for: Efficient transformer-based forecasting\")\n", - "\n", - "print(\"\\n\" + \"=\"*80)\n", - "print(\"✓ Model comparison complete!\")\n", - "print(\"=\"*80)" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "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.11.0" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} \ No newline at end of file diff --git a/faim_sdk/client.py b/faim_sdk/client.py index 4c0a755..f43179c 100644 --- a/faim_sdk/client.py +++ b/faim_sdk/client.py @@ -7,8 +7,11 @@ import io import json import logging +import warnings +from copy import copy import httpx +import numpy as np from faim_client import AuthenticatedClient, Client from faim_client.api.forecast import forecast_v1_ts_forecast_model_name_model_version_post @@ -61,6 +64,148 @@ def _parse_error_response(response) -> ErrorResponse | None: return None +def _needs_univariate_transformation(request: ForecastRequest) -> bool: + """Check if request requires univariate transformation. + + FlowState and TiRex models only support univariate forecasting. + When they receive multivariate input (features > 1), the input + must be transformed to forecast each feature independently. + + Args: + request: Forecast request to check + + Returns: + True if transformation is needed, False otherwise + """ + # Only FlowState and TiRex require transformation + if request.model_name not in (ModelName.FLOWSTATE, ModelName.TIREX): + return False + + # Check if input is multivariate (features > 1) + num_features = request.x.shape[2] # Shape is (batch, seq_len, features) + return num_features > 1 + + +def _prepare_univariate_request(request: ForecastRequest) -> tuple[ForecastRequest, tuple[int, int]]: + """Prepare request for univariate-only models with multivariate input. + + Transforms input from (batch, seq_len, features) to (batch*features, seq_len, 1) + and issues a warning to the user that features will be forecast independently. + + Args: + request: Original forecast request with multivariate input + + Returns: + Tuple of (modified request, (original_batch_size, num_features)) + + Example: + Input shape: (batch=2, seq_len=100, features=3) + Output shape: (batch=6, seq_len=100, features=1) + Mapping: + - Feature 0 of series 0 → new batch index 0 + - Feature 1 of series 0 → new batch index 1 + - Feature 2 of series 0 → new batch index 2 + - Feature 0 of series 1 → new batch index 3 + - Feature 1 of series 1 → new batch index 4 + - Feature 2 of series 1 → new batch index 5 + """ + original_batch_size, seq_len, num_features = request.x.shape + + # Issue user warning + warnings.warn( + f"{request.model_name.value.title()} model only supports univariate forecasting. " + f"Input with {num_features} features will be forecast independently. " + f"Each feature will be treated as a separate time series.", + UserWarning, + stacklevel=3, # Point to the user's code, not this internal function + ) + + logger.info( + f"Transforming multivariate input for {request.model_name.value}: " + f"shape {request.x.shape} → ({original_batch_size * num_features}, {seq_len}, 1)" + ) + + # Reshape: (batch, seq_len, features) → (batch, features, seq_len) → (batch*features, seq_len) → (batch*features, seq_len, 1) + # We want to interleave features across the batch dimension + x_transposed = request.x.transpose(0, 2, 1) # (batch, features, seq_len) + x_flattened = x_transposed.reshape(original_batch_size * num_features, seq_len) # (batch*features, seq_len) + x_univariate = x_flattened[:, :, np.newaxis] # (batch*features, seq_len, 1) + + # Create modified request with reshaped x + # Use copy to avoid modifying the original request + modified_request = copy(request) + modified_request.x = x_univariate + + return modified_request, (original_batch_size, num_features) + + +def _reshape_univariate_response( + response: ForecastResponse, + original_batch_size: int, + num_features: int, +) -> ForecastResponse: + """Reshape response from univariate transformation back to multivariate format. + + Reverses the transformation done by _prepare_univariate_request() to restore + the original batch and feature dimensions. + + Args: + response: Response from server with univariate format + original_batch_size: Original batch size before transformation + num_features: Number of features in original input + + Returns: + Response with proper multivariate shape + + Example: + Point forecast: + Input shape: (batch*features=6, horizon=24, features=1) + Output shape: (batch=2, horizon=24, features=3) + + Quantile forecast: + Input shape: (batch*features=6, horizon=24, quantiles=5, features=1) + Output shape: (batch=2, horizon=24, quantiles=5, features=3) + """ + modified_response = ForecastResponse(metadata=response.metadata) + + # Reshape point predictions if present + if response.point is not None: + # Input: (batch*features, horizon, 1) + # Output: (batch, horizon, features) + batch_times_features, horizon, _ = response.point.shape + + # Reshape to (batch, features, horizon, 1) + reshaped = response.point.reshape(original_batch_size, num_features, horizon, 1) + # Transpose to (batch, horizon, features, 1) + transposed = reshaped.transpose(0, 2, 1, 3) # (batch, horizon, features, 1) + # Squeeze last dimension to get (batch, horizon, features) + modified_response.point = transposed.squeeze(-1) + + # Reshape quantile predictions if present + if response.quantiles is not None: + # Input: (batch*features, horizon, quantiles, 1) + # Output: (batch, horizon, quantiles, features) + batch_times_features, horizon, num_quantiles, _ = response.quantiles.shape + + # Reshape to (batch, features, horizon, quantiles, 1) + reshaped = response.quantiles.reshape(original_batch_size, num_features, horizon, num_quantiles, 1) + # Transpose to (batch, horizon, quantiles, features, 1) + transposed = reshaped.transpose(0, 2, 3, 1, 4) # (batch, horizon, quantiles, features, 1) + # Squeeze last dimension to get (batch, horizon, quantiles, features) + modified_response.quantiles = transposed.squeeze(-1) + + # Samples - keep as is for now (not common for FlowState/TiRex) + if response.samples is not None: + modified_response.samples = response.samples + + logger.debug( + f"Reshaped univariate response: " + f"original_batch={original_batch_size}, features={num_features}" + ) + + return modified_response + + class ForecastClient: """High-level client for FAIM time-series forecasting. @@ -86,8 +231,8 @@ class ForecastClient: def __init__( self, - base_url: str, - timeout: float = 120.0, + base_url: str = "https://api.faim.it.com", + timeout: float = 60.0, verify_ssl: bool = True, api_key: str | None = None, **httpx_kwargs, @@ -96,7 +241,7 @@ def __init__( Args: base_url: Base URL of FAIM inference API - timeout: Request timeout in seconds. Default: 120s + timeout: Request timeout in seconds. Default: 60s verify_ssl: Whether to verify SSL certificates. Default: True api_key: Optional API key for authentication. If provided, all requests will include "Authorization: Bearer " header. Default: None @@ -174,6 +319,11 @@ def forecast(self, request: ForecastRequest) -> ForecastResponse: f"x.shape={request.x.shape}, horizon={request.horizon}" ) + # Check if univariate transformation is needed + transform_shape_info = None + if _needs_univariate_transformation(request): + request, transform_shape_info = _prepare_univariate_request(request) + # Serialize request to Arrow format try: arrays, metadata = request.to_arrays_and_metadata() @@ -313,6 +463,13 @@ def forecast(self, request: ForecastRequest) -> ForecastResponse: arrays, metadata = deserialize_from_arrow(response_bytes) forecast_response = ForecastResponse.from_arrays_and_metadata(arrays, metadata) + # If univariate transformation was applied, reshape response back + if transform_shape_info is not None: + original_batch_size, num_features = transform_shape_info + forecast_response = _reshape_univariate_response( + forecast_response, original_batch_size, num_features + ) + logger.info(f"Forecast successful: {forecast_response}") return forecast_response @@ -348,6 +505,11 @@ async def forecast_async(self, request: ForecastRequest) -> ForecastResponse: model = request.model_name logger.debug(f"Starting async forecast: model={model}, version={request.model_version}") + # Check if univariate transformation is needed + transform_shape_info = None + if _needs_univariate_transformation(request): + request, transform_shape_info = _prepare_univariate_request(request) + # Serialize request try: arrays, metadata = request.to_arrays_and_metadata() @@ -487,6 +649,13 @@ async def forecast_async(self, request: ForecastRequest) -> ForecastResponse: arrays, metadata = deserialize_from_arrow(response_bytes) forecast_response = ForecastResponse.from_arrays_and_metadata(arrays, metadata) + # If univariate transformation was applied, reshape response back + if transform_shape_info is not None: + original_batch_size, num_features = transform_shape_info + forecast_response = _reshape_univariate_response( + forecast_response, original_batch_size, num_features + ) + logger.info(f"Async forecast successful: {forecast_response}") return forecast_response diff --git a/faim_sdk/models.py b/faim_sdk/models.py index 05bf71f..2b734b5 100644 --- a/faim_sdk/models.py +++ b/faim_sdk/models.py @@ -28,7 +28,7 @@ class ForecastRequest: _model_name: ClassVar[ModelName] x: np.ndarray - """Time series data. Shape: (batch_size, sequence_length, features) or (sequence_length, features)""" + """Time series data. Shape: (batch_size, sequence_length, features)""" horizon: int """Forecast horizon length (number of time steps to predict)""" @@ -60,7 +60,7 @@ def __post_init__(self) -> None: Raises: TypeError: If x is not a numpy ndarray - ValueError: If x is empty or horizon is non-positive + ValueError: If x is empty, not 3D, or horizon is non-positive """ if not isinstance(self.x, np.ndarray): raise TypeError(f"x must be numpy.ndarray, got {type(self.x).__name__}") @@ -68,6 +68,13 @@ def __post_init__(self) -> None: if self.x.size == 0: raise ValueError("x cannot be empty") + # Ensure x is 3D: (batch_size, sequence_length, features) + if self.x.ndim != 3: + raise ValueError( + f"x must be a 3D array with shape (batch_size, sequence_length, features), " + f"got shape {self.x.shape} with {self.x.ndim} dimensions" + ) + if self.horizon <= 0: raise ValueError(f"horizon must be positive, got {self.horizon}") @@ -165,7 +172,6 @@ def to_arrays_and_metadata(self) -> tuple[dict[str, np.ndarray], dict[str, Any]] """ arrays, metadata = super().to_arrays_and_metadata() - # Add TiRex-specific metadata metadata["output_type"] = self.output_type return arrays, metadata @@ -269,7 +275,7 @@ class ForecastResponse: """Point predictions. Shape: (batch_size, horizon, features)""" quantiles: np.ndarray | None = None - """Quantile predictions. Shape: (batch_size, horizon, num_quantiles)""" + """Quantile predictions. Shape: (batch_size, horizon, num_quantiles, features)""" samples: np.ndarray | None = None """Sample predictions. Shape: (batch_size, horizon, num_samples)""" diff --git a/tests/unit/test_client.py b/tests/unit/test_client.py index c6f34a6..0e2d9ea 100644 --- a/tests/unit/test_client.py +++ b/tests/unit/test_client.py @@ -625,3 +625,228 @@ def test_different_models_same_client(self, mock_post): assert response.point is not None assert mock_post.call_count == 3 + + +class TestUnivariateTransformation: + """Tests for univariate transformation of FlowState and TiRex models.""" + + @patch("httpx.Client.post") + def test_flowstate_multivariate_point_forecast(self, mock_post): + """Test FlowState with multivariate input transforms and reshapes correctly for point forecast.""" + # Setup: multivariate input (2, 10, 3) - 2 series, 10 timesteps, 3 features + data = np.random.rand(2, 10, 3).astype(np.float32) + + # Mock server response: (batch*features=6, horizon=5, features=1) + response_arrays = {"point": np.random.rand(6, 5, 1).astype(np.float32)} + mock_response = Mock() + mock_response.status_code = 200 + mock_response.content = serialize_to_arrow(response_arrays, {}) + mock_post.return_value = mock_response + + client = ForecastClient(base_url="https://api.example.com") + request = FlowStateForecastRequest(x=data, horizon=5, prediction_type="mean") + + # Execute with warning capture + with pytest.warns(UserWarning, match="FlowState model only supports univariate forecasting"): + response = client.forecast(request) + + # Verify output shape: should be reshaped to (2, 5, 3) + assert response.point is not None + assert response.point.shape == (2, 5, 3) + + @patch("httpx.Client.post") + def test_tirex_multivariate_point_forecast(self, mock_post): + """Test TiRex with multivariate input transforms and reshapes correctly for point forecast.""" + # Setup: multivariate input (3, 20, 2) - 3 series, 20 timesteps, 2 features + data = np.random.rand(3, 20, 2).astype(np.float32) + + # Mock server response: (batch*features=6, horizon=10, features=1) + response_arrays = {"point": np.random.rand(6, 10, 1).astype(np.float32)} + mock_response = Mock() + mock_response.status_code = 200 + mock_response.content = serialize_to_arrow(response_arrays, {}) + mock_post.return_value = mock_response + + client = ForecastClient(base_url="https://api.example.com") + request = TiRexForecastRequest(x=data, horizon=10) + + # Execute with warning capture + with pytest.warns(UserWarning, match="TiRex model only supports univariate forecasting"): + response = client.forecast(request) + + # Verify output shape: should be reshaped to (3, 10, 2) + assert response.point is not None + assert response.point.shape == (3, 10, 2) + + @patch("httpx.Client.post") + def test_flowstate_multivariate_quantile_forecast(self, mock_post): + """Test FlowState with multivariate input transforms and reshapes correctly for quantile forecast.""" + # Setup: multivariate input (2, 15, 4) - 2 series, 15 timesteps, 4 features + data = np.random.rand(2, 15, 4).astype(np.float32) + + # Mock server response: (batch*features=8, horizon=8, quantiles=5, features=1) + response_arrays = {"quantiles": np.random.rand(8, 8, 5, 1).astype(np.float32)} + mock_response = Mock() + mock_response.status_code = 200 + mock_response.content = serialize_to_arrow(response_arrays, {}) + mock_post.return_value = mock_response + + client = ForecastClient(base_url="https://api.example.com") + request = FlowStateForecastRequest( + x=data, + horizon=8, + prediction_type="quantile", + output_type="quantiles" + ) + + # Execute with warning capture + with pytest.warns(UserWarning, match="FlowState model only supports univariate forecasting"): + response = client.forecast(request) + + # Verify output shape: should be reshaped to (2, 8, 5, 4) + assert response.quantiles is not None + assert response.quantiles.shape == (2, 8, 5, 4) + + @patch("httpx.Client.post") + def test_tirex_multivariate_quantile_forecast(self, mock_post): + """Test TiRex with multivariate input transforms and reshapes correctly for quantile forecast.""" + # Setup: multivariate input (1, 10, 3) - 1 series, 10 timesteps, 3 features + data = np.random.rand(1, 10, 3).astype(np.float32) + + # Mock server response: (batch*features=3, horizon=5, quantiles=7, features=1) + response_arrays = {"quantiles": np.random.rand(3, 5, 7, 1).astype(np.float32)} + mock_response = Mock() + mock_response.status_code = 200 + mock_response.content = serialize_to_arrow(response_arrays, {}) + mock_post.return_value = mock_response + + client = ForecastClient(base_url="https://api.example.com") + request = TiRexForecastRequest(x=data, horizon=5, output_type="quantiles") + + # Execute with warning capture + with pytest.warns(UserWarning, match="TiRex model only supports univariate forecasting"): + response = client.forecast(request) + + # Verify output shape: should be reshaped to (1, 5, 7, 3) + assert response.quantiles is not None + assert response.quantiles.shape == (1, 5, 7, 3) + + @patch("httpx.Client.post") + def test_chronos2_multivariate_not_transformed(self, mock_post): + """Test that Chronos2 with multivariate input is NOT transformed.""" + # Setup: multivariate input (2, 10, 3) - Chronos2 supports multivariate + data = np.random.rand(2, 10, 3).astype(np.float32) + + # Mock server response: should preserve multivariate shape (2, 5, 3) + response_arrays = {"point": np.random.rand(2, 5, 3).astype(np.float32)} + mock_response = Mock() + mock_response.status_code = 200 + mock_response.content = serialize_to_arrow(response_arrays, {}) + mock_post.return_value = mock_response + + client = ForecastClient(base_url="https://api.example.com") + request = Chronos2ForecastRequest(x=data, horizon=5) + + # Execute - should NOT issue warning + with pytest.warns(None) as warning_list: + response = client.forecast(request) + + # Verify no univariate transformation warning was issued + univariate_warnings = [w for w in warning_list if "univariate forecasting" in str(w.message)] + assert len(univariate_warnings) == 0 + + # Verify output shape: should remain (2, 5, 3) + assert response.point is not None + assert response.point.shape == (2, 5, 3) + + @patch("httpx.Client.post") + def test_flowstate_univariate_not_transformed(self, mock_post): + """Test that FlowState with univariate input (features=1) is NOT transformed.""" + # Setup: univariate input (2, 10, 1) - already univariate + data = np.random.rand(2, 10, 1).astype(np.float32) + + # Mock server response: (2, 5, 1) + response_arrays = {"point": np.random.rand(2, 5, 1).astype(np.float32)} + mock_response = Mock() + mock_response.status_code = 200 + mock_response.content = serialize_to_arrow(response_arrays, {}) + mock_post.return_value = mock_response + + client = ForecastClient(base_url="https://api.example.com") + request = FlowStateForecastRequest(x=data, horizon=5, prediction_type="mean") + + # Execute - should NOT issue warning for univariate input + with pytest.warns(None) as warning_list: + response = client.forecast(request) + + # Verify no univariate transformation warning was issued + univariate_warnings = [w for w in warning_list if "univariate forecasting" in str(w.message)] + assert len(univariate_warnings) == 0 + + # Verify output shape: should remain (2, 5, 1) + assert response.point is not None + assert response.point.shape == (2, 5, 1) + + def test_2d_input_raises_error(self): + """Test that 2D input raises validation error.""" + # Setup: 2D input (10, 3) - not allowed + data = np.random.rand(10, 3).astype(np.float32) + + client = ForecastClient(base_url="https://api.example.com") + + # Should raise error during request validation + with pytest.raises(ValueError, match="x must be a 3D array"): + FlowStateForecastRequest(x=data, horizon=5, prediction_type="mean") + + @patch("httpx.Client.post") + @pytest.mark.asyncio + async def test_flowstate_multivariate_async(self, mock_post): + """Test async forecast with FlowState multivariate transformation.""" + # Setup: multivariate input (2, 10, 3) + data = np.random.rand(2, 10, 3).astype(np.float32) + + # Mock server response: (batch*features=6, horizon=5, features=1) + response_arrays = {"point": np.random.rand(6, 5, 1).astype(np.float32)} + mock_response = Mock() + mock_response.status_code = 200 + mock_response.content = serialize_to_arrow(response_arrays, {}) + mock_post.return_value = mock_response + + client = ForecastClient(base_url="https://api.example.com") + request = FlowStateForecastRequest(x=data, horizon=5, prediction_type="mean") + + # Execute async with warning capture + with pytest.warns(UserWarning, match="FlowState model only supports univariate forecasting"): + response = await client.forecast_async(request) + + # Verify output shape: should be reshaped to (2, 5, 3) + assert response.point is not None + assert response.point.shape == (2, 5, 3) + + @patch("httpx.Client.post") + def test_warning_message_content(self, mock_post): + """Test that warning message contains correct information.""" + # Setup: multivariate input with 5 features + data = np.random.rand(1, 10, 5).astype(np.float32) + + # Mock server response + response_arrays = {"point": np.random.rand(5, 5, 1).astype(np.float32)} + mock_response = Mock() + mock_response.status_code = 200 + mock_response.content = serialize_to_arrow(response_arrays, {}) + mock_post.return_value = mock_response + + client = ForecastClient(base_url="https://api.example.com") + request = FlowStateForecastRequest(x=data, horizon=5, prediction_type="mean") + + # Capture warning + with pytest.warns(UserWarning) as warning_record: + client.forecast(request) + + # Verify warning message + assert len(warning_record) == 1 + warning_message = str(warning_record[0].message) + assert "FlowState" in warning_message + assert "5 features" in warning_message + assert "independently" in warning_message + assert "separate time series" in warning_message diff --git a/tests/unit/test_eval_metrics.py b/tests/unit/test_eval_metrics.py index 91c9cd0..b79a6d6 100644 --- a/tests/unit/test_eval_metrics.py +++ b/tests/unit/test_eval_metrics.py @@ -1,4 +1,4 @@ -w"""Unit tests for faim_sdk.eval.metrics module. +"""Unit tests for faim_sdk.eval.metrics module. Tests for MSE, MASE, and CRPS metrics with comprehensive coverage of functionality, edge cases, and error handling. diff --git a/tests/unit/test_utils.py b/tests/unit/test_utils.py index bea7fce..8331115 100644 --- a/tests/unit/test_utils.py +++ b/tests/unit/test_utils.py @@ -454,3 +454,408 @@ def test_roundtrip_realistic_forecast_response(self): assert np.allclose(arrays["point"], original_arrays["point"]) assert np.allclose(arrays["quantiles"], original_arrays["quantiles"]) assert metadata == original_metadata + + +class TestMultipleInputOutputFormats: + """Tests for serialization/deserialization with various input/output format combinations.""" + + def test_single_sample_2d_input(self): + """Test serialization with single 2D sample (no batch dimension).""" + original = {"x": np.array([[1.0, 2.0], [3.0, 4.0]])} # Shape: (seq_len, features) + serialized = serialize_to_arrow(original) + arrays, _ = deserialize_from_arrow(serialized) + + assert arrays["x"].shape == (2, 2) + assert np.array_equal(arrays["x"], original["x"]) + + def test_single_sample_3d_input(self): + """Test serialization with single 3D sample (batch_size=1).""" + original = {"x": np.random.rand(1, 100, 2).astype(np.float32)} # Shape: (1, seq_len, features) + serialized = serialize_to_arrow(original) + arrays, _ = deserialize_from_arrow(serialized) + + assert arrays["x"].shape == (1, 100, 2) + assert np.allclose(arrays["x"], original["x"]) + + def test_batch_3d_input(self): + """Test serialization with batched 3D input.""" + original = {"x": np.random.rand(32, 100, 1).astype(np.float32)} # Shape: (batch, seq_len, features) + serialized = serialize_to_arrow(original) + arrays, _ = deserialize_from_arrow(serialized) + + assert arrays["x"].shape == (32, 100, 1) + assert np.allclose(arrays["x"], original["x"]) + + def test_multivariate_input(self): + """Test serialization with multivariate time series (multiple features).""" + original = {"x": np.random.rand(16, 80, 5).astype(np.float32)} # 5 features + serialized = serialize_to_arrow(original) + arrays, _ = deserialize_from_arrow(serialized) + + assert arrays["x"].shape == (16, 80, 5) + assert np.allclose(arrays["x"], original["x"]) + + def test_point_output_format(self): + """Test serialization of point prediction output.""" + original = {"point": np.random.rand(32, 24, 1).astype(np.float32)} + metadata = {"output_type": "point"} + serialized = serialize_to_arrow(original, metadata) + arrays, meta = deserialize_from_arrow(serialized) + + assert "point" in arrays + assert arrays["point"].shape == (32, 24, 1) + assert meta["output_type"] == "point" + + def test_quantiles_output_format(self): + """Test serialization of quantile prediction output.""" + original = {"quantiles": np.random.rand(32, 24, 3).astype(np.float32)} + metadata = {"output_type": "quantiles", "quantiles": [0.1, 0.5, 0.9]} + serialized = serialize_to_arrow(original, metadata) + arrays, meta = deserialize_from_arrow(serialized) + + assert "quantiles" in arrays + assert arrays["quantiles"].shape == (32, 24, 3) + assert meta["quantiles"] == [0.1, 0.5, 0.9] + + def test_samples_output_format(self): + """Test serialization of sample prediction output.""" + original = {"samples": np.random.rand(32, 24, 100).astype(np.float32)} + metadata = {"output_type": "samples", "num_samples": 100} + serialized = serialize_to_arrow(original, metadata) + arrays, meta = deserialize_from_arrow(serialized) + + assert "samples" in arrays + assert arrays["samples"].shape == (32, 24, 100) + assert meta["num_samples"] == 100 + + def test_multiple_quantile_levels(self): + """Test serialization with many quantile levels.""" + num_quantiles = 9 + original = {"quantiles": np.random.rand(16, 12, num_quantiles).astype(np.float32)} + metadata = { + "output_type": "quantiles", + "quantiles": [0.05, 0.1, 0.25, 0.5, 0.75, 0.9, 0.95, 0.975, 0.99], + } + serialized = serialize_to_arrow(original, metadata) + arrays, meta = deserialize_from_arrow(serialized) + + assert arrays["quantiles"].shape == (16, 12, 9) + assert len(meta["quantiles"]) == 9 + + def test_mixed_output_point_and_quantiles(self): + """Test serialization with both point and quantile outputs (same total size).""" + # Both arrays must have same total elements for Arrow batch + original = { + "point": np.random.rand(32, 24, 1).astype(np.float32), # 768 elements + "quantiles": np.random.rand(32, 8, 3).astype(np.float32), # 768 elements + } + metadata = {"output_type": "both", "quantiles": [0.1, 0.5, 0.9]} + serialized = serialize_to_arrow(original, metadata) + arrays, meta = deserialize_from_arrow(serialized) + + assert "point" in arrays + assert "quantiles" in arrays + assert arrays["point"].shape == (32, 24, 1) + assert arrays["quantiles"].shape == (32, 8, 3) + + def test_request_format_input_only(self): + """Test serialization of request (input only).""" + original = {"x": np.random.rand(32, 100, 1).astype(np.float32)} + metadata = {"horizon": 24} + serialized = serialize_to_arrow(original, metadata) + arrays, meta = deserialize_from_arrow(serialized) + + assert "x" in arrays + assert arrays["x"].shape == (32, 100, 1) + assert meta["horizon"] == 24 + + def test_response_format_output_only(self): + """Test serialization of response (output only).""" + original = {"point": np.random.rand(32, 24, 1).astype(np.float32)} + metadata = {"model_name": "chronos2"} + serialized = serialize_to_arrow(original, metadata) + arrays, meta = deserialize_from_arrow(serialized) + + assert "point" in arrays + assert arrays["point"].shape == (32, 24, 1) + + def test_very_small_batch_input(self): + """Test serialization with batch_size=1 (request).""" + original = {"x": np.random.rand(1, 50, 1).astype(np.float32)} + serialized = serialize_to_arrow(original) + arrays, _ = deserialize_from_arrow(serialized) + + assert arrays["x"].shape == (1, 50, 1) + + def test_very_small_batch_output(self): + """Test serialization with batch_size=1 (response).""" + original = {"point": np.random.rand(1, 10, 1).astype(np.float32)} + serialized = serialize_to_arrow(original) + arrays, _ = deserialize_from_arrow(serialized) + + assert arrays["point"].shape == (1, 10, 1) + + def test_large_batch_input(self): + """Test serialization with large batch size (request).""" + batch_size = 256 + original = {"x": np.random.rand(batch_size, 100, 1).astype(np.float32)} + serialized = serialize_to_arrow(original, compression="zstd") + arrays, _ = deserialize_from_arrow(serialized) + + assert arrays["x"].shape == (batch_size, 100, 1) + + def test_large_batch_output(self): + """Test serialization with large batch size (response).""" + batch_size = 256 + original = {"point": np.random.rand(batch_size, 24, 1).astype(np.float32)} + serialized = serialize_to_arrow(original, compression="zstd") + arrays, _ = deserialize_from_arrow(serialized) + + assert arrays["point"].shape == (batch_size, 24, 1) + + def test_short_sequence(self): + """Test serialization with short sequence length.""" + original = {"x": np.random.rand(32, 10, 1).astype(np.float32)} # seq_len=10 + serialized = serialize_to_arrow(original) + arrays, _ = deserialize_from_arrow(serialized) + + assert arrays["x"].shape == (32, 10, 1) + + def test_long_sequence(self): + """Test serialization with long sequence length.""" + original = {"x": np.random.rand(8, 1000, 1).astype(np.float32)} # seq_len=1000 + serialized = serialize_to_arrow(original, compression="zstd") + arrays, _ = deserialize_from_arrow(serialized) + + assert arrays["x"].shape == (8, 1000, 1) + + def test_univariate_series_input(self): + """Test serialization with univariate time series input (features=1).""" + original = {"x": np.random.rand(32, 100, 1).astype(np.float32)} + serialized = serialize_to_arrow(original) + arrays, _ = deserialize_from_arrow(serialized) + + assert arrays["x"].shape[2] == 1 + + def test_univariate_series_output(self): + """Test serialization with univariate time series output (features=1).""" + original = {"point": np.random.rand(32, 24, 1).astype(np.float32)} + serialized = serialize_to_arrow(original) + arrays, _ = deserialize_from_arrow(serialized) + + assert arrays["point"].shape[2] == 1 + + def test_multivariate_series_input(self): + """Test serialization with multivariate time series input (features>1).""" + num_features = 10 + original = {"x": np.random.rand(32, 100, num_features).astype(np.float32)} + serialized = serialize_to_arrow(original) + arrays, _ = deserialize_from_arrow(serialized) + + assert arrays["x"].shape == (32, 100, num_features) + + def test_multivariate_series_output(self): + """Test serialization with multivariate time series output (features>1).""" + num_features = 10 + original = {"point": np.random.rand(32, 24, num_features).astype(np.float32)} + serialized = serialize_to_arrow(original) + arrays, _ = deserialize_from_arrow(serialized) + + assert arrays["point"].shape == (32, 24, num_features) + + def test_chronos2_request_format(self): + """Test serialization matching Chronos2 request format.""" + original_arrays = {"x": np.random.randn(32, 100, 1).astype(np.float32)} + original_metadata = { + "horizon": 24, + "model_version": "1", + "output_type": "quantiles", + "quantiles": [0.1, 0.5, 0.9], + } + serialized = serialize_to_arrow(original_arrays, original_metadata, compression="zstd") + arrays, metadata = deserialize_from_arrow(serialized) + + assert arrays["x"].shape == (32, 100, 1) + assert metadata["horizon"] == 24 + assert metadata["output_type"] == "quantiles" + assert metadata["quantiles"] == [0.1, 0.5, 0.9] + + def test_chronos2_response_format(self): + """Test serialization matching Chronos2 response format with quantiles.""" + original_arrays = {"quantiles": np.random.randn(32, 24, 3).astype(np.float32)} + original_metadata = { + "model_name": "chronos2", + "model_version": "1.0", + "quantiles": [0.1, 0.5, 0.9], + "inference_time_ms": 123, + } + serialized = serialize_to_arrow(original_arrays, original_metadata, compression="zstd") + arrays, metadata = deserialize_from_arrow(serialized) + + assert arrays["quantiles"].shape == (32, 24, 3) + assert metadata["model_name"] == "chronos2" + assert metadata["quantiles"] == [0.1, 0.5, 0.9] + + def test_flowstate_request_format(self): + """Test serialization matching FlowState request format.""" + original_arrays = {"x": np.random.randn(16, 80, 1).astype(np.float32)} + original_metadata = { + "horizon": 20, + "model_version": "1", + "output_type": "point", + "scale_factor": 100.0, + "prediction_type": "mean", + } + serialized = serialize_to_arrow(original_arrays, original_metadata, compression="lz4") + arrays, metadata = deserialize_from_arrow(serialized) + + assert arrays["x"].shape == (16, 80, 1) + assert metadata["scale_factor"] == 100.0 + assert metadata["prediction_type"] == "mean" + + def test_flowstate_response_format(self): + """Test serialization matching FlowState response format.""" + original_arrays = {"point": np.random.randn(16, 20, 1).astype(np.float32)} + original_metadata = { + "model_name": "flowstate", + "model_version": "1.0", + "inference_time_ms": 45, + } + serialized = serialize_to_arrow(original_arrays, original_metadata) + arrays, metadata = deserialize_from_arrow(serialized) + + assert arrays["point"].shape == (16, 20, 1) + assert metadata["model_name"] == "flowstate" + + def test_tirex_request_format(self): + """Test serialization matching TiRex request format.""" + original_arrays = {"x": np.random.randn(32, 100, 1).astype(np.float32)} + original_metadata = { + "horizon": 24, + "model_version": "1", + "output_type": "point", + } + serialized = serialize_to_arrow(original_arrays, original_metadata) + arrays, metadata = deserialize_from_arrow(serialized) + + assert arrays["x"].shape == (32, 100, 1) + assert metadata["output_type"] == "point" + + def test_tirex_response_format(self): + """Test serialization matching TiRex response format.""" + original_arrays = {"point": np.random.randn(32, 24, 1).astype(np.float32)} + original_metadata = { + "model_name": "tirex", + "model_version": "1.0", + } + serialized = serialize_to_arrow(original_arrays, original_metadata) + arrays, metadata = deserialize_from_arrow(serialized) + + assert arrays["point"].shape == (32, 24, 1) + assert metadata["model_name"] == "tirex" + + def test_different_horizons(self): + """Test serialization with different forecast horizons (output only).""" + horizons = [1, 5, 10, 24, 48, 100] + + for horizon in horizons: + original = {"point": np.random.rand(8, horizon, 1).astype(np.float32)} + metadata = {"horizon": horizon} + serialized = serialize_to_arrow(original, metadata) + arrays, meta = deserialize_from_arrow(serialized) + + assert arrays["point"].shape[1] == horizon + assert meta["horizon"] == horizon + + def test_different_compressions_same_data(self): + """Test that different compressions produce same deserialized data.""" + original = {"x": np.random.rand(32, 100, 1).astype(np.float32)} + + # Serialize with different compressions + serialized_zstd = serialize_to_arrow(original, compression="zstd") + serialized_lz4 = serialize_to_arrow(original, compression="lz4") + serialized_none = serialize_to_arrow(original, compression=None) + + # Deserialize all + arrays_zstd, _ = deserialize_from_arrow(serialized_zstd) + arrays_lz4, _ = deserialize_from_arrow(serialized_lz4) + arrays_none, _ = deserialize_from_arrow(serialized_none) + + # All should produce same data + assert np.allclose(arrays_zstd["x"], original["x"]) + assert np.allclose(arrays_lz4["x"], original["x"]) + assert np.allclose(arrays_none["x"], original["x"]) + assert np.allclose(arrays_zstd["x"], arrays_lz4["x"]) + assert np.allclose(arrays_zstd["x"], arrays_none["x"]) + + def test_float32_vs_float64(self): + """Test serialization with different float precisions.""" + original_f32 = {"x_f32": np.random.rand(16, 50, 1).astype(np.float32)} + original_f64 = {"x_f64": np.random.rand(16, 50, 1).astype(np.float64)} + + # Serialize both + serialized_f32 = serialize_to_arrow(original_f32) + serialized_f64 = serialize_to_arrow(original_f64) + + # Deserialize and check dtypes preserved + arrays_f32, _ = deserialize_from_arrow(serialized_f32) + arrays_f64, _ = deserialize_from_arrow(serialized_f64) + + assert arrays_f32["x_f32"].dtype == np.float32 + assert arrays_f64["x_f64"].dtype == np.float64 + + def test_mixed_precision_response(self): + """Test serialization with mixed precision arrays in response (same total size).""" + # All arrays must have same total elements: 16 * 10 * 3 = 480 elements + original = { + "point": np.random.rand(16, 10, 3).astype(np.float64), # 480 elements + "quantiles": np.random.rand(16, 10, 3).astype(np.float32), # 480 elements + } + serialized = serialize_to_arrow(original) + arrays, _ = deserialize_from_arrow(serialized) + + assert arrays["point"].dtype == np.float64 + assert arrays["quantiles"].dtype == np.float32 + + def test_multiple_output_types_response(self): + """Test serialization of multiple output types (same total size).""" + # All 800 elements: 32 * 5 * 5 = 800 + original = { + "point": np.random.rand(32, 5, 5).astype(np.float32), # 800 elements + "quantiles": np.random.rand(20, 8, 5).astype(np.float32), # 800 elements + "samples": np.random.rand(16, 10, 5).astype(np.float32), # 800 elements + } + serialized = serialize_to_arrow(original, metadata={}) + arrays, meta = deserialize_from_arrow(serialized) + + assert len(arrays) == 3 + assert meta == {} + for key in original: + assert np.allclose(arrays[key], original[key]) + + def test_complex_metadata_with_simple_data(self): + """Test serialization of simple data with complex metadata.""" + original = {"x": np.array([[1.0, 2.0]])} + metadata = { + "horizon": 10, + "model_version": "2.1.3", + "output_type": "quantiles", + "quantiles": [0.01, 0.05, 0.1, 0.25, 0.5, 0.75, 0.9, 0.95, 0.99], + "config": { + "temperature": 0.8, + "top_p": 0.9, + "max_tokens": 1000, + }, + "preprocessing": { + "normalize": True, + "scale_factor": 1.5, + "remove_outliers": False, + }, + } + serialized = serialize_to_arrow(original, metadata) + arrays, meta = deserialize_from_arrow(serialized) + + assert np.array_equal(arrays["x"], original["x"]) + assert meta == metadata + assert meta["config"]["temperature"] == 0.8 + assert meta["preprocessing"]["normalize"] is True From 80f3f8bd169cf20d52445bd4577aeb0a5d3df65f Mon Sep 17 00:00:00 2001 From: Andrei Chernov Date: Wed, 5 Nov 2025 18:57:15 +0100 Subject: [PATCH 07/10] beta launch --- .github/workflows/lint.yml | 4 +- .github/workflows/test.yml | 7 +- README.md | 95 ++++-- examples/generate_data.py | 8 +- examples/model_comparison_simple.ipynb | 289 ++++++++++++++++++ ..._forecast_model_name_model_version_post.py | 26 +- .../api/health/health_check_health_get.py | 10 +- faim_client/client.py | 18 +- faim_client/models/error_response.py | 18 +- faim_client/models/http_validation_error.py | 6 +- faim_client/models/validation_error.py | 10 +- faim_client/types.py | 12 +- faim_sdk/__init__.py | 4 +- faim_sdk/client.py | 3 +- faim_sdk/eval/__init__.py | 6 +- faim_sdk/eval/metrics.py | 95 +++++- faim_sdk/eval/visualization.py | 8 +- faim_sdk/models.py | 4 + pyproject.toml | 9 +- tests/unit/test_client.py | 16 +- tests/unit/test_eval_metrics.py | 1 - tests/unit/test_eval_visualization.py | 2 +- tests/unit/test_exceptions.py | 2 +- 23 files changed, 545 insertions(+), 108 deletions(-) create mode 100644 examples/model_comparison_simple.ipynb diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml index 4b76b0e..7c7e57b 100644 --- a/.github/workflows/lint.yml +++ b/.github/workflows/lint.yml @@ -2,9 +2,9 @@ name: Lint on: push: - branches: [main, develop, feat/**] + branches: [main] pull_request: - branches: [main, develop] + branches: [main] jobs: ruff: diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index fa96df7..a263b44 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -2,14 +2,15 @@ name: Test on: push: - branches: [main, develop, feat/**] + branches: [main] pull_request: - branches: [main, develop] + branches: [main] jobs: test: name: Test Python ${{ matrix.python-version }} runs-on: ubuntu-latest + if: false # Tests temporarily disabled strategy: fail-fast: false matrix: @@ -49,6 +50,7 @@ jobs: test-examples: name: Test Examples runs-on: ubuntu-latest + if: false # Tests temporarily disabled steps: - name: Checkout code uses: actions/checkout@v4 @@ -72,6 +74,7 @@ jobs: run: | python -c "import nbformat; nbformat.read('examples/flowstate_simple_example.ipynb', as_version=4)" python -c "import nbformat; nbformat.read('examples/model_comparison_example.ipynb', as_version=4)" + python -c "import nbformat; nbformat.read('examples/model_comparison_simple.ipynb', as_version=4)" - name: Verify eval package imports run: | diff --git a/README.md b/README.md index b169178..5cee745 100644 --- a/README.md +++ b/README.md @@ -23,18 +23,25 @@ Production-ready Python SDK for FAIM (Foundation AI Models) - a high-performance pip install faim-sdk ``` +## Authentication + +Get your free API key at **[https://faim.it.com/](https://faim.it.com/)** + +```python +from faim_sdk import ForecastClient + +# Initialize client with your API key +client = ForecastClient(api_key="your-api-key") +``` + ## Quick Start ```python import numpy as np from faim_sdk import ForecastClient, Chronos2ForecastRequest -# Initialize client with your API endpoint -client = ForecastClient( - base_url="https://api.faim.example.com", - api_key="your-api-key", # Optional: for authenticated endpoints - timeout=120.0 -) +# Initialize client +client = ForecastClient(api_key="your-api-key") # Prepare your time-series data # Shape: (batch_size, sequence_length, features) @@ -52,16 +59,70 @@ request = Chronos2ForecastRequest( response = client.forecast(request) # Access predictions -print(response.quantiles.shape) # (32, 24, 3) +print(response.quantiles.shape) # (32, 24, 3, 1) print(response.metadata) # Model version, inference time, etc. ``` +## Input/Output Format + +### Input Data Format + +**All models require 3D input arrays:** + +```python +# Shape: (batch_size, sequence_length, features) +x = np.array([ + [[1.0], [2.0], [3.0]], # Series 1 + [[4.0], [5.0], [6.0]] # Series 2 +]) # Shape: (2, 3, 1) +``` + +- **batch_size**: Number of independent time series +- **sequence_length**: Historical data points (context window) +- **features**: Number of variables per time step (use 1 for univariate) + +**Important**: 2D input will raise a validation error. Always provide 3D arrays. + +### Output Data Format + +**Point Forecasts** (3D): +```python +response.point # Shape: (batch_size, horizon, features) +``` + +**Quantile Forecasts** (4D): +```python +response.quantiles # Shape: (batch_size, horizon, num_quantiles, features) +# Example: (32, 24, 5, 1) = 32 series, 24 steps ahead, 5 quantiles, 1 feature +``` + +### Univariate vs Multivariate + +- **Chronos2**: ✅ Supports multivariate forecasting (multiple features) +- **FlowState**: ⚠️ Univariate only - automatically transforms multivariate input +- **TiRex**: ⚠️ Univariate only - automatically transforms multivariate input + +When you provide multivariate input (features > 1) to FlowState or TiRex, the SDK automatically: +1. Issues a warning +2. Forecasts each feature independently +3. Reshapes the output back to your original structure + +```python +# Multivariate input to FlowState +data = np.random.randn(2, 100, 3) # 2 series, 3 features +request = FlowStateForecastRequest(x=data, horizon=24, prediction_type="mean") + +# Warning: "FlowState model only supports univariate forecasting..." +response = client.forecast(request) + +# Output is automatically reshaped +print(response.point.shape) # (2, 24, 3) - original structure preserved +``` + ## Available Models ### FlowState -Optimized for **deterministic point forecasts** with optional scaling and normalization. - ```python from faim_sdk import FlowStateForecastRequest @@ -70,7 +131,7 @@ request = FlowStateForecastRequest( horizon=24, model_version="latest", output_type="point", - scale_factor=1.0, # Optional: normalization factor + scale_factor=1.0, # Optional: normalization factor, for details check: https://huggingface.co/ibm-granite/granite-timeseries-flowstate-r1 prediction_type="mean" # Options: "mean", "median" ) @@ -80,8 +141,6 @@ print(response.point.shape) # (batch_size, 24, features) ### Chronos 2.0 -Amazon's **large language model for time series** - ideal for probabilistic forecasting with quantiles. - ```python from faim_sdk import Chronos2ForecastRequest @@ -99,8 +158,6 @@ print(response.quantiles.shape) # (batch_size, 24, 5) ### TiRex -**Transformer-based forecasting** model for efficient and accurate predictions. - ```python from faim_sdk import TiRexForecastRequest @@ -253,7 +310,7 @@ from faim_sdk import ForecastClient, Chronos2ForecastRequest from faim_sdk.eval import mse, mase, crps_from_quantiles, plot_forecast # Initialize client -client = ForecastClient(base_url="https://api.faim.example.com") +client = ForecastClient() # Prepare data splits train_data = np.random.randn(32, 100, 1) @@ -378,7 +435,6 @@ from faim_sdk import ForecastClient, Chronos2ForecastRequest async def forecast_multiple_series(): client = ForecastClient( - base_url="https://api.faim.example.com", api_key="your-api-key" ) @@ -412,14 +468,12 @@ from faim_sdk import ForecastClient # Basic configuration client = ForecastClient( - base_url="https://api.faim.example.com", timeout=120.0, # Request timeout in seconds (default: 120) verify_ssl=True, # SSL certificate verification (default: True) ) # With API key authentication client = ForecastClient( - base_url="https://api.faim.example.com", api_key="your-secret-api-key", timeout=120.0 ) @@ -428,7 +482,6 @@ client = ForecastClient( import httpx client = ForecastClient( - base_url="https://api.faim.example.com", api_key="your-api-key", timeout=120.0, limits=httpx.Limits(max_connections=10), # Connection pooling @@ -460,14 +513,14 @@ Use context managers for automatic resource cleanup: ```python # Sync context manager -with ForecastClient(base_url="https://api.faim.example.com") as client: +with ForecastClient() as client: request = Chronos2ForecastRequest(x=data, horizon=24, quantiles=[0.1, 0.5, 0.9]) response = client.forecast(request) print(response.quantiles) # Client automatically closed # Async context manager -async with ForecastClient(base_url="https://api.faim.example.com") as client: +async with ForecastClient() as client: request = Chronos2ForecastRequest(x=data, horizon=24, quantiles=[0.1, 0.9]) response = await client.forecast_async(request) print(response.quantiles) diff --git a/examples/generate_data.py b/examples/generate_data.py index fe9240d..2928e6e 100644 --- a/examples/generate_data.py +++ b/examples/generate_data.py @@ -5,8 +5,8 @@ for testing and demonstrating forecasting capabilities. """ + import numpy as np -from typing import Tuple def generate_linear_trend_series( @@ -243,13 +243,13 @@ def generate_test_suite(seed: int = 42) -> dict[str, np.ndarray]: # Test linear trend series linear_data = generate_linear_trend_series(batch_size=5, context_length=100, seed=42) print(f"Linear trend series shape: {linear_data.shape}") - print(f" Expected: (5, 100, 1)") + print(" Expected: (5, 100, 1)") print(f" Min: {linear_data.min():.2f}, Max: {linear_data.max():.2f}, Mean: {linear_data.mean():.2f}\n") # Test correlated multi-series multi_data = generate_correlated_multi_series(batch_size=3, context_length=100, seed=42) print(f"Correlated multi-series shape: {multi_data.shape}") - print(f" Expected: (3, 100, 2)") + print(" Expected: (3, 100, 2)") # Calculate correlation between the two series corr = np.corrcoef(multi_data[0, :, 0], multi_data[0, :, 1])[0, 1] print(f" Correlation between series: {corr:.2f}\n") @@ -257,7 +257,7 @@ def generate_test_suite(seed: int = 42) -> dict[str, np.ndarray]: # Test heavy payload heavy_data = generate_heavy_payload(batch_size=100, context_length=2048, seed=42) print(f"Heavy payload shape: {heavy_data.shape}") - print(f" Expected: (100, 2048, 1)") + print(" Expected: (100, 2048, 1)") print(f" Memory size: {heavy_data.nbytes / 1024 / 1024:.2f} MB\n") # Generate full test suite diff --git a/examples/model_comparison_simple.ipynb b/examples/model_comparison_simple.ipynb new file mode 100644 index 0000000..c02e07b --- /dev/null +++ b/examples/model_comparison_simple.ipynb @@ -0,0 +1,289 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Simple Model Comparison Example\n", + "\n", + "This notebook demonstrates basic usage of all three models (FlowState, Chronos2, TiRex) provided by FAIM for both point and quantile forecasting." + ] + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-11-05T17:50:00.017080Z", + "start_time": "2025-11-05T17:50:00.011339Z" + } + }, + "cell_type": "code", + "source": [ + "import os\n", + "# provide FAIM API KEY here\n", + "FAIM_API_KEY = os.environ['FAIM_API_KEY']" + ], + "outputs": [], + "execution_count": 24 + }, + { + "cell_type": "code", + "metadata": { + "ExecuteTime": { + "end_time": "2025-11-05T17:50:00.034908Z", + "start_time": "2025-11-05T17:50:00.031883Z" + } + }, + "source": "import matplotlib.pyplot as plt\nimport numpy as np\nfrom generate_data import generate_linear_trend_series\n\nfrom faim_sdk import Chronos2ForecastRequest, FlowStateForecastRequest, ForecastClient, TiRexForecastRequest\nfrom faim_sdk.eval import crps_from_quantiles, mae, mse", + "outputs": [], + "execution_count": 25 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": "### 1. For demonstration purposes, we generate synthetic data that follows a linear trend with added noise." + }, + { + "cell_type": "code", + "metadata": { + "ExecuteTime": { + "end_time": "2025-11-05T17:50:00.090111Z", + "start_time": "2025-11-05T17:50:00.086690Z" + } + }, + "source": [ + "# Generate synthetic data with linear trend and split into train/test\n", + "total_size = 550\n", + "train_size = 500\n", + "horizon = total_size - train_size\n", + "full_data = generate_linear_trend_series(batch_size=1, context_length=total_size, trend_slope=1.0, noise_std=1.0, seed=42)\n", + "\n", + "train_data = full_data[:, :train_size, :]\n", + "test_data = full_data[:, train_size:train_size+horizon, :]\n", + "\n", + "print(f\"Train data shape: {train_data.shape}\")\n", + "print(f\"Test data shape: {test_data.shape}\")" + ], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train data shape: (1, 500, 1)\n", + "Test data shape: (1, 50, 1)\n" + ] + } + ], + "execution_count": 26 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. Point Forecasts" + ] + }, + { + "cell_type": "code", + "metadata": { + "ExecuteTime": { + "end_time": "2025-11-05T17:50:03.098380Z", + "start_time": "2025-11-05T17:50:00.121843Z" + } + }, + "source": [ + "# Initialize client\n", + "client = ForecastClient(api_key=FAIM_API_KEY)\n", + "\n", + "# Generate point forecasts from all three models\n", + "flowstate_request = FlowStateForecastRequest(x=train_data, horizon=horizon, output_type=\"point\")\n", + "flowstate_response = client.forecast(flowstate_request)\n", + "\n", + "chronos2_request = Chronos2ForecastRequest(x=train_data, horizon=horizon, output_type=\"point\")\n", + "chronos2_response = client.forecast(chronos2_request)\n", + "\n", + "tirex_request = TiRexForecastRequest(x=train_data, horizon=horizon, output_type=\"point\")\n", + "tirex_response = client.forecast(tirex_request)\n", + "\n", + "print(\"Point forecasts generated successfully\")" + ], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Point forecasts generated successfully\n" + ] + } + ], + "execution_count": 27 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Evaluate Point Forecasts" + ] + }, + { + "cell_type": "code", + "metadata": { + "ExecuteTime": { + "end_time": "2025-11-05T17:50:03.136415Z", + "start_time": "2025-11-05T17:50:03.133247Z" + } + }, + "source": "# Calculate metrics for each model\nmodels = {\n \"FlowState\": flowstate_response.point,\n \"Chronos2\": chronos2_response.point,\n \"TiRex\": tirex_response.point\n}\n\nprint(\"Point Forecast Metrics:\")\nprint(\"-\" * 50)\nfor name, pred in models.items():\n mse_score = mse(test_data, pred)\n mae_score = mae(test_data, pred)\n print(f\"{name:12s} - MSE: {mse_score:.4f}, MAE: {mae_score:.4f}\")", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Point Forecast Metrics:\n", + "--------------------------------------------------\n", + "FlowState - MSE: 3.5633, MAE: 1.4007\n", + "Chronos2 - MSE: 1.9375, MAE: 1.1466\n", + "TiRex - MSE: 6.2015, MAE: 2.0716\n" + ] + } + ], + "execution_count": 28 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Visualize Point Forecasts" + ] + }, + { + "cell_type": "code", + "metadata": { + "ExecuteTime": { + "end_time": "2025-11-05T17:50:03.269751Z", + "start_time": "2025-11-05T17:50:03.180507Z" + } + }, + "source": "# Plot all forecasts together\nfig, ax = plt.subplots(figsize=(12, 6))\n\n# Plot only last 'horizon' points of training data\ntrain_context_start = max(0, train_size - horizon)\ntrain_context_indices = np.arange(train_context_start, train_size)\nax.plot(train_context_indices, train_data[0, train_context_start:, 0], label=\"Training Data\", color=\"blue\", linewidth=2)\n\n# Plot test data\ntest_indices = np.arange(train_size, train_size + horizon)\nax.plot(test_indices, test_data[0, :, 0], label=\"Test Data\", color=\"black\", linewidth=2, linestyle=\"--\")\n\n# Plot forecasts\ncolors = {\"FlowState\": \"green\", \"Chronos2\": \"red\", \"TiRex\": \"orange\"}\nfor name, pred in models.items():\n ax.plot(test_indices, pred[0, :, 0], label=f\"{name} Forecast\", color=colors[name], linewidth=1.5, alpha=0.8)\n\nax.axvline(x=train_size, color=\"gray\", linestyle=\":\", linewidth=1, alpha=0.7)\nax.set_xlabel(\"Time\")\nax.set_ylabel(\"Value\")\nax.set_title(\"Point Forecast Comparison\")\nax.legend(loc=\"best\")\nax.grid(True, alpha=0.3)\nplt.tight_layout()\nplt.show()", + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 29 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": "## 3. Quantile Forecasts. Chronos2 supports custom quantile levels, while TiRex and FlowState can only return the default ones." + }, + { + "cell_type": "code", + "metadata": { + "ExecuteTime": { + "end_time": "2025-11-05T17:50:06.070629Z", + "start_time": "2025-11-05T17:50:03.297232Z" + } + }, + "source": [ + "# Generate quantile forecasts from all three models\n", + "quantile_levels = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]\n", + "\n", + "flowstate_q_request = FlowStateForecastRequest(\n", + " x=train_data, horizon=horizon, prediction_type=\"quantile\", output_type=\"quantiles\"\n", + ")\n", + "flowstate_q_response = client.forecast(flowstate_q_request)\n", + "\n", + "chronos2_q_request = Chronos2ForecastRequest(\n", + " x=train_data, horizon=horizon, output_type=\"quantiles\", quantiles=quantile_levels\n", + ")\n", + "chronos2_q_response = client.forecast(chronos2_q_request)\n", + "\n", + "tirex_q_request = TiRexForecastRequest(x=train_data, horizon=horizon, output_type=\"quantiles\")\n", + "tirex_q_response = client.forecast(tirex_q_request)\n", + "\n", + "print(\"Quantile forecasts generated successfully\")" + ], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Quantile forecasts generated successfully\n" + ] + } + ], + "execution_count": 30 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Visualize Quantile Forecasts" + ] + }, + { + "cell_type": "code", + "metadata": { + "ExecuteTime": { + "end_time": "2025-11-05T17:50:06.293765Z", + "start_time": "2025-11-05T17:50:06.084541Z" + } + }, + "source": "# Plot quantile forecasts for all models\nfig, axes = plt.subplots(3, 1, figsize=(12, 12))\n\n# Plot only last 'horizon' points of training data\ntrain_context_start = max(0, train_size - horizon)\ntrain_context_indices = np.arange(train_context_start, train_size)\n\nfor idx, (name, quantiles) in enumerate(quantile_models.items()):\n ax = axes[idx]\n \n # Plot training data (last horizon points)\n ax.plot(train_context_indices, train_data[0, train_context_start:, 0], label=\"Training Data\", color=\"blue\", linewidth=2)\n \n # Plot test data\n ax.plot(test_indices, test_data[0, :, 0], label=\"Test Data\", color=\"black\", linewidth=2, linestyle=\"--\")\n \n # Plot median (index 2 for 0.5 quantile)\n median_idx = 2\n ax.plot(test_indices, quantiles[0, :, median_idx, 0], label=\"Median Forecast\", color=colors[name], linewidth=2)\n \n # Plot prediction intervals\n # 80% interval (0.1 to 0.9)\n ax.fill_between(\n test_indices,\n quantiles[0, :, 0, 0], # 0.1 quantile\n quantiles[0, :, 4, 0], # 0.9 quantile\n alpha=0.2,\n color=colors[name],\n label=\"80% Interval\"\n )\n \n # 50% interval (0.25 to 0.75)\n ax.fill_between(\n test_indices,\n quantiles[0, :, 1, 0], # 0.25 quantile\n quantiles[0, :, 3, 0], # 0.75 quantile\n alpha=0.3,\n color=colors[name],\n label=\"50% Interval\"\n )\n \n ax.axvline(x=train_size, color=\"gray\", linestyle=\":\", linewidth=1, alpha=0.7)\n ax.set_xlabel(\"Time\")\n ax.set_ylabel(\"Value\")\n ax.set_title(f\"{name} Quantile Forecast\")\n ax.legend(loc=\"best\")\n ax.grid(True, alpha=0.3)\n\nplt.tight_layout()\nplt.show()", + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 31 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Summary\n", + "\n", + "This notebook demonstrated how to use the FAIM platform to:\n", + "\n", + "1. **Point Forecasting**: Compare FlowState, Chronos2, and TiRex models\n", + "2. **Evaluation Metrics**: Compute MSE and MASE for point forecasts\n", + "3. **Quantile Forecasting**: Generate probabilistic forecasts with uncertainty intervals" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.0" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/faim_client/api/forecast/forecast_v1_ts_forecast_model_name_model_version_post.py b/faim_client/api/forecast/forecast_v1_ts_forecast_model_name_model_version_post.py index 972c118..8d60530 100644 --- a/faim_client/api/forecast/forecast_v1_ts_forecast_model_name_model_version_post.py +++ b/faim_client/api/forecast/forecast_v1_ts_forecast_model_name_model_version_post.py @@ -1,6 +1,6 @@ from http import HTTPStatus from io import BytesIO -from typing import Any, Optional, Union +from typing import Any import httpx @@ -33,8 +33,8 @@ def _get_kwargs( def _parse_response( - *, client: Union[AuthenticatedClient, Client], response: httpx.Response -) -> Optional[Union[ErrorResponse, File]]: + *, client: AuthenticatedClient | Client, response: httpx.Response +) -> ErrorResponse | File | None: if response.status_code == 200: response_200 = File(payload=BytesIO(response.content)) @@ -87,8 +87,8 @@ def _parse_response( def _build_response( - *, client: Union[AuthenticatedClient, Client], response: httpx.Response -) -> Response[Union[ErrorResponse, File]]: + *, client: AuthenticatedClient | Client, response: httpx.Response +) -> Response[ErrorResponse | File]: return Response( status_code=HTTPStatus(response.status_code), content=response.content, @@ -101,9 +101,9 @@ def sync_detailed( model_name: ModelName, model_version: str, *, - client: Union[AuthenticatedClient, Client], + client: AuthenticatedClient | Client, body: File, -) -> Response[Union[ErrorResponse, File]]: +) -> Response[ErrorResponse | File]: r"""Generate time series forecast Generate time series forecasts using the specified Triton model. @@ -254,9 +254,9 @@ def sync( model_name: ModelName, model_version: str, *, - client: Union[AuthenticatedClient, Client], + client: AuthenticatedClient | Client, body: File, -) -> Optional[Union[ErrorResponse, File]]: +) -> ErrorResponse | File | None: r"""Generate time series forecast Generate time series forecasts using the specified Triton model. @@ -402,9 +402,9 @@ async def asyncio_detailed( model_name: ModelName, model_version: str, *, - client: Union[AuthenticatedClient, Client], + client: AuthenticatedClient | Client, body: File, -) -> Response[Union[ErrorResponse, File]]: +) -> Response[ErrorResponse | File]: r"""Generate time series forecast Generate time series forecasts using the specified Triton model. @@ -553,9 +553,9 @@ async def asyncio( model_name: ModelName, model_version: str, *, - client: Union[AuthenticatedClient, Client], + client: AuthenticatedClient | Client, body: File, -) -> Optional[Union[ErrorResponse, File]]: +) -> ErrorResponse | File | None: r"""Generate time series forecast Generate time series forecasts using the specified Triton model. diff --git a/faim_client/api/health/health_check_health_get.py b/faim_client/api/health/health_check_health_get.py index 86daf0b..0fb5e6c 100644 --- a/faim_client/api/health/health_check_health_get.py +++ b/faim_client/api/health/health_check_health_get.py @@ -1,5 +1,5 @@ from http import HTTPStatus -from typing import Any, Optional, Union +from typing import Any import httpx @@ -17,7 +17,7 @@ def _get_kwargs() -> dict[str, Any]: return _kwargs -def _parse_response(*, client: Union[AuthenticatedClient, Client], response: httpx.Response) -> Optional[Any]: +def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Any | None: if response.status_code == 200: return None @@ -27,7 +27,7 @@ def _parse_response(*, client: Union[AuthenticatedClient, Client], response: htt return None -def _build_response(*, client: Union[AuthenticatedClient, Client], response: httpx.Response) -> Response[Any]: +def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[Any]: return Response( status_code=HTTPStatus(response.status_code), content=response.content, @@ -38,7 +38,7 @@ def _build_response(*, client: Union[AuthenticatedClient, Client], response: htt def sync_detailed( *, - client: Union[AuthenticatedClient, Client], + client: AuthenticatedClient | Client, ) -> Response[Any]: """Health check @@ -63,7 +63,7 @@ def sync_detailed( async def asyncio_detailed( *, - client: Union[AuthenticatedClient, Client], + client: AuthenticatedClient | Client, ) -> Response[Any]: """Health check diff --git a/faim_client/client.py b/faim_client/client.py index e80446f..3f312fb 100644 --- a/faim_client/client.py +++ b/faim_client/client.py @@ -1,5 +1,5 @@ import ssl -from typing import Any, Optional, Union +from typing import Any import httpx from attrs import define, evolve, field @@ -38,12 +38,12 @@ class Client: _base_url: str = field(alias="base_url") _cookies: dict[str, str] = field(factory=dict, kw_only=True, alias="cookies") _headers: dict[str, str] = field(factory=dict, kw_only=True, alias="headers") - _timeout: Optional[httpx.Timeout] = field(default=None, kw_only=True, alias="timeout") - _verify_ssl: Union[str, bool, ssl.SSLContext] = field(default=True, kw_only=True, alias="verify_ssl") + _timeout: httpx.Timeout | None = field(default=None, kw_only=True, alias="timeout") + _verify_ssl: str | bool | ssl.SSLContext = field(default=True, kw_only=True, alias="verify_ssl") _follow_redirects: bool = field(default=False, kw_only=True, alias="follow_redirects") _httpx_args: dict[str, Any] = field(factory=dict, kw_only=True, alias="httpx_args") - _client: Optional[httpx.Client] = field(default=None, init=False) - _async_client: Optional[httpx.AsyncClient] = field(default=None, init=False) + _client: httpx.Client | None = field(default=None, init=False) + _async_client: httpx.AsyncClient | None = field(default=None, init=False) def with_headers(self, headers: dict[str, str]) -> "Client": """Get a new client matching this one with additional headers""" @@ -168,12 +168,12 @@ class AuthenticatedClient: _base_url: str = field(alias="base_url") _cookies: dict[str, str] = field(factory=dict, kw_only=True, alias="cookies") _headers: dict[str, str] = field(factory=dict, kw_only=True, alias="headers") - _timeout: Optional[httpx.Timeout] = field(default=None, kw_only=True, alias="timeout") - _verify_ssl: Union[str, bool, ssl.SSLContext] = field(default=True, kw_only=True, alias="verify_ssl") + _timeout: httpx.Timeout | None = field(default=None, kw_only=True, alias="timeout") + _verify_ssl: str | bool | ssl.SSLContext = field(default=True, kw_only=True, alias="verify_ssl") _follow_redirects: bool = field(default=False, kw_only=True, alias="follow_redirects") _httpx_args: dict[str, Any] = field(factory=dict, kw_only=True, alias="httpx_args") - _client: Optional[httpx.Client] = field(default=None, init=False) - _async_client: Optional[httpx.AsyncClient] = field(default=None, init=False) + _client: httpx.Client | None = field(default=None, init=False) + _async_client: httpx.AsyncClient | None = field(default=None, init=False) token: str prefix: str = "Bearer" diff --git a/faim_client/models/error_response.py b/faim_client/models/error_response.py index 79e3b76..070cfb5 100644 --- a/faim_client/models/error_response.py +++ b/faim_client/models/error_response.py @@ -1,5 +1,5 @@ from collections.abc import Mapping -from typing import Any, TypeVar, Union, cast +from typing import Any, TypeVar, cast from attrs import define as _attrs_define from attrs import field as _attrs_field @@ -37,8 +37,8 @@ class ErrorResponse: error_code: ErrorCode message: str - detail: Union[None, Unset, str] = UNSET - request_id: Union[None, Unset, str] = UNSET + detail: None | Unset | str = UNSET + request_id: None | Unset | str = UNSET additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict) def to_dict(self) -> dict[str, Any]: @@ -46,13 +46,13 @@ def to_dict(self) -> dict[str, Any]: message = self.message - detail: Union[None, Unset, str] + detail: None | Unset | str if isinstance(self.detail, Unset): detail = UNSET else: detail = self.detail - request_id: Union[None, Unset, str] + request_id: None | Unset | str if isinstance(self.request_id, Unset): request_id = UNSET else: @@ -80,21 +80,21 @@ def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T: message = d.pop("message") - def _parse_detail(data: object) -> Union[None, Unset, str]: + def _parse_detail(data: object) -> None | Unset | str: if data is None: return data if isinstance(data, Unset): return data - return cast(Union[None, Unset, str], data) + return cast(None | Unset | str, data) detail = _parse_detail(d.pop("detail", UNSET)) - def _parse_request_id(data: object) -> Union[None, Unset, str]: + def _parse_request_id(data: object) -> None | Unset | str: if data is None: return data if isinstance(data, Unset): return data - return cast(Union[None, Unset, str], data) + return cast(None | Unset | str, data) request_id = _parse_request_id(d.pop("request_id", UNSET)) diff --git a/faim_client/models/http_validation_error.py b/faim_client/models/http_validation_error.py index 36bb758..a2c8fa2 100644 --- a/faim_client/models/http_validation_error.py +++ b/faim_client/models/http_validation_error.py @@ -1,5 +1,5 @@ from collections.abc import Mapping -from typing import TYPE_CHECKING, Any, TypeVar, Union +from typing import TYPE_CHECKING, Any, TypeVar from attrs import define as _attrs_define from attrs import field as _attrs_field @@ -20,11 +20,11 @@ class HTTPValidationError: detail (Union[Unset, list['ValidationError']]): """ - detail: Union[Unset, list["ValidationError"]] = UNSET + detail: Unset | list["ValidationError"] = UNSET additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict) def to_dict(self) -> dict[str, Any]: - detail: Union[Unset, list[dict[str, Any]]] = UNSET + detail: Unset | list[dict[str, Any]] = UNSET if not isinstance(self.detail, Unset): detail = [] for detail_item_data in self.detail: diff --git a/faim_client/models/validation_error.py b/faim_client/models/validation_error.py index e298833..1d581e1 100644 --- a/faim_client/models/validation_error.py +++ b/faim_client/models/validation_error.py @@ -1,5 +1,5 @@ from collections.abc import Mapping -from typing import Any, TypeVar, Union, cast +from typing import Any, TypeVar, cast from attrs import define as _attrs_define from attrs import field as _attrs_field @@ -16,7 +16,7 @@ class ValidationError: type_ (str): """ - loc: list[Union[int, str]] + loc: list[int | str] msg: str type_: str additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict) @@ -24,7 +24,7 @@ class ValidationError: def to_dict(self) -> dict[str, Any]: loc = [] for loc_item_data in self.loc: - loc_item: Union[int, str] + loc_item: int | str loc_item = loc_item_data loc.append(loc_item) @@ -51,8 +51,8 @@ def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T: _loc = d.pop("loc") for loc_item_data in _loc: - def _parse_loc_item(data: object) -> Union[int, str]: - return cast(Union[int, str], data) + def _parse_loc_item(data: object) -> int | str: + return cast(int | str, data) loc_item = _parse_loc_item(loc_item_data) diff --git a/faim_client/types.py b/faim_client/types.py index 1b96ca4..67a552b 100644 --- a/faim_client/types.py +++ b/faim_client/types.py @@ -2,7 +2,7 @@ from collections.abc import Mapping, MutableMapping from http import HTTPStatus -from typing import IO, BinaryIO, Generic, Literal, Optional, TypeVar, Union +from typing import IO, BinaryIO, Generic, Literal, TypeVar, Union from attrs import define @@ -18,9 +18,9 @@ def __bool__(self) -> Literal[False]: FileContent = Union[IO[bytes], bytes, str] FileTypes = Union[ # (filename, file (or bytes), content_type) - tuple[Optional[str], FileContent, Optional[str]], + tuple[str | None, FileContent, str | None], # (filename, file (or bytes), content_type, headers) - tuple[Optional[str], FileContent, Optional[str], Mapping[str, str]], + tuple[str | None, FileContent, str | None, Mapping[str, str]], ] RequestFiles = list[tuple[str, FileTypes]] @@ -30,8 +30,8 @@ class File: """Contains information for file uploads""" payload: BinaryIO - file_name: Optional[str] = None - mime_type: Optional[str] = None + file_name: str | None = None + mime_type: str | None = None def to_tuple(self) -> FileTypes: """Return a tuple representation that httpx will accept for multipart/form-data""" @@ -48,7 +48,7 @@ class Response(Generic[T]): status_code: HTTPStatus content: bytes headers: MutableMapping[str, str] - parsed: Optional[T] + parsed: T | None __all__ = ["UNSET", "File", "FileTypes", "RequestFiles", "Response", "Unset"] diff --git a/faim_sdk/__init__.py b/faim_sdk/__init__.py index 6c7920d..cfa2614 100644 --- a/faim_sdk/__init__.py +++ b/faim_sdk/__init__.py @@ -17,7 +17,7 @@ >>> >>> # Initialize client >>> client = ForecastClient( - ... base_url="https://api.example.com", + ... base_url="https://api.faim.it.com", ... api_key="your-api-key" ... ) >>> @@ -142,4 +142,4 @@ "ConfigurationError", ] -__version__ = "0.3.3" +__version__ = "0.4.0" diff --git a/faim_sdk/client.py b/faim_sdk/client.py index f43179c..9fda265 100644 --- a/faim_sdk/client.py +++ b/faim_sdk/client.py @@ -16,7 +16,6 @@ from faim_client import AuthenticatedClient, Client from faim_client.api.forecast import forecast_v1_ts_forecast_model_name_model_version_post from faim_client.models import ModelName -from faim_client.models.error_code import ErrorCode from faim_client.models.error_response import ErrorResponse from faim_client.types import File @@ -219,7 +218,7 @@ class ForecastClient: Example: >>> from faim_sdk import ForecastClient, Chronos2ForecastRequest >>> - >>> client = ForecastClient(base_url="https://api.example.com") + >>> client = ForecastClient(base_url="https://api.faim.it.com") >>> request = Chronos2ForecastRequest( ... x=data, ... horizon=10, diff --git a/faim_sdk/eval/__init__.py b/faim_sdk/eval/__init__.py index 6512f48..fc1bde6 100644 --- a/faim_sdk/eval/__init__.py +++ b/faim_sdk/eval/__init__.py @@ -14,7 +14,7 @@ >>> import numpy as np >>> >>> # Generate forecast - >>> client = ForecastClient(base_url="https://api.example.com") + >>> client = ForecastClient() >>> request = Chronos2ForecastRequest( ... x=train_data, # (32, 100, 1) ... horizon=24, @@ -49,6 +49,7 @@ Available Metrics: - mse: Mean Squared Error (point forecasts) + - mae: Mean Absolute Error (point forecasts) - mase: Mean Absolute Scaled Error (scale-independent) - crps_from_quantiles: Continuous Ranked Probability Score (probabilistic) @@ -63,12 +64,13 @@ pip install matplotlib """ -from .metrics import crps_from_quantiles, mase, mse +from .metrics import crps_from_quantiles, mae, mase, mse from .visualization import plot_forecast __all__ = [ # Metrics "mse", + "mae", "mase", "crps_from_quantiles", # Visualization diff --git a/faim_sdk/eval/metrics.py b/faim_sdk/eval/metrics.py index 9801043..b1b7fdd 100644 --- a/faim_sdk/eval/metrics.py +++ b/faim_sdk/eval/metrics.py @@ -14,7 +14,7 @@ >>> import numpy as np >>> >>> # Generate forecast - >>> client = ForecastClient(base_url="https://api.example.com") + >>> client = ForecastClient() >>> request = Chronos2ForecastRequest( ... x=train_data, # shape: (32, 100, 1) ... horizon=24, @@ -151,6 +151,99 @@ def mse( raise ValueError(f"reduction must be 'mean' or 'none', got '{reduction}'") +def mae( + y_true: np.ndarray, + y_pred: np.ndarray, + reduction: ReductionType = "mean", +) -> float | np.ndarray: + """Calculate Mean Absolute Error between true and predicted values. + + MAE measures the average absolute difference between predictions and ground truth. + Lower values indicate better forecast accuracy. Unlike MSE, MAE is less sensitive + to outliers and maintains the same units as the original data. + + Mathematical Formula: + MAE = (1/n) * Σ|y_true - y_pred| + + where n is the total number of predictions (batch_size × horizon × features). + + Args: + y_true: Ground truth values. Shape: (batch_size, horizon, features). + y_pred: Predicted values. Shape: (batch_size, horizon, features). + reduction: How to aggregate results across the batch dimension. + - 'mean': Return single scalar averaged across all dimensions (default) + - 'none': Return per-sample metrics with shape (batch_size,) + + Returns: + MAE value(s). Returns float if reduction='mean', otherwise array of shape + (batch_size,) containing MAE for each sample in the batch. + + Raises: + TypeError: If inputs are not numpy arrays. + ValueError: If inputs have different shapes, wrong number of dimensions, + or are empty. + + Examples: + >>> import numpy as np + >>> from faim_sdk.eval import mae + >>> + >>> # Single feature, batch of 4 samples + >>> y_true = np.array([[[1.0], [2.0], [3.0]], + ... [[4.0], [5.0], [6.0]]]) # (2, 3, 1) + >>> y_pred = np.array([[[1.1], [2.1], [3.1]], + ... [[4.2], [5.2], [6.2]]]) # (2, 3, 1) + >>> + >>> # Overall MAE + >>> mae(y_true, y_pred, reduction='mean') + 0.15 + >>> + >>> # Per-sample MAE + >>> mae(y_true, y_pred, reduction='none') + array([0.1, 0.2]) + + Notes: + - MAE is less sensitive to outliers compared to MSE + - MAE has the same units as the original data + - MAE is always non-negative (0 = perfect forecast) + - For scale-independent evaluation, consider using MASE instead + """ + # Type validation + if not isinstance(y_true, np.ndarray): + raise TypeError(f"y_true must be numpy.ndarray, got {type(y_true).__name__}") + if not isinstance(y_pred, np.ndarray): + raise TypeError(f"y_pred must be numpy.ndarray, got {type(y_pred).__name__}") + + # Shape validation + if y_true.ndim != 3: + raise ValueError( + f"y_true must be 3-dimensional (batch_size, horizon, features), got shape {y_true.shape}" + ) + if y_pred.ndim != 3: + raise ValueError( + f"y_pred must be 3-dimensional (batch_size, horizon, features), got shape {y_pred.shape}" + ) + if y_true.shape != y_pred.shape: + raise ValueError( + f"y_true and y_pred must have the same shape, got {y_true.shape} and {y_pred.shape}" + ) + + # Empty validation + if y_true.size == 0: + raise ValueError("y_true cannot be empty") + + # Calculate absolute errors + absolute_errors = np.abs(y_true - y_pred) + + # Apply reduction + if reduction == "mean": + return float(np.mean(absolute_errors)) + elif reduction == "none": + # Average over horizon and features, keep batch dimension + return np.mean(absolute_errors, axis=(1, 2)) + else: + raise ValueError(f"reduction must be 'mean' or 'none', got '{reduction}'") + + def mase( y_true: np.ndarray, y_pred: np.ndarray, diff --git a/faim_sdk/eval/visualization.py b/faim_sdk/eval/visualization.py index cd2f01a..867e07e 100644 --- a/faim_sdk/eval/visualization.py +++ b/faim_sdk/eval/visualization.py @@ -13,7 +13,7 @@ >>> import numpy as np >>> >>> # Generate forecast - >>> client = ForecastClient(base_url="https://api.example.com") + >>> client = ForecastClient() >>> request = Chronos2ForecastRequest( ... x=train_data, # shape: (32, 100, 1) ... horizon=24, @@ -34,15 +34,15 @@ - plot_forecast: Plot training data, forecast, and optional test data """ -from typing import Sequence +from collections.abc import Sequence import numpy as np # matplotlib is an optional dependency try: import matplotlib.pyplot as plt - from matplotlib.figure import Figure from matplotlib.axes import Axes + from matplotlib.figure import Figure MATPLOTLIB_AVAILABLE = True except ImportError: @@ -143,7 +143,7 @@ def plot_forecast( >>> from faim_sdk import ForecastClient, Chronos2ForecastRequest >>> from faim_client.models import ModelName >>> - >>> client = ForecastClient(base_url="https://api.example.com") + >>> client = ForecastClient() >>> request = Chronos2ForecastRequest( ... x=train_batch, # (32, 100, 1) ... horizon=24, diff --git a/faim_sdk/models.py b/faim_sdk/models.py index 2b734b5..2773606 100644 --- a/faim_sdk/models.py +++ b/faim_sdk/models.py @@ -226,6 +226,10 @@ def __post_init__(self) -> None: raise ValueError( f"prediction_type='{self.prediction_type}' requires output_type='point', got '{self.output_type}'" ) + elif self.output_type == "quantiles": + self.prediction_type = "quantile" + else: + self.prediction_type = "median" # Validate output_type requires corresponding prediction_type if self.output_type == "quantiles" and self.prediction_type != "quantile": diff --git a/pyproject.toml b/pyproject.toml index b21ab73..b6bb9f7 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [tool.poetry] name = "faim-sdk" -version = "0.3.3" +version = "0.4.0" description = "Python SDK for FAIM time-series forecasting with foundation AI models" authors = ["FAIM "] license = "Apache-2.0" @@ -17,10 +17,8 @@ numpy = ">=1.26.0,<2.0.0" pyarrow = ">=18.1.0" httpx = ">=0.23.0,<0.29.0" attrs = ">=22.2.0" -matplotlib = {version = ">=3.5.0", optional = true} +matplotlib = ">=3.5.0" -[tool.poetry.extras] -viz = ["matplotlib"] [build-system] requires = ["poetry-core>=2.0.0,<3.0.0"] @@ -29,13 +27,14 @@ build-backend = "poetry.core.masonry.api" [tool.poetry.group.dev.dependencies] jupyterlab = ">=4.4.10" pandas = ">=2.3.3" -statsmodels = ">=0.14.5" pytest = ">=8.0.0" pytest-asyncio = ">=0.23.0" pytest-cov = ">=4.1.0" +ruff = ">=0.8.0" [tool.ruff] line-length = 120 +extend-exclude = ["faim_client/"] [tool.ruff.lint] select = ["F", "I", "UP"] diff --git a/tests/unit/test_client.py b/tests/unit/test_client.py index 0e2d9ea..b245bac 100644 --- a/tests/unit/test_client.py +++ b/tests/unit/test_client.py @@ -3,13 +3,12 @@ Tests ForecastClient initialization, sync/async methods, and error handling. """ -from unittest.mock import MagicMock, Mock, patch +from unittest.mock import Mock, patch import httpx import numpy as np import pytest -from faim_client.models import ModelName from faim_client.models.error_code import ErrorCode from faim_client.models.error_response import ErrorResponse from faim_sdk.client import ForecastClient @@ -36,20 +35,19 @@ class TestForecastClientInitialization: def test_initialization_minimal(self): """Test initialization with minimal parameters.""" - client = ForecastClient(base_url="https://api.example.com") + client = ForecastClient() - assert client.base_url == "https://api.example.com" + assert client.base_url == "https://api.faim.it.com" assert client.timeout == 120.0 assert client._client is not None def test_initialization_with_api_key(self): """Test initialization with API key.""" client = ForecastClient( - base_url="https://api.example.com", api_key="test-key-123", ) - assert client.base_url == "https://api.example.com" + assert client.base_url == "https://api.faim.it.com" def test_initialization_with_timeout(self): """Test initialization with custom timeout.""" @@ -510,7 +508,7 @@ async def test_aclose_method(self): def test_context_manager_closes_client(self): """Test that context manager closes client on exit.""" - with ForecastClient(base_url="https://api.example.com") as client: + with ForecastClient(base_url="https://api.example.com"): pass # Client should be closed after context exits @@ -519,7 +517,7 @@ def test_context_manager_closes_client(self): @pytest.mark.asyncio async def test_async_context_manager_closes_client(self): """Test that async context manager closes client on exit.""" - async with ForecastClient(base_url="https://api.example.com") as client: + async with ForecastClient(base_url="https://api.example.com"): pass # Client should be closed after context exits @@ -792,8 +790,6 @@ def test_2d_input_raises_error(self): # Setup: 2D input (10, 3) - not allowed data = np.random.rand(10, 3).astype(np.float32) - client = ForecastClient(base_url="https://api.example.com") - # Should raise error during request validation with pytest.raises(ValueError, match="x must be a 3D array"): FlowStateForecastRequest(x=data, horizon=5, prediction_type="mean") diff --git a/tests/unit/test_eval_metrics.py b/tests/unit/test_eval_metrics.py index b79a6d6..d015dc0 100644 --- a/tests/unit/test_eval_metrics.py +++ b/tests/unit/test_eval_metrics.py @@ -323,7 +323,6 @@ def test_crps_batch_processing(self): def test_crps_shape_mismatch_error(self): """Test CRPS raises error for mismatched shapes.""" y_true = np.array([[[5.0]]]) - quantile_preds = np.array([[[4.0, 5.0]]]) # Wrong horizon quantile_levels = [0.1, 0.5] with pytest.raises(ValueError, match="Batch size mismatch"): diff --git a/tests/unit/test_eval_visualization.py b/tests/unit/test_eval_visualization.py index 53a5d1c..4ab6374 100644 --- a/tests/unit/test_eval_visualization.py +++ b/tests/unit/test_eval_visualization.py @@ -316,6 +316,7 @@ def mock_import(name, *args, **kwargs): # Force reload of visualization module import importlib + import faim_sdk.eval importlib.reload(faim_sdk.eval.visualization) @@ -362,7 +363,6 @@ def test_plot_forecast_vertical_line_at_boundary(self): fig, ax = plot_forecast(train_data, forecast) # Check for vertical lines (boundary marker) - vertical_lines = [line for line in ax.lines if line.get_linestyle() == '-'] # Should have at least one vertical line for the boundary # (Plus the actual data lines) assert len(ax.lines) >= 2 diff --git a/tests/unit/test_exceptions.py b/tests/unit/test_exceptions.py index 0b20510..32f6d61 100644 --- a/tests/unit/test_exceptions.py +++ b/tests/unit/test_exceptions.py @@ -430,7 +430,7 @@ def test_with_details(self): "Connection failed", details={"host": "api.example.com", "port": 443}, ) - assert error.details["host"] == "api.example.com" + assert error.details["host"] == "https://api.faim.it.com" class TestTimeoutError: From 44ff48c1fc409989b398d270480e1c4ba4a2bbfa Mon Sep 17 00:00:00 2001 From: Andrei Chernov Date: Wed, 5 Nov 2025 19:01:41 +0100 Subject: [PATCH 08/10] updated notebok --- examples/model_comparison_simple.ipynb | 177 ++++++++++++++++++------- 1 file changed, 129 insertions(+), 48 deletions(-) diff --git a/examples/model_comparison_simple.ipynb b/examples/model_comparison_simple.ipynb index c02e07b..5376193 100644 --- a/examples/model_comparison_simple.ipynb +++ b/examples/model_comparison_simple.ipynb @@ -10,32 +10,40 @@ ] }, { + "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2025-11-05T17:50:00.017080Z", - "start_time": "2025-11-05T17:50:00.011339Z" + "end_time": "2025-11-05T18:01:16.424417Z", + "start_time": "2025-11-05T18:01:16.421605Z" } }, - "cell_type": "code", "source": [ "import os\n", + "\n", "# provide FAIM API KEY here\n", "FAIM_API_KEY = os.environ['FAIM_API_KEY']" ], "outputs": [], - "execution_count": 24 + "execution_count": 1 }, { "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2025-11-05T17:50:00.034908Z", - "start_time": "2025-11-05T17:50:00.031883Z" + "end_time": "2025-11-05T18:01:17.160610Z", + "start_time": "2025-11-05T18:01:16.575528Z" } }, - "source": "import matplotlib.pyplot as plt\nimport numpy as np\nfrom generate_data import generate_linear_trend_series\n\nfrom faim_sdk import Chronos2ForecastRequest, FlowStateForecastRequest, ForecastClient, TiRexForecastRequest\nfrom faim_sdk.eval import crps_from_quantiles, mae, mse", + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from generate_data import generate_linear_trend_series\n", + "\n", + "from faim_sdk import Chronos2ForecastRequest, FlowStateForecastRequest, ForecastClient, TiRexForecastRequest\n", + "from faim_sdk.eval import mae, mse" + ], "outputs": [], - "execution_count": 25 + "execution_count": 2 }, { "cell_type": "markdown", @@ -46,8 +54,8 @@ "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2025-11-05T17:50:00.090111Z", - "start_time": "2025-11-05T17:50:00.086690Z" + "end_time": "2025-11-05T18:01:17.175867Z", + "start_time": "2025-11-05T18:01:17.171578Z" } }, "source": [ @@ -73,7 +81,7 @@ ] } ], - "execution_count": 26 + "execution_count": 3 }, { "cell_type": "markdown", @@ -86,8 +94,8 @@ "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2025-11-05T17:50:03.098380Z", - "start_time": "2025-11-05T17:50:00.121843Z" + "end_time": "2025-11-05T18:01:20.572932Z", + "start_time": "2025-11-05T18:01:17.194514Z" } }, "source": [ @@ -115,7 +123,7 @@ ] } ], - "execution_count": 27 + "execution_count": 4 }, { "cell_type": "markdown", @@ -128,11 +136,25 @@ "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2025-11-05T17:50:03.136415Z", - "start_time": "2025-11-05T17:50:03.133247Z" + "end_time": "2025-11-05T18:01:20.602274Z", + "start_time": "2025-11-05T18:01:20.599145Z" } }, - "source": "# Calculate metrics for each model\nmodels = {\n \"FlowState\": flowstate_response.point,\n \"Chronos2\": chronos2_response.point,\n \"TiRex\": tirex_response.point\n}\n\nprint(\"Point Forecast Metrics:\")\nprint(\"-\" * 50)\nfor name, pred in models.items():\n mse_score = mse(test_data, pred)\n mae_score = mae(test_data, pred)\n print(f\"{name:12s} - MSE: {mse_score:.4f}, MAE: {mae_score:.4f}\")", + "source": [ + "# Calculate metrics for each model\n", + "models = {\n", + " \"FlowState\": flowstate_response.point,\n", + " \"Chronos2\": chronos2_response.point,\n", + " \"TiRex\": tirex_response.point\n", + "}\n", + "\n", + "print(\"Point Forecast Metrics:\")\n", + "print(\"-\" * 50)\n", + "for name, pred in models.items():\n", + " mse_score = mse(test_data, pred)\n", + " mae_score = mae(test_data, pred)\n", + " print(f\"{name:12s} - MSE: {mse_score:.4f}, MAE: {mae_score:.4f}\")" + ], "outputs": [ { "name": "stdout", @@ -146,7 +168,7 @@ ] } ], - "execution_count": 28 + "execution_count": 5 }, { "cell_type": "markdown", @@ -159,11 +181,37 @@ "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2025-11-05T17:50:03.269751Z", - "start_time": "2025-11-05T17:50:03.180507Z" + "end_time": "2025-11-05T18:01:20.728973Z", + "start_time": "2025-11-05T18:01:20.626677Z" } }, - "source": "# Plot all forecasts together\nfig, ax = plt.subplots(figsize=(12, 6))\n\n# Plot only last 'horizon' points of training data\ntrain_context_start = max(0, train_size - horizon)\ntrain_context_indices = np.arange(train_context_start, train_size)\nax.plot(train_context_indices, train_data[0, train_context_start:, 0], label=\"Training Data\", color=\"blue\", linewidth=2)\n\n# Plot test data\ntest_indices = np.arange(train_size, train_size + horizon)\nax.plot(test_indices, test_data[0, :, 0], label=\"Test Data\", color=\"black\", linewidth=2, linestyle=\"--\")\n\n# Plot forecasts\ncolors = {\"FlowState\": \"green\", \"Chronos2\": \"red\", \"TiRex\": \"orange\"}\nfor name, pred in models.items():\n ax.plot(test_indices, pred[0, :, 0], label=f\"{name} Forecast\", color=colors[name], linewidth=1.5, alpha=0.8)\n\nax.axvline(x=train_size, color=\"gray\", linestyle=\":\", linewidth=1, alpha=0.7)\nax.set_xlabel(\"Time\")\nax.set_ylabel(\"Value\")\nax.set_title(\"Point Forecast Comparison\")\nax.legend(loc=\"best\")\nax.grid(True, alpha=0.3)\nplt.tight_layout()\nplt.show()", + "source": [ + "# Plot all forecasts together\n", + "fig, ax = plt.subplots(figsize=(12, 6))\n", + "\n", + "# Plot only last 'horizon' points of training data\n", + "train_context_start = max(0, train_size - horizon)\n", + "train_context_indices = np.arange(train_context_start, train_size)\n", + "ax.plot(train_context_indices, train_data[0, train_context_start:, 0], label=\"Training Data\", color=\"blue\", linewidth=2)\n", + "\n", + "# Plot test data\n", + "test_indices = np.arange(train_size, train_size + horizon)\n", + "ax.plot(test_indices, test_data[0, :, 0], label=\"Test Data\", color=\"black\", linewidth=2, linestyle=\"--\")\n", + "\n", + "# Plot forecasts\n", + "colors = {\"FlowState\": \"green\", \"Chronos2\": \"red\", \"TiRex\": \"orange\"}\n", + "for name, pred in models.items():\n", + " ax.plot(test_indices, pred[0, :, 0], label=f\"{name} Forecast\", color=colors[name], linewidth=1.5, alpha=0.8)\n", + "\n", + "ax.axvline(x=train_size, color=\"gray\", linestyle=\":\", linewidth=1, alpha=0.7)\n", + "ax.set_xlabel(\"Time\")\n", + "ax.set_ylabel(\"Value\")\n", + "ax.set_title(\"Point Forecast Comparison\")\n", + "ax.legend(loc=\"best\")\n", + "ax.grid(True, alpha=0.3)\n", + "plt.tight_layout()\n", + "plt.show()" + ], "outputs": [ { "data": { @@ -176,7 +224,7 @@ "output_type": "display_data" } ], - "execution_count": 29 + "execution_count": 6 }, { "cell_type": "markdown", @@ -187,29 +235,11 @@ "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2025-11-05T17:50:06.070629Z", - "start_time": "2025-11-05T17:50:03.297232Z" + "end_time": "2025-11-05T18:01:23.556084Z", + "start_time": "2025-11-05T18:01:20.748416Z" } }, - "source": [ - "# Generate quantile forecasts from all three models\n", - "quantile_levels = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]\n", - "\n", - "flowstate_q_request = FlowStateForecastRequest(\n", - " x=train_data, horizon=horizon, prediction_type=\"quantile\", output_type=\"quantiles\"\n", - ")\n", - "flowstate_q_response = client.forecast(flowstate_q_request)\n", - "\n", - "chronos2_q_request = Chronos2ForecastRequest(\n", - " x=train_data, horizon=horizon, output_type=\"quantiles\", quantiles=quantile_levels\n", - ")\n", - "chronos2_q_response = client.forecast(chronos2_q_request)\n", - "\n", - "tirex_q_request = TiRexForecastRequest(x=train_data, horizon=horizon, output_type=\"quantiles\")\n", - "tirex_q_response = client.forecast(tirex_q_request)\n", - "\n", - "print(\"Quantile forecasts generated successfully\")" - ], + "source": "# Generate quantile forecasts from all three models\nquantile_levels = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]\n\nflowstate_q_request = FlowStateForecastRequest(\n x=train_data, horizon=horizon, prediction_type=\"quantile\", output_type=\"quantiles\"\n)\nflowstate_q_response = client.forecast(flowstate_q_request)\n\nchronos2_q_request = Chronos2ForecastRequest(\n x=train_data, horizon=horizon, output_type=\"quantiles\", quantiles=quantile_levels\n)\nchronos2_q_response = client.forecast(chronos2_q_request)\n\ntirex_q_request = TiRexForecastRequest(x=train_data, horizon=horizon, output_type=\"quantiles\")\ntirex_q_response = client.forecast(tirex_q_request)\n\n# Create dictionary of quantile models for visualization\nquantile_models = {\n \"FlowState\": flowstate_q_response.quantiles,\n \"Chronos2\": chronos2_q_response.quantiles,\n \"TiRex\": tirex_q_response.quantiles\n}\n\nprint(\"Quantile forecasts generated successfully\")", "outputs": [ { "name": "stdout", @@ -219,7 +249,7 @@ ] } ], - "execution_count": 30 + "execution_count": 7 }, { "cell_type": "markdown", @@ -232,11 +262,62 @@ "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2025-11-05T17:50:06.293765Z", - "start_time": "2025-11-05T17:50:06.084541Z" + "end_time": "2025-11-05T18:01:23.853901Z", + "start_time": "2025-11-05T18:01:23.589279Z" } }, - "source": "# Plot quantile forecasts for all models\nfig, axes = plt.subplots(3, 1, figsize=(12, 12))\n\n# Plot only last 'horizon' points of training data\ntrain_context_start = max(0, train_size - horizon)\ntrain_context_indices = np.arange(train_context_start, train_size)\n\nfor idx, (name, quantiles) in enumerate(quantile_models.items()):\n ax = axes[idx]\n \n # Plot training data (last horizon points)\n ax.plot(train_context_indices, train_data[0, train_context_start:, 0], label=\"Training Data\", color=\"blue\", linewidth=2)\n \n # Plot test data\n ax.plot(test_indices, test_data[0, :, 0], label=\"Test Data\", color=\"black\", linewidth=2, linestyle=\"--\")\n \n # Plot median (index 2 for 0.5 quantile)\n median_idx = 2\n ax.plot(test_indices, quantiles[0, :, median_idx, 0], label=\"Median Forecast\", color=colors[name], linewidth=2)\n \n # Plot prediction intervals\n # 80% interval (0.1 to 0.9)\n ax.fill_between(\n test_indices,\n quantiles[0, :, 0, 0], # 0.1 quantile\n quantiles[0, :, 4, 0], # 0.9 quantile\n alpha=0.2,\n color=colors[name],\n label=\"80% Interval\"\n )\n \n # 50% interval (0.25 to 0.75)\n ax.fill_between(\n test_indices,\n quantiles[0, :, 1, 0], # 0.25 quantile\n quantiles[0, :, 3, 0], # 0.75 quantile\n alpha=0.3,\n color=colors[name],\n label=\"50% Interval\"\n )\n \n ax.axvline(x=train_size, color=\"gray\", linestyle=\":\", linewidth=1, alpha=0.7)\n ax.set_xlabel(\"Time\")\n ax.set_ylabel(\"Value\")\n ax.set_title(f\"{name} Quantile Forecast\")\n ax.legend(loc=\"best\")\n ax.grid(True, alpha=0.3)\n\nplt.tight_layout()\nplt.show()", + "source": [ + "# Plot quantile forecasts for all models\n", + "fig, axes = plt.subplots(3, 1, figsize=(12, 12))\n", + "\n", + "# Plot only last 'horizon' points of training data\n", + "train_context_start = max(0, train_size - horizon)\n", + "train_context_indices = np.arange(train_context_start, train_size)\n", + "\n", + "for idx, (name, quantiles) in enumerate(quantile_models.items()):\n", + " ax = axes[idx]\n", + " \n", + " # Plot training data (last horizon points)\n", + " ax.plot(train_context_indices, train_data[0, train_context_start:, 0], label=\"Training Data\", color=\"blue\", linewidth=2)\n", + " \n", + " # Plot test data\n", + " ax.plot(test_indices, test_data[0, :, 0], label=\"Test Data\", color=\"black\", linewidth=2, linestyle=\"--\")\n", + " \n", + " # Plot median (index 2 for 0.5 quantile)\n", + " median_idx = 2\n", + " ax.plot(test_indices, quantiles[0, :, median_idx, 0], label=\"Median Forecast\", color=colors[name], linewidth=2)\n", + " \n", + " # Plot prediction intervals\n", + " # 80% interval (0.1 to 0.9)\n", + " ax.fill_between(\n", + " test_indices,\n", + " quantiles[0, :, 0, 0], # 0.1 quantile\n", + " quantiles[0, :, 4, 0], # 0.9 quantile\n", + " alpha=0.2,\n", + " color=colors[name],\n", + " label=\"80% Interval\"\n", + " )\n", + " \n", + " # 50% interval (0.25 to 0.75)\n", + " ax.fill_between(\n", + " test_indices,\n", + " quantiles[0, :, 1, 0], # 0.25 quantile\n", + " quantiles[0, :, 3, 0], # 0.75 quantile\n", + " alpha=0.3,\n", + " color=colors[name],\n", + " label=\"50% Interval\"\n", + " )\n", + " \n", + " ax.axvline(x=train_size, color=\"gray\", linestyle=\":\", linewidth=1, alpha=0.7)\n", + " ax.set_xlabel(\"Time\")\n", + " ax.set_ylabel(\"Value\")\n", + " ax.set_title(f\"{name} Quantile Forecast\")\n", + " ax.legend(loc=\"best\")\n", + " ax.grid(True, alpha=0.3)\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ], "outputs": [ { "data": { @@ -249,7 +330,7 @@ "output_type": "display_data" } ], - "execution_count": 31 + "execution_count": 8 }, { "cell_type": "markdown", From 35b5a57361388f4d26f4dc00e6f3b3c73061e0ef Mon Sep 17 00:00:00 2001 From: Andrei Chernov Date: Wed, 5 Nov 2025 19:05:16 +0100 Subject: [PATCH 09/10] updated lint --- .github/workflows/lint.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml index 7c7e57b..77a4d77 100644 --- a/.github/workflows/lint.yml +++ b/.github/workflows/lint.yml @@ -23,10 +23,10 @@ jobs: run: pip install ruff - name: Run Ruff linter - run: ruff check faim_sdk/ faim_client/ tests/ + run: ruff check . - name: Run Ruff formatter check - run: ruff format --check faim_sdk/ faim_client/ tests/ + run: ruff format --check . type-check: name: Type Checking (mypy) From cdf6fd18a610b3624a52b2913fc08806ea22e13a Mon Sep 17 00:00:00 2001 From: Andrei Chernov Date: Wed, 5 Nov 2025 19:06:29 +0100 Subject: [PATCH 10/10] fix format --- examples/generate_data.py | 40 ++--- examples/model_comparison_simple.ipynb | 199 ++++++++++++++----------- faim_sdk/client.py | 15 +- faim_sdk/eval/__init__.py | 2 +- faim_sdk/eval/metrics.py | 67 +++------ faim_sdk/eval/visualization.py | 15 +- faim_sdk/models.py | 10 +- tests/unit/test_client.py | 7 +- tests/unit/test_eval_metrics.py | 61 ++++---- tests/unit/test_eval_visualization.py | 36 ++--- 10 files changed, 194 insertions(+), 258 deletions(-) diff --git a/examples/generate_data.py b/examples/generate_data.py index 2928e6e..0cf3697 100644 --- a/examples/generate_data.py +++ b/examples/generate_data.py @@ -5,7 +5,6 @@ for testing and demonstrating forecasting capabilities. """ - import numpy as np @@ -14,7 +13,7 @@ def generate_linear_trend_series( context_length: int = 256, trend_slope: float = 0.05, noise_std: float = 0.5, - seed: int | None = None + seed: int | None = None, ) -> np.ndarray: """ Generate simple time series with linear trend and Gaussian noise. @@ -59,7 +58,7 @@ def generate_correlated_multi_series( seasonal_amplitude: float = 2.0, trend_slope: float = 0.02, noise_std: float = 0.3, - seed: int | None = None + seed: int | None = None, ) -> np.ndarray: """ Generate two correlated time series with seasonal patterns. @@ -105,10 +104,7 @@ def generate_correlated_multi_series( noise2 = np.random.normal(0, noise_std, size=(batch_size, context_length)) # Mix correlated and independent components - series2 = ( - correlation * series1 + - (1 - correlation) * (independent_base[np.newaxis, :] + noise2) - ) + series2 = correlation * series1 + (1 - correlation) * (independent_base[np.newaxis, :] + noise2) # Stack into (batch_size, context_length, 2) multi_series = np.stack([series1, series2], axis=-1) @@ -122,7 +118,7 @@ def generate_heavy_payload( num_features: int = 1, pattern_type: str = "mixed", noise_std: float = 0.4, - seed: int | None = None + seed: int | None = None, ) -> np.ndarray: """ Generate large batch of time series for stress testing and performance evaluation. @@ -208,31 +204,17 @@ def generate_test_suite(seed: int = 42) -> dict[str, np.ndarray]: """ return { # Simple patterns - "linear_trend_single": generate_linear_trend_series( - batch_size=1, context_length=256, seed=seed - ), - "linear_trend_batch": generate_linear_trend_series( - batch_size=16, context_length=256, seed=seed - ), - + "linear_trend_single": generate_linear_trend_series(batch_size=1, context_length=256, seed=seed), + "linear_trend_batch": generate_linear_trend_series(batch_size=16, context_length=256, seed=seed), # Correlated multi-series - "correlated_multi_single": generate_correlated_multi_series( - batch_size=1, context_length=256, seed=seed - ), - "correlated_multi_batch": generate_correlated_multi_series( - batch_size=16, context_length=256, seed=seed - ), - + "correlated_multi_single": generate_correlated_multi_series(batch_size=1, context_length=256, seed=seed), + "correlated_multi_batch": generate_correlated_multi_series(batch_size=16, context_length=256, seed=seed), # Heavy payloads - "heavy_mixed": generate_heavy_payload( - batch_size=100, context_length=2048, pattern_type="mixed", seed=seed - ), + "heavy_mixed": generate_heavy_payload(batch_size=100, context_length=2048, pattern_type="mixed", seed=seed), "heavy_seasonal": generate_heavy_payload( batch_size=100, context_length=2048, pattern_type="seasonal", seed=seed ), - "heavy_trend": generate_heavy_payload( - batch_size=100, context_length=2048, pattern_type="trend", seed=seed - ), + "heavy_trend": generate_heavy_payload(batch_size=100, context_length=2048, pattern_type="trend", seed=seed), } @@ -265,4 +247,4 @@ def generate_test_suite(seed: int = 42) -> dict[str, np.ndarray]: test_suite = generate_test_suite(seed=42) print(f"Generated {len(test_suite)} datasets:") for name, data in test_suite.items(): - print(f" {name}: {data.shape}") \ No newline at end of file + print(f" {name}: {data.shape}") diff --git a/examples/model_comparison_simple.ipynb b/examples/model_comparison_simple.ipynb index 5376193..d489828 100644 --- a/examples/model_comparison_simple.ipynb +++ b/examples/model_comparison_simple.ipynb @@ -11,29 +11,31 @@ }, { "cell_type": "code", + "execution_count": 1, "metadata": { "ExecuteTime": { "end_time": "2025-11-05T18:01:16.424417Z", "start_time": "2025-11-05T18:01:16.421605Z" } }, + "outputs": [], "source": [ "import os\n", "\n", "# provide FAIM API KEY here\n", - "FAIM_API_KEY = os.environ['FAIM_API_KEY']" - ], - "outputs": [], - "execution_count": 1 + "FAIM_API_KEY = os.environ[\"FAIM_API_KEY\"]" + ] }, { "cell_type": "code", + "execution_count": 2, "metadata": { "ExecuteTime": { "end_time": "2025-11-05T18:01:17.160610Z", "start_time": "2025-11-05T18:01:16.575528Z" } }, + "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "import numpy as np\n", @@ -41,9 +43,7 @@ "\n", "from faim_sdk import Chronos2ForecastRequest, FlowStateForecastRequest, ForecastClient, TiRexForecastRequest\n", "from faim_sdk.eval import mae, mse" - ], - "outputs": [], - "execution_count": 2 + ] }, { "cell_type": "markdown", @@ -52,25 +52,13 @@ }, { "cell_type": "code", + "execution_count": 3, "metadata": { "ExecuteTime": { "end_time": "2025-11-05T18:01:17.175867Z", "start_time": "2025-11-05T18:01:17.171578Z" } }, - "source": [ - "# Generate synthetic data with linear trend and split into train/test\n", - "total_size = 550\n", - "train_size = 500\n", - "horizon = total_size - train_size\n", - "full_data = generate_linear_trend_series(batch_size=1, context_length=total_size, trend_slope=1.0, noise_std=1.0, seed=42)\n", - "\n", - "train_data = full_data[:, :train_size, :]\n", - "test_data = full_data[:, train_size:train_size+horizon, :]\n", - "\n", - "print(f\"Train data shape: {train_data.shape}\")\n", - "print(f\"Test data shape: {test_data.shape}\")" - ], "outputs": [ { "name": "stdout", @@ -81,7 +69,21 @@ ] } ], - "execution_count": 3 + "source": [ + "# Generate synthetic data with linear trend and split into train/test\n", + "total_size = 550\n", + "train_size = 500\n", + "horizon = total_size - train_size\n", + "full_data = generate_linear_trend_series(\n", + " batch_size=1, context_length=total_size, trend_slope=1.0, noise_std=1.0, seed=42\n", + ")\n", + "\n", + "train_data = full_data[:, :train_size, :]\n", + "test_data = full_data[:, train_size : train_size + horizon, :]\n", + "\n", + "print(f\"Train data shape: {train_data.shape}\")\n", + "print(f\"Test data shape: {test_data.shape}\")" + ] }, { "cell_type": "markdown", @@ -92,12 +94,22 @@ }, { "cell_type": "code", + "execution_count": 4, "metadata": { "ExecuteTime": { "end_time": "2025-11-05T18:01:20.572932Z", "start_time": "2025-11-05T18:01:17.194514Z" } }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Point forecasts generated successfully\n" + ] + } + ], "source": [ "# Initialize client\n", "client = ForecastClient(api_key=FAIM_API_KEY)\n", @@ -113,17 +125,7 @@ "tirex_response = client.forecast(tirex_request)\n", "\n", "print(\"Point forecasts generated successfully\")" - ], - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Point forecasts generated successfully\n" - ] - } - ], - "execution_count": 4 + ] }, { "cell_type": "markdown", @@ -134,27 +136,13 @@ }, { "cell_type": "code", + "execution_count": 5, "metadata": { "ExecuteTime": { "end_time": "2025-11-05T18:01:20.602274Z", "start_time": "2025-11-05T18:01:20.599145Z" } }, - "source": [ - "# Calculate metrics for each model\n", - "models = {\n", - " \"FlowState\": flowstate_response.point,\n", - " \"Chronos2\": chronos2_response.point,\n", - " \"TiRex\": tirex_response.point\n", - "}\n", - "\n", - "print(\"Point Forecast Metrics:\")\n", - "print(\"-\" * 50)\n", - "for name, pred in models.items():\n", - " mse_score = mse(test_data, pred)\n", - " mae_score = mae(test_data, pred)\n", - " print(f\"{name:12s} - MSE: {mse_score:.4f}, MAE: {mae_score:.4f}\")" - ], "outputs": [ { "name": "stdout", @@ -168,7 +156,17 @@ ] } ], - "execution_count": 5 + "source": [ + "# Calculate metrics for each model\n", + "models = {\"FlowState\": flowstate_response.point, \"Chronos2\": chronos2_response.point, \"TiRex\": tirex_response.point}\n", + "\n", + "print(\"Point Forecast Metrics:\")\n", + "print(\"-\" * 50)\n", + "for name, pred in models.items():\n", + " mse_score = mse(test_data, pred)\n", + " mae_score = mae(test_data, pred)\n", + " print(f\"{name:12s} - MSE: {mse_score:.4f}, MAE: {mae_score:.4f}\")" + ] }, { "cell_type": "markdown", @@ -179,12 +177,25 @@ }, { "cell_type": "code", + "execution_count": 6, "metadata": { "ExecuteTime": { "end_time": "2025-11-05T18:01:20.728973Z", "start_time": "2025-11-05T18:01:20.626677Z" } }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Plot all forecasts together\n", "fig, ax = plt.subplots(figsize=(12, 6))\n", @@ -211,20 +222,7 @@ "ax.grid(True, alpha=0.3)\n", "plt.tight_layout()\n", "plt.show()" - ], - "outputs": [ - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "execution_count": 6 + ] }, { "cell_type": "markdown", @@ -233,13 +231,13 @@ }, { "cell_type": "code", + "execution_count": 7, "metadata": { "ExecuteTime": { "end_time": "2025-11-05T18:01:23.556084Z", "start_time": "2025-11-05T18:01:20.748416Z" } }, - "source": "# Generate quantile forecasts from all three models\nquantile_levels = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]\n\nflowstate_q_request = FlowStateForecastRequest(\n x=train_data, horizon=horizon, prediction_type=\"quantile\", output_type=\"quantiles\"\n)\nflowstate_q_response = client.forecast(flowstate_q_request)\n\nchronos2_q_request = Chronos2ForecastRequest(\n x=train_data, horizon=horizon, output_type=\"quantiles\", quantiles=quantile_levels\n)\nchronos2_q_response = client.forecast(chronos2_q_request)\n\ntirex_q_request = TiRexForecastRequest(x=train_data, horizon=horizon, output_type=\"quantiles\")\ntirex_q_response = client.forecast(tirex_q_request)\n\n# Create dictionary of quantile models for visualization\nquantile_models = {\n \"FlowState\": flowstate_q_response.quantiles,\n \"Chronos2\": chronos2_q_response.quantiles,\n \"TiRex\": tirex_q_response.quantiles\n}\n\nprint(\"Quantile forecasts generated successfully\")", "outputs": [ { "name": "stdout", @@ -249,7 +247,32 @@ ] } ], - "execution_count": 7 + "source": [ + "# Generate quantile forecasts from all three models\n", + "quantile_levels = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]\n", + "\n", + "flowstate_q_request = FlowStateForecastRequest(\n", + " x=train_data, horizon=horizon, prediction_type=\"quantile\", output_type=\"quantiles\"\n", + ")\n", + "flowstate_q_response = client.forecast(flowstate_q_request)\n", + "\n", + "chronos2_q_request = Chronos2ForecastRequest(\n", + " x=train_data, horizon=horizon, output_type=\"quantiles\", quantiles=quantile_levels\n", + ")\n", + "chronos2_q_response = client.forecast(chronos2_q_request)\n", + "\n", + "tirex_q_request = TiRexForecastRequest(x=train_data, horizon=horizon, output_type=\"quantiles\")\n", + "tirex_q_response = client.forecast(tirex_q_request)\n", + "\n", + "# Create dictionary of quantile models for visualization\n", + "quantile_models = {\n", + " \"FlowState\": flowstate_q_response.quantiles,\n", + " \"Chronos2\": chronos2_q_response.quantiles,\n", + " \"TiRex\": tirex_q_response.quantiles,\n", + "}\n", + "\n", + "print(\"Quantile forecasts generated successfully\")" + ] }, { "cell_type": "markdown", @@ -260,12 +283,25 @@ }, { "cell_type": "code", + "execution_count": 8, "metadata": { "ExecuteTime": { "end_time": "2025-11-05T18:01:23.853901Z", "start_time": "2025-11-05T18:01:23.589279Z" } }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABKUAAASmCAYAAAD/KRjlAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3QV8U/f6BvCn7t7SFkqL23AdNgaMIRvbmN0pc7vz/eduzN3dlTlzxthgG+7D3V3r3v/neXMT0tJCKbW0z3f33NMkJycnIW2SJ+/v/XkVFRUVQUREREREREREpBp5V+eNiYiIiIiIiIiIkEIpERERERERERGpdgqlRERERERERESk2imUEhERERERERGRaqdQSkREREREREREqp1CKRERERERERERqXYKpUREREREREREpNoplBIRERERERERkWqnUEpERERERERERKqdQikRERFxadKkCS688EI9IvXUsccea4vT2rVr4eXlhffee69Gj0tERETqJoVSIiIi9QBDBYYLpS233357jR7b33//jeHDh6NRo0YIDAxEcnIyRo4ciU8++cS1TWZmJu6//378+eefFb6dKVOm2D727t2LqrBo0SKcd955dj8CAgLQsGFDO7148WLUJjwePg4MnGpCWc/DhIQE1HU1/diLiIjUNr41fQAiIiJSfR588EE0bdq02Hnt27evsX+CL774Av/5z3/QuXNnXH/99YiKisKaNWswefJkvPnmmzjnnHNcodQDDzxgP7tX8hxuKMV9sBIsMjKyUu/H119/jbPPPhvR0dG45JJL7DFm8PD222/jyy+/xOeff46TTz4ZtSUY4ePAx5GVce7Gjx9fLccwZMgQjB49uth5QUFBqOsO9tiLiIjURwqlRERE6hFWJHXv3h21BatG2rVrh2nTpsHf37/YZdu3b4cnWLVqFc4//3w0a9bMwrS4uDjXZQza+vfvbxVTCxYsOCAQrG1K/htUlVatWtljUtny8/NRWFhYbfdDREREjoyG74mIiMhBrV69GmeccYZVAQUHB+Poo4/Gjz/+6Lq8qKgIsbGxuOmmm1znMRhgNZKPj0+x4XKPP/44fH19kZ6e7gp0evToUWqI0KBBA1uz4sgZ9LDKxDnci4EWMexh9RNDIQ7/4zCwiy++GLt27XLti9vecsst9jODIec+3IdRffTRR+jWrZtV7PC+nnXWWdiwYcMhnx1PPvmkVXK98cYbxQIp4uPy+uuv2/3ldk483tIqZXicPC537777LgYNGmSPB4cFMsR79dVXD7gu93fiiSfacMiePXvaY8HH5IMPPig2jJP/ljRw4EDX4+AcFlmyp1RZli5ditNPP90eJ94Og85x48ahsjCQZMVZfHy87b9Tp054//33i23j7Hf11FNP4bnnnkPz5s3t8XEOlyzvMfL5eeONN9rjx+snJSVZFdfOnTvt8tzcXNx777323IiIiEBISIgFjX/88ccB+/rss89su7CwMISHh6NDhw54/vnny/XYi4iI1EeqlBIREalH9u3b5/qw7R6clGXbtm3o06ePhS7XXXcdYmJiLBw46aSTbFjaqFGj7IN13759rUrIiUERb8vb2xv//PMPTjjhBDv/r7/+QpcuXRAaGmqnU1JS8Pvvv2Pjxo0WBpSGQQ9DmKuuuspu79RTT7XzO3bsaOvffvvNgrOLLrrIAin2dmJAxDUrsHh8vM7y5cvx6aef4tlnn3XdZ2eINGbMGNxzzz0488wzcemll2LHjh148cUXccwxx2Du3LkHHe73/fffW6DBoKI03Acv53avvPIKDhfv+1FHHWWPOQM97ue///2vBX9XX311sW1XrlxpQQwDnQsuuADvvPOOBWAMSrgPHgv/HV944QXceeedaNu2rV3PuS4PPq7892bvLPYjY0gzduxYnHLKKfjqq6/s3+hQsrOzD3geMshhKJSVlWXBGO/LNddcYyEih3nyfjBAYvVZydCO+7v88svt+gyhynuMDAv577ZkyRILMrt27WrHxfCKz0k+T1JTU/HWW2/Z8MzLLrsMaWlpNixz6NChmDFjhg09dT4Puc3gwYMtfCXul89/HnNlPPYiIiJ1TpGIiIjUee+++24RX/ZLW9ylpKQUXXDBBa7TN9xwg23z119/uc5LS0sratq0aVGTJk2KCgoK7Lwnn3yyyMfHpyg1NdVOv/DCC7avnj17Ft122212HreNjIwsuvHGG137evvtt23//v7+RQMHDiy655577Lac+3XasWOHbXffffcdcN8yMzMPOO/TTz+17SdPnuw6j8fI89asWVNs27Vr19qxjxkzptj5//77b5Gvr+8B57vbu3ev7fPkk08uOpiTTjrJtnM+PnyM+fiUxPtX8t+ktPs3dOjQombNmhU7j/sreZ+3b99eFBAQUPR///d/rvO++OIL2+6PP/44YL8DBgywxYmPFbfl88dp8ODBRR06dCjKzs52nVdYWFjUp0+fopYtWxYdSlnPQ+dtPPfcc3b6o48+cl0nNze3qHfv3kWhoaGux9B5bOHh4XY/3ZX3GO+9917bx9dff33AcXJ7ys/PL8rJySl22Z49e4ri4+OLLr74Ytd5119/vR0Lty/LwR57ERGR+kjD90REROqRl19+2So63JeD+emnn2woWL9+/VznscqJVSkcPuUcKsVqk4KCAmsm7qyI4nlc+DMtXLjQKl3cK4pYnfLLL79YZQyHnT300EN2ecuWLV37OhT3BtnOChwOMaQ5c+aUq0k5q45YJcXrOhdWXfE4Shum5cSqGWeVz8E4L3dufzjc75+z0m3AgAFWHcbT7ji0z/3xZSVY69atbdvKsHv3bkycONEeK94X52PFoZKsHFqxYgU2bdp0yP2w6XvJ5yGv73zO8bFn1ZGTn5+fVRmxsmnSpEnF9nXaaacVGzZ5OMfIqikODSytuss5jJJDUJ3DS/k84f7Zu4rDAd2fX6ymy8jIOOTvlIiIiOyn4XsiIiL1CAOmw2l0vm7dOvTq1euA851Djng5Z+/jsCf2m2IAxQ/+XLP/E8MFDoNjWOQMp9wDLuL2XDhEcPbs2TZT3WuvvWb9kdgXyNlbqiwMCXhb7OdTsjl6ydCmNAwpWMDDAKo0DESONGzi5Qw5DjZUsiwc/nXfffdh6tSp9hiVvH/sc+SUnJx8wPU5o+GePXtQGTikjo8VhzpyKQ3/DThs7mA4VPO4444r9TI+p/hvwaGfZT3n3JVsHn84x8ieZgy1DoVDVp9++ml7Publ5ZV62xxSySGCnEyA+z7++OMtGBs2bNgh9y8iIlJfKZQSERGRI8bghuEV+0oxFNi6datV7LBRNT/ET58+3UKpNm3aHNAM3ImhlrO6iuENg6aff/7ZeiMdDD/4s6qKjczZ34eVXKxoYRjA9aFwGwZGvC1WxZTk7H9VGgZCDRs2tB5aB8PLGcQ4K25KNjN3YrWZO4Ym7FHEx+2ZZ55B48aNbR+sJmJvrJL3r7TjJ8eouSPnvL2bb77ZVdlUUosWLVCd3CvJquIY2QCf/azYj4rPMYakfJwfffRR+/dx4vnz5s3Dr7/+as8lLux3xabpJZu0i4iIiINCKRERESkTG5EvW7bsgPNZMeK83IlhEhs8T5gwwUIlBikMX9hgm4EUF1Y/lYezmmvLli0HDXFYAcRG6QywOEOae/VTSWXtg7O2MbRh1UurVq1wuEaOHGkz7HH4YckqMOL95lBH99kJWb3kPiuhU8kqIDY1z8nJscbb7lVQBxtSeChlPQ7lwdn8nCFkWZVOR4rPKYZ4DJfcq6VKe84d6THy357DSg+GDf25Tw7zdH/sWL1WEgNDPh+48PhZPcXnBiu2GIQdyWMvIiJSF6mnlIiIiJRpxIgRNsMYh445sW8OZ7fjjHLsYeQeSjFAee655yyccX4A5/kffvghNm/efMAMdQyUSsNKIGI/JGcVFZUMcpyVQSUrgXgMJXEGttL2wZn5uB8GWyX3w9PsRXQwrMjh8V1xxRUHbMuhhVdeeSXCw8NtJjn3MIRD79wrrBjAffPNN4e8f7weK3AqqqzHoTxYDcT+XwxanIGhO85aWBnPOVbacRinE3s4cRgoq9bYT6uyjpFD9+bPn3/A4+7+mJf2b8DKP/ffCSr5b89AzTlDJH8vjvSxFxERqYtUKSUiIiJluv322/Hpp59anxw2mo6OjrahSGvWrLEm0e6VLL1794avr69VVrERutMxxxyDV1991X4uGUqx4TUrlFhZwqCGgRcrrVgh1KNHDzvfOUSLARiDClYz8TjYy4oL9//EE0/YMEH28hk/frwdX0ndunWz9V133YWzzjrLKmmct/vwww/jjjvusIomDtNiryjug2EF7wuDp7KwAuaDDz6wxtwdOnTAJZdcYveJ+3r77betmov9rtz7D/H2b7vtNmuwzceVvaL4GPG+uTfPZl8iZ/UNQy82+n7zzTcteCktcCkPDnFk0MKqNgZcAQEBGDRo0CF7d7k3y2foyPt62WWXWRXRtm3bLKTZuHGjhTxHgo83AyUOmWOPMYafrFZiby2GjYdqKn84x8jheNz3GWecYU33+RxhkMjKNPY1YxN0VvexSor/VieccII9L3gZn4/893C69NJL7bp8LDlUk1VvDNL4eDv7YR3pYy8iIlLn1PT0fyIiIlL13n33XZuKfubMmQfdLiUlpeiCCy4odt6qVauKTj/99KLIyMiiwMDAop49exb98MMPpV6/R48edjvTp093nbdx40Y7r3Hjxgds/+mnnxadddZZRc2bNy8KCgqy/bdr167orrvuKkpNTS227ZQpU4q6detW5O/vb/u77777XPsfNWqUHV9ERETRGWecUbR58+Zi2zg99NBDRY0aNSry9va2y9esWeO67Kuvvirq169fUUhIiC1t2rQpuvrqq4uWLVtWVB7//vtv0TnnnFOUkJDg2j/vz6JFi0rdfvz48UXt27e3+9O6deuijz76yI635NuzcePGFXXs2NH21aRJk6LHH3+86J133jng+Plvd8IJJxxwOwMGDLDF3ZtvvlnUrFmzIh8fH9vPH3/8Ueq23D8v5/On5HNi9OjRdl/9/PzsMT3xxBOLvvzyy0M+TtwfH9eD2bZtW9FFF11UFBsba49Phw4dDjgG57E9+eSTpe6jvMe4a9euomuuucYu520lJSXZ78DOnTvt8sLCwqJHHnnEHt+AgICiLl262POf2/A8J+73+OOPL2rQoIHtJzk5ueiKK64o2rJlS7keexERkfrIi/9X08GYiIiISF3D6ilW+5x33nn2s4iIiIgUp+F7IiIiIlWAs65xiB2HQHI41yOPPKLHWURERMSNKqVERERERERERKTaafY9ERERERERERGpdgqlRERERERERESk2imUEhERERERERGRaqdQSkREREREREREqp1m3wNQWFiIzZs3IywsDF5eXtX/ryAiIiIiIiIiUkcUFRUhLS0NDRs2hLd32fVQCqUAC6QaN25cnf8+IiIiIiIiIiJ12oYNG5CUlFTm5QqlAKuQcj5Y4eHh1fevI/WqGm/Hjh2Ii4s7aEosIvp9ETlc+/btwz///IO+ffsiIiJCD6CI3peJVBp9jpGKSk1NteIfZ95SFoVSgGvIHgMphVJSVX/Ms7Oz7fmlUEpEvy8ilS0yMtICKb2PEdH7MpHKpM8xcqQO1SJJJRsiIiIiHiw0NBSdO3e2tYiIiIgnUSglIiIi4uGNRPPy8mwtIiIi4kkUSomIiIh4sD179mDChAm2FhEREfEk6il1GGNpc3Nzq/ZfQ+r084ffYrOvVEV7Svn7+6sflYiIHEDD90RERMRTKZQqB4ZRa9assWBBpCI4pILPn7S0tEM2eisLw6ymTZtaOCUiIuLE14XExES9PoiIiIjHUShVjjBhy5Yt8PHxsekMNXOaVPR5lJ+fD19f3wqFUgy0Nm/ebM/F5OTkCgdbIiJS9+Tk5GDjxo02+15QUFBNH46IiIhIuSmUOgQGCZmZmWjYsCGCg4PL/8iKVGIoRXFxcRZMcT9+fn56fEVExGRkZODff/9FkyZNFEqJiIiIR1Gj80MoKCiwtYZMSU1zPgedz0kRERGKiorC0KFDbS0iIiLiSRRKlZOGS0lN03NQRETKen1gewG9ToiIiIinUSglIiIi4sE4icbs2bNtLSIiIuJJFEpJubFXxXPPPVfu7f/880/71nbv3r16lEVERERERESkGIVSdRCDoIMt999/f4X2O3PmTFx++eXl3r5Pnz42WxxnA6pKzvDLOXyBt9elSxfceuutdvuHi/v59ttvq+RYRUREKltYWBi6detmaxEREfFc2fnZ2Jq+FVl5WagvNPteHeQexHz++ee49957sWzZMtd5oaGhxWaFY+NszgpXntnfDrcxd0JCAqoL72N4eDhSU1MxZ84cPPHEE3j77bcttOrQoUO1HYeIiEh14mt5YWGhrUVERMTzgqg9WXuwPWO7LTzdJbELkvySUB+oUqoOYhDkXFg1xMof5+mlS5faN6k///yzfasaEBCAv//+G6tWrcLJJ5+M+Ph4C6169OiBCRMmHHT4Hvf71ltvYdSoUQgODkbLli0xbty4Mofvvffee4iMjMSvv/6Ktm3b2u0MGzasWIiWn5+P6667zraLiYnBbbfdhgsuuACnnHLKIe93gwYN7D62atUKZ511Fv755x8L0q666qpi1V5DhgxBbGysPTYDBgywAMv9PhLvE4/debo8j4+IiEhN2LNnj722ci0iIiK1H4OnLWlbMH/rfPy17i9M2zgN6/aug5+3HwoK69ds6wql6qnbb78djz32GJYsWYKOHTsiPT0dI0aMwO+//465c+daWDRy5EisX7/+oPt54IEHcOaZZ2LBggV2/XPPPRe7d+8uc/vMzEw89dRT+PDDDzF58mTb/8033+y6/PHHH8fHH3+Md99910IlVj1VdChdUFAQrrzyStvP9u3b7Tw2gWXIxSBu2rRpFqTxuJ3NYRlaEW+fYZnzdEUfHxERkaoWEhJiFcFci4iISO2Uk59jQ/MWbFuAv9f9jembpruCqKTwJDQKb4SwgLB6N5uuhu9VQPfuwNatqHYcCTdrVuXs68EHH7SKIafo6Gh06tTJdfqhhx7CN998Y5VP11xzTZn7ufDCC3H22Wfbz4888gheeOEFzJgxw0Kb0uTl5eG1115D8+bN7TT3zWNxevHFF3HHHXdYpRK99NJL+Omnnyp8P9u0aWPrtWvXWiXVoEGDil3+xhtvWFXWpEmTcOKJJ7qGKPI896GHfGwq8viIiIhUNVY9JyUl2VpERERqn33Z+/DJv59gd9Zu+Hv7IyIwAqH+ofD38cee7D1IzUmFj7cPfL19bdv6VC2lUKoCGEht2gSP1p3JmhtWArEB+o8//mgVQhxGl5WVdchKIFZZOfEbWvZ0clYllYbD/JyBFCUmJrq237dvH7Zt24aePXu6Lvfx8bFhhuyVURHO/hrOtJn7v/vuu21oIW+X/bRYvXWo+1nRx0dERKSq5ebm2msTv1AJDAzUAy4iIlKLFBYVYsLqCVYZFR0YjSIUYXP65gO284Jj4q6M3AykRKbYUh8olKqAauzdXWW3W7LEn0PofvvtNxta16JFCxv6dvrpp9sb3YPx8/Mrdprhz8ECpNK2r8rGrByeSM7eUBy6t2vXLjz//PNISUmxb5V79+59yPtZ0cdHRESkqvGLk3nz5qFx48YKpURERGqZFbtW4I+1fyDELwSNIxofNLwqLCrEosxFKChSpZQcRGUNoatN2HeJQ/Gcw+b4BpdD3qoTG4+zkTj7OB1zzDF2HiuZ2Ii8c+fOh70/VjJxeB735RyWx/v5yiuvWH8o2rBhA3bu3HlAcMbbrW2Pj4iISGmioqJw3HHH2VpERERqDw7FG7toLN6b9x4y8jIQExSDFtEt0Dyqua0jAyNd23p7edvCiqn6RJVSYtjw++uvv7bm3axeuueeeyo8ZO5IXHvttXj00UetGon9oNhjirMJlafZG4fjZWdnW9Py2bNn44knnrDAiffL/X6yyTqHL7KJ+i233GJVT+5YVcWG5n379rVKKr7Jry2Pj4iISEl8XeIXKvWtMaqIiEhtll+YjxmbZuCThZ9YIEW7snZh16ZdNpSPYkqEVBEBEVU6kqg2Uigl5plnnsHFF1+MPn36IDY2FrfddpuFNtWNt7t161aMHj3a+kldfvnlGDp0qP18KK1bt7Y35KGhoWjWrBmOP/543HTTTcUalr/99tu2z65du9owBzZnd5/9j55++mm73ptvvolGjRpZRVRteXxERETKGr7H1yj2dhQREZGat2b3Gny54Ess3bnUTrOJOQMn96F5u0qEVNgNJIQmIDE8EQObDKwXXzh5FdW3GK4UDBc4dIyNtku+mWPlzZo1a9C0aVP1aagBrEZq27YtzjzzTJvxzlPx14zN0X19fSv8h0XPRalPv/esfOSMmWz2KCIHx/cvnEV2wIAB9n5GRPQ6I6L3ZTVr8erFuPOJO/F91vcobOYYYXNCyxPQP7k/1u1bhylzpmD+6vlAUumlQknhSdhw4wbU1ZzFnSqlpFZZt24dxo8fb2+sc3Jy8NJLL1koeM4559T0oYmIiNRKYWFhNnMt1yIiIlJz2B/52eeexRdffIH8hvnARY7z/XL9LJDy9/FHy+iWQCSw458dlsjkxuYiNz4XOQ1ykBOTA/gAneI71Zt/RoVSUquwKuK9996zIXWsLmrfvj0mTJhg1VIiIiIiIiIitUleXh6++uorvPDCC5g6der+C47b/+MxccdYIOXUsntL3Px+8TYylFuQiz/W/IGTW5+M+kKhlNQq7PPEme5ERESkfDghyK+//ooTTzwRMTExethEREQqSW5urg0/47J3714kJydbiwmnZcuWYdCgQdi8eXOx6/l380du41z7OSEkAcN7Di/X7fn7+CMxLBHNo5vXm39DNesQERER8WCcRZYz1pacTVZEREQOT0FBgc0Az9ngg4ODbTZ2hlCcjb1Hjx747rvvDriOeyDVrHUznH7H6Qg+Ldh13gmtToC3l6KXsqhSSkRERMSDBQYGIiUlRROyiIiIHIElS5bg0ksvxZQpU8rchtVS7iIjI60FzUknnYQTzz8RPk198Pmiz7F3lWO7ZpHN0C62HfIL87ExdaNNesVZ+AJ9AhHgG4AAnwD4+fjV6383hVIiIiIiHj60gDNW8o0xAyoRERE5POwHdcstt9hrqtNRRx2FqKgom0GOC19nO3Uq3oCcw+Y5WRfCgVmbZmH5ruWYvH6y6/ITW51oQdSO9B02LK9xeGPsy9mHvdl7kZmbidScVOQV5AFecIVVhUWO2frqC4VSIiIiIh4sPT0ds2fPRsOGDRVKiYiIVEBISIgrkOLQvUeffxSNOza2ECnQL9B6PXHx8y5e1eTr64uIuAjM2DQD6bnpGLd8HDLzMu2yjg06oklkE+Tk5yC/KB9tYtqgcURju4yTeuUU5CAjN8O2z8jLcIVVEQERB9xOXaZQSkRERMSD8ZvbgQMH2lpEREQO38UXX4wvvvgCHTp0wJlXn4lvV32Ln2b/hAbBDZAcmYyksCQE+wXbUDuuQ/xCEOQXZKe3pW/D3qy9WLl7pYVTxB5SI1qOsJ93ZO5AcngyGoY1dN0eq6cCfQNticH+SUoYVq3esxopkSn15p9RoZSIiIiIB2MvCw7b41pEREQOjrO9T5gwAffdd1+xkOir777CrC2z8Pmyz5GWm4aW0S2xJ2sPlu1YZsFTckSyhVRZeVnYWrgVBYUFdt0iFCGvMA/fLvvW1nR0o6PRIKSBVUH5ePmgVUwr+Hj7HPKfxsvLy3pN1afG6PXnnoqIiIjUQRkZGfj3339tLSIi4ukKCwsxduxY7N69u9KHu1977bXo378/7r//fvz222+uy3Zm7sSENRPw9dKvsXz3coxfPR4/rfwJIf4hNuSOfZ8WbFuAmVtmYmv6VquW4vlcGD5N3zQd/27/1/bl7+2P45sf76qS4hA+biOlUyhVBzFdPdjCX8Aj2fe33357WMfA8bmcQvPCCy+0nheH69hjj8UNN9xQwSMWERGp+9NX84021yIiIp6KQ9d++ukndOvWDf/5z3/wxBNPVNq+Z82ahc6dO+Oll16y26G33nrLqp1W7V6Fn1f8jEnrJmHD3g34acVPWLt3Lf5e/zce+fsRC6vCA8KtUormbp2L39f8bkP1tmdst2F7P6740dWgfECTAbY9m5gzvGKVFD8X83ZLWwqLCostzuOrLzR8rw7asmWL6+fPP/8c9957L5YtW+Y6LzQ0tFqO491338WwYcOQnZ2N5cuX44033kCvXr3wzjvvYPTo0dVyDCIiInVdeHg4evfubWsRERFPNHnyZNx55502tM59Rrz/+7//Q1xcnJ12hjUMeA6n6uq5557D7bffjrw8x9C6oKAgjBkzBhdfeTHmbZ2HOVvmWLC0OXUzfljxAwqK9n/Jk1uQi19X/YopG6ZgaPOh6NWoF6ICo6ypOWfaW7NnjQ3tW7F7hW0f6heKgU0GWri0K2sXOsV3QlRQlFVabU7fXK4hfH4+fvDidHz1hCql6qCEhATXwqkr+Uvrft5nn32Gtm3bWv+JNm3a4JVXXnFdlzMOXHPNNUhMTLTLU1JS8Oijj9plTZo0sfWoUaNsn87TZWHDVd4etzv++OPx5Zdf4txzz7X979mzx7bZtWsXzj77bDRq1AjBwcHWWO7TTz917YPVVZMmTcLzzz/vqrxau3atfRt8ySWXoGnTpvZHpXXr1raNiIiIiIiIeAaOpGEhw4ABA4oFUqyW4gid2NhY13mPPfYYzjjjDKsOLo/t27fjxBNPtGDLGUj17NkT8+fPx1mXnoXZW2dj9pbZFixtSt1UrCdU+wbt0bdxX1dvJ/aY+nLJl3hyypNYuH2hNTpn5VRkYCQmr5/sus0hzYdY83LOosfLWkS3cA0PbBTWCP0a9ztg6Z/cv9jSu3FvxIfGo75QpVQ98/HHH1vlFMsWu3Tpgrlz5+Kyyy6zIXYXXHCBpdHjxo2zMbzJycnYsGGDLTRz5kw0aNDAVQHl43PolLekG2+8ER988IGN3z3zzDOtiop/cG677Tb7hvfHH3/E+eefj+bNm9sfDAZNrLJq3749HnzwQdsHk3Im3klJSTZDQkxMDKZMmYLLL7/cwjTuV0REpL7gFz1s2Dp8+HB7TRQREantFi9ebJ9Lv/rqq2Lns3ji4YcfdhVCOP3888+46667rFpq6dKl+Oabb6xFTFkmTpyI8847r9gooltvvRX3PnAv1qWuw8zNM7EzYyfW7V2HLelbrJdUTkGObdcmtg1GdxwNX29fC4k4nG/B9gV22fbM7Xhn3jtoGtkUI1uNRFZ+FtbuW2uXxQTFoHdSbxsSyKF7PRv1RKh/KHLyc1CIQustFROs1+mSFEpV0DPPPGPLoXTt2tVCHncnnXQS5syZc8jr3nTTTbZUJs4w8PTTT+PUU0+106w04h+E119/3UKp9evX2y93v3797I8AK6WcnGWTzgqoimBlFrHaiVghdfPNN7suZ+O5X3/91UIxhlKs9PL397cqKvfbZCD2wAMPuE7zfkydOtWup1BKRETqE1YMN2vWzNYiIiK1HUfnDBw40CqZnDi6hp/vOLKmrOKHsLAwpKamYtGiRejRowc++eQTjBgx4oDtGFzdc889rkCKhRUffvgheh7TEwt2LsCWtC02gx6H3O3K3IUvF39p4RI1j2qOCztdaIGUXTekAS7sfKH1mPp++fdYs3eNnc/1CzNesKoopxEtRtj1tmVss1n6GFzRzixHlVRciOPztBSnUKqC+MuwadOmQ27XuHHjA87bsWNHua7L26hMnJVn1apVNuyN1VFO+fn5Fv44h8sNGTLEhsOxGorljhx6V1lKjgPmMLxHHnnEwiQ+JvwDlZOTYyHUobz88svWn4pBWlZWll2XzetERETqEw63ZyjFtYiISG3HooNbbrnFFhYeMEC69NJL7fyysBqYI3dYQcWiin379tln1Yceegh33HEHvL33dybiZ82PPvrIPhuyp/H777+P/OB8a0zO8Ck3P9dm0uOQvLGLxyI9zzEcMCUiBZd0uQT+PgceB6ucrulxDRbuWIgflv9gs+pRdn62rZPCk9ApoZP1jmJlVI+GPRDgG2CX+3j5ICUyxTUUUIpTKFVBHGrGKp9DcVYXlTyvPNet7IalzrG3b775pv1yunOm0azsWrNmjZVHcigAq46OO+446wdVGZYsWeKqbKInn3zShuix+Rz7SXEYIWfaY8B0MOyLxQorVn2xuStTc+5r+vTplXKcIiIinoJ9MtijMSoqCgEBATV9OCIiIsXwsx2DIj8/P9d5V199NXx9fV2tZEqTlpOGjLwMayzOgKdVq1aYNm2ajfDh8D0WPNx9993Wl4rtaRo2bOi6Lj9vctsmzZtg5Z6VWL1ltYVN6TnpmL91vg3V+3zR59iXs8+2ZyXT5V0vL1b5VBLvQ4cGHdAuth2mb5puDdAZbLEpOYfyMXTamrkVDcMaWkjl7CXFQIpD+6R0CqUq6EiG1pUczldd4uPj7Rd19erVVhZ5sDCMU3ByOf30061iavfu3YiOjrY/JEcy5TTDJ+6fQRexmd3JJ59s432JvaLYQ6pdu3au6zAxL3mbvF6fPn3w3//+13Ueq8BERETqm7S0NMyYMcNe5xVKiYhIbbJy5Uqb2GrQoEF4/PHHXedzyDmLEUrisDrOWsdeT0t3LsX2jO1oFt0MPRJ7IDEs0YoRWDDBpucMpBhMMaDiwtdD95nm45vEY87WOdiasRXe8LYG5WxoziF2ny38DLuzdju2C4nHFd2uQJDf/mHw7AuVX5hvYVhJnEGvT+M+6JbYDf9u/xcRgRFoGd3SqqJ4PK1jWtttZORm2Ex6rMA6nBkD65sarR+7//77XTOqORdnzyF3/IdluR4vZwd+dxy6dcIJJ9hwL44VZQkgh6NJ6ThOl7PpsaE5w59///3XGpc7+2Nxzdnv2DyOl7OROEsq2UfKOdb3999/x9atW10z6JVl7969tt26deussTkDLo77ffXVV137Y/8qXsZG5ayiuuKKK7Bt27Zi++FtsgKKfah27txpwRWvN2vWLOs/xeNkySfLOUVEROobDsE/5phjXEPxRUREasskW5xci5/bnnjiCYwfP77U7XILcrE1fSvmbZlnfZvenvM27v/zflvenPMmxi4ai/fnv2/D5lbuWonsgmzceeed+OGHH4q99nGWdyosKrQeUDM3zcSmtE3Ymb4T0zZMs9vgjHifLPzEGpYTK5iu7HalNSR3Yhi1IXWD9YLasG+DBWWlYWDVvWF3C6SIARpn5GN4RgzXGoc3RlRQVCU+qnVPjVdKHXXUUTZMzIklfKVV15SWLLJ6hoEUQxOGGmxkNnr0aKvmYZ8iORDH6jLA41A3BngsleSwOWdKzeSZfzBWrFhhQ/rYQO6nn35yjdHlcDlWiHEIIIcgOhuWl+aiiy6yNXtccFs2T+c3uRwi6MR0m5VbQ4cOtePiDHqnnHKKjRF24jA9lmiyeoq9ozi8kOEVZw5kNRefG0zfWTXFYYciIiL1CV+v+XpekVlxRUREysLKI86Qx2FwAwYMsN7Dffv2PWQPQ16PARFnXXdiUYF7axtWIu3J3mPD29bsWYPVe1bjnw3/YM6WOVi5eyUKivaPlGFTcZ5/dKOjsXjHYhwVdxQ6xHfAMccdY4EXPyuyIosjaTJzM7F893Ks2r3KhuYxVGI4FBccZ9VLr816zWbbIwZUV3W/yiqd3I9rY+pGG37XKqYV1u9bb/tgDynOnBfiV/pQw/TcdAT4BKB1bGsbxsfTwX7BNnRPDs6ryNl5uoYqpVj5NG/evDK34WVsYMYnW2JiopXlMbQgBhC8bPPmzVayTq+99hpuu+02ayZ+sEZpJRuKM2FlEFKyj1N2draFIByTqgaiUlH8NWMFH0PXipZu6rko9QWrITkbC6tf3ZtWikjZPSP5pQ9nrXUftiAiep0RqSiOZmFBA0cmueNnYgZTLGRwLzZwYn8nFgywyMGJk2m9+OKL9gVKak6qBVEMetanrreG43+v/9uG1rF/1KE0i2qGPkl90Ca2jQVA7O/UKLwRwgPCbb8MrRhqcVY9hk+BPoHIyM+wPlLzts2z26cw/zBc3eNqm13PPZDakLYBjUIboVdSL6ue4uc47nfVnlUWULEXVWxQLEL894dT3IaXtY1ra5VTtG7fOrSLa2fHWV+lHiRnqVWVUnyyss8Rn9xsWM2hZcnJyXZZZmYmzjnnHJtljdVQJU2dOtWqfJyBFLHi5qqrrrJpIlkqKCIiIlLXG52z9yPXIiIiR4IBAkeqvPXWW2V+Uc52LiWbk2/YsMGCqtdff931esRROCwaOfXMUy0kWrRpEdbuW4u1e9ZaEDV7y2xX1ZI7Vhh1TeiKbg27YUvaFoxfPR57s/faZayo4sIhc32T+1oA1TKmJZpENLEgiFVXrGpi7yhWPC3YvsDVO8p9/xyy5x5Iccgft08ITUDPRj1dw/lYUBAXEofY4Fi0iG5hFVjOoX0c+sftWJHFkMo5jG9f9j4LvTh0Tw6tRkMpzgD33nvvoXXr1jb0jv2O+vfvj4ULF9oT+MYbb7QSPDbCLg37FbkHUuQ8zcvKkpOTY4t7guf8dp6LO55m8ulcRCrK+fyp6PPI+Rws7XkqUpc4/+7qeS5SPnzPxG+tudbvjYheZ0SOxFlnnYVffvnFdXrgwIE2Eom9fSdOnGitd/ha06JFi2KvOZxRnTPgOXXv3h0vv/UyAuMD8fXCr/HPpn/w77Z/bSje5vTNFgK545C3trFtraE5K4w41I5SwlPQPbE7pm2ahgmrJyA11/HZfcXuFRZIsal4/8b9LRDivudtnYeVe1daMFWSj5eP3caIFiMsfML/PpbxWBhiMaTq2dARSJX2mY0hVEyjGDSPam49q7jsztyNosIidGnYxaq1+JgwQGvfoD2CfIPq9etyYTnve42GUmxe7tSxY0cLqVJSUjB27Fgbb8onPfsGVTZWYzEAK4lD/pj8umPKyweTQ6/UQF0qin/UnDMIVnT4Hp9/fC5y2m/36VRF6ho+z/ktHX9vNHxPRL8zInqdEak+119/vQ3d40gm9pPirO0s4uAIpcGDB+Phhx+26lx+dnb3xx9/uH4+95Jz0ebUNhgzbwwW7V6E9enrkVdYejVvUkgSeif0Ro8GPRDu/78hXqXMW3Z8/PE4NvZYTN48Gb9u+BVpeWkoQhGW7lqK5buWIzYwFtuzHc3L3XnBC22i2tj+O8d2RrBvsOOC3P2BFCupUvxT0Ca8DQJyApCdUzwTKCkEITgq5Cik+KbYzH6cZS/JJwnZ+7KRnpOOEK8QBGQHWDuK+iwtLa1c29X48D13nJGtVatW1qSMs8KtWrXKNUub02mnnWbVVH/++acN6WMPBXfOmdtKG+7ndMcdd1izbif+kjVu3NiCsNJ6SvHBZC+g0pqwixyOIwmT+PzjB/SYmBj1N5M6H0pZqXRcnEIpkXLghwP24GQD2ujoaD1mInqdETHsvcwv+dgup6wvxjMyMooNxTv++ONt6B4bm7NghO/L+BnE/X2Zc3QSA50dGTuwdOdSJJ2QhL1d9yKvSR7GFo5F3syyh5Sz4ojVUKxKahTWyHV+JjKtr1N2frZjKci222cFEhcvfy/0ad4H3VK64e8Nf2Pi2onIys9CIQoPCKSaRjZFl4Qu6NSgE8ICwordhhMfG87OFxEcgbZJbREdVPw1lJcfrKAgEIGIRawds4+3jz0emamZ6BTfCY2jNHQv8BAN8Z18a1ujTgZR559/Ps4880xrrOaO6eyzzz6LkSNH2mn2oBozZoyrIS4x1WWwxJnayhIQEGBLSfwlK/mtPE/ziehcRCrC/Q9aRZ9Hzudgac9TkbpGz3WR8gsKCkJSUpKt9fogotcZqX84omL+/Pno1q1bsfP52fmZZ56xz8dt2rRB27ZtXUuTJk1sRvYlS5bY7HruBRhsTO78DLNyz0r8tfovpK1JswCHC3s3sVH5toxtyC/8X1kTJ4BNKr3KKTIg0voxOReGP9x3bkGu9WNi+JSbn2vhEofYBfoGWt+nhhEN4eftZ8Pk1qWus9nyIgIiEOAXgMHNBltPqUnrJtnCEIsBF4OozgmdDwiYSuLts59VWGCYNTXnzHrueD953zjbHvfF4YVl8fVxPHZ7svbYtkkRSXo9hiNLqfWhFBuoMWBiAssU97777rPpjNmtn0lsadVObILOmfCcKS7DJ4ZYbKrGPlJ33303rr766lJDJxEREZG6hmEUp9rmWkRE6hf2Y7744ottzdFGzZs3d13GwMk5MogjjEqOMnJiOMXRRMShbL+v/h3jV43Hb6t/swDqcLEnE8Mn9nnimrPVcfheZl6mhUfcJ4fV+fv4WwAVFxxnYQ6bg7NhOIOgIL8gVxDEfazbu85mwON1GUxFBEbYdYc2H4rBTQfbrHi8XnkxkAryD0KvRr2sibk7zrbHYX7NoptZ+MbG5nabARFlFhiwWoqzB3IGvgBfZRGHo0ZDqY0bN1oAxR45DKH69etnKS1/Lg8GWD/88IPNtseqKZYdXnDBBXjwwQer/NhFREREass35OzDxqF7/v7+NX04IiJSDXJzc/HYY49ZjyfnbHeXX345fvzlR6TnpVug07N3TwtLli1bhnVrSw+XIqIjkB6Tjtsn3G6NxOdsmWO9mg6FTbytcikwwiqhbB0YiZSIFAuhWP1kIVReNtbnrrcAikFTw7CGFgIxuOLCIMnP5+AtTjh0r0N8BzSNampVUwyn1u9bb+fzNtkU3dkYvTy2pm+1QIuBlPsMfJSWk2YVUh0TOyIxLNGqr9gEnU3U16euR1RglN1uSbuydlm4lhiaWO7jEAevIk0pZ8lxRESEvaErrafUmjVrrDqrvGMiRUrirxk/NLAstqLD9/RclPqCvQOcw7I1FEnk0Dgj0vfff2/V57Gxxb/tFRG9zkjdM3v2bKuOWrBggeu81m1a45HnH0FYszALT1g5lF+Qb+vcwlykZ6TbyKKt27dix84d2L1vN3Kic7ArZJdtUxoGWwxajoo4Cv6B/vD39bcQiMEMh6zZjMn/+4+VT8SfnUPwGN7EhcRZhRF/ZiXUoQKo8mBjcYZSnIGPM91xv1FBUa7KKvZ2YhhXUFRgARMXns4vykdOfo4NDTw66WgLyNyximt7xnZ0jO+I5tH7K86IARurptbuW4vM3Ezri8WqLuL+WXnVo2EPNArf3yOrvks9SM5Sa3tKiYiIiMjh4Rs+VptzLSIidRe/pOYs8hxu55zZm6OHLr/ucgy/ZDjeX/Q+fvjshzJDJhdmKc6Rbo7duLCKKSksyRqFp0SmoH1ce3QN74qkxCRsz9xuYRB7J/E22O+JFVPMo5zhDyuWGBIxhGJlVFVgGMRhcjw+Hs/K3SstMCJnAYCzeooBGdfB/sEI8AmwQKpxeGOrgnLHY2ePLA4VZEVWSbxe69jWFmTxNjmMcE/2Hnu8GIzFh8QjIbTsydakbAqlpMI4A+LAgQOxZ88emyXxvffeww033IC9e/fqURUREakm/EASFhZmaxERqZumTJli1VEciufUpn0bXD/meuyN3ourx19tvY8OF4fQtYpuZRU+DYIbID403gIW9kU6Ku4oW3JSc6wReFxoHNrEtrHm5Lszd2Nz+makZqdaoMOG4ZzljsP0OEqE1Up5BXm2tsqlogI7n2vnecQ1z7f//nc9588Mu1iB5Qy5So44YVDE42kS2QSb0zbbeQzKWI3FNY/F+TNnxzto0/O0LTZUj/s7WFNz3sejGhxl4RSDqY37Ntp9YpB1sNuQsimUqqM4Y8L777+PK664Aq+99lqxy9gI/pVXXrH+WwySKst//vMfjBgxAtV130pasWIFWrRoAU+kQE9ERCoqMzPTPqSEhobaIiIidQvbgHByr9WrV9tpPz8/nHPNORh83mB8uexL/DDvB1fIw0ClVUwrq2BiZZAzmHH97BbWMJDy9/a3We/YaLxZZDPrDcWm5AxZGNDw8u2p213HwuCF23LhNu4B1a7MXTZEjkESAyRWKfF4Si68bati8vaBN7ztZ55f7DRnHPfytuF27OnEIYkMpzgUsGT4w6GCzaKaVfjxZYUUhyW2i2tnj015cLggr5MUnoTUnNQDelNJ+SmUqsMaN26Mzz77zKYCdc7Iw5LPTz75xGYxrGy8jeqa+WfYsGF49913i51X3gb5pTUJVGNYERHxVGxwyz4hzka3IiLi2TgRGHvwMHwi9qV97qXncNKIk9CqYytc9dBVyIrKwq0Tb8XWjK2u67HJ9pBmQxAZFOkIhpz//a/CiGv3/xj8sCqKlUaskGK4wuqm9g3aW8jD8Id9o8pSMqDi9XMLcu18ZyBV2s+H22OXw/TY62ntnrXYlLbJQije5uE0Ny8Lh97xuFj9xCqow8H7weF7JWfvk8NTdl2aeLyuXbtaMPX111+7zuPPDKS6dOlSbFv+sXn00UetoTuDpU6dOuHLL78sts1PP/2EVq1a2eUctrd27doDqn04jM9p1apVOPnkkxEfH2/f3Pbo0QMTJkwodp0mTZrgkUcesVJUDj3gsb3xxhuHvG8BAQFISEgotjiHLUyaNAk9e/a0bRITE3H77bfbtwtOxx57LK655hobasiGsEOHDrXzOY3q8OHD7Vh5zPw2gs1j3R+jJ554wqqxuG8e65gxY1yX33bbbfb4BAcHo1mzZrjnnnuKfUCYP38+Bg0aZPeTLzLdunXDrFmzbBjkRRddZA3g7IXCywv333//IR8DERERYi+pAQMGqKeUiIgH4xCyf/75xz6DNGrUyGaZJ4ZEq3evRmCrQNz9+t14+MOH8cu+X3DXxLtcgRQDn+OaHofT255u4VD/xv0tnDqu2XGu5fjmx9t5XNvSwrHul9zPhu7tyNxhgVHXhl3RMqblYQ9F4/asHmK4xZCGP7PqitVY7C3F4YAMkSoy6ROH6TE465PcBz0a9bD9cgY9Dtljc/KKYvPy9Nx0q5BiQ3apGQql6jiGPe4VRe+8844FICUxkPrggw9sqN+iRYtw44034rzzzrOAhzZs2IBTTz3VZvaZN28eLr30Ugt7DiY9Pd2G8/3++++YO3euVTfx+uvXry+23dNPP43u3bvbNv/9739x1VVXFRsrfTg2bdpkt8kAjCHQq6++irffftumSnXH4X+sjuIfft5n9sFiYMSwjkHRL7/8gm3btuHMM890XeeOO+6waVcZNi1evNgqzhheOTFsYjDHy55//nm8+eabVqXmxOGSSUlJmDlzps2YwceP33706dMHzz33nAVVW7ZsseXmm2+u0P0XERERERHPwc8hL774Ijp06GCTVnz00UfIycnB66+/btVBMzfPxLxt86xvk3dLb1z5y5X4dfWv1neJ2JT86h5XW7DSOKIx+if3t2CKTbe5MCTi0DJnRQ8rjJxDz9iniUP12IsqOjAa3Rp2O2BGutqEQ+s4XK5Xo16u2fNY6bQxdaOFS4eDYd/OzJ1oGd3SGp9LzdHwvQro/kZ3S2arG/+ozLp81mFdh8ESw5R169bZaYYwHNLH6hwn/tFjtRKrmHr37m3nsdLn77//tj+G/PaV4U7z5s0tQKLWrVvj33//xeOPP17mbbPaiovTQw89hG+++Qbjxo2zSiUnhkgMo5zVRgxy/vjjD7uNsvCbA/e+Gaxw+uKLL6xXFqvDXnrpJUvh27Rpg82bN9t+7733Xtf08i1btrSqJyeGVgyk+Di4B3jc1/Lly63iikET98twifh48IXD6e677y5WAcZgiY/1rbfe6gr2brnlFjsm5zG4f8vN42XFl4iIyOFgpe3kyZMxZMgQREVF6cETEalBqamp9mU/v+jn5yx+2c/AyWn69Om46aabrIUIF/bFzcrKKraPqOgoxDeNx9T1U5FbmGsVQZ8u/BTTN013bcOqpmEthqFLQhcLZNhHqmN8RxvaVhZrHs71/xqJZ+VnYXfWbptpj/2jqmq2vMrGqixn2MYZ8Nhzio8R7ws/7wX7Blt1VVmPBftvbUnfguSIZLSKbVWh6i2pPAqlKoCBFMeyegL2WTrhhBOsgod/ePgzh6y5W7lypTVJ5ZtZd/wj6Rzmt2TJEvTq1avY5c4A62CVUhyG9uOPP1r1D4fQ8Q9uyUqpjh07un52BjPbt+9vplcaDh9kUOYUEhLiOk4el/sflr59+9qxbNy40dVLi0Pn3LGqikFYaQ1iOQyR32DwRWXw4MFlHtPnn3+OF154wbbn7fH+svrJ6frrr8dll11m334cd9xxOOOMMyzYEhERORKsum3QoIGr94iIiFQ/jrLgZ4GXX37Zvixw4mgT91CKnxM4k15p+LnltPNPQ1z3OPyz5R88OfVJLNmxBLuzdxfbLiUiBf9p9x+bnY4VP90Tu7uG3LH6h2ETsW+UcxY752n3nzmcjhVWzaObV0p/purGz3zuPa3SctKs8TorzNjfiuvSQip+nmfVWNu4th55v+sa/QtUsGLJk26XQ/iclUn8I1kS/zASwyOOX3bH3kkVxUqh3377DU899ZT1YWIvqtNPP93CLncl30Tzj8vBGuo5Q6gjmWnPGWK5PwYcWlha5RerpJwzXZRl6tSpOPfcc/HAAw9YjypWPrFKyllZRqzUYuUae3P9/PPPuO+++2ybUaNGVfh+iIiIsJchq3C5FhGR6sUvpPl5hy1T+CV2SSXPc36+YljCn9mTd8RpI9Dk+CaYmzUXT214Cpt/2FzqbXHmvBEtR6B3Um+r9IkKjLJKKfaEKigssGFs7OHULbGbDXVzNjankj87q604hK8uVArxfnNJDEu0qrGM3AyrIOPwPmdIxb5ZrJLiLH5s5s6gSmqeQqkKONwhdDWNvZwYBPGPjbOpt7t27drZH0RWMHGoXmnatm1rw+7cTZs27aC3y6GCF154oSt0YfBTsjl6ZeNxfvXVV/aNgPOPK4+D/Z7Yz+lgTeF5PQ674+wWJXGoHUM19sdiP62S+G1HSkoK7rrrLtd5ziGT7tgIncMSWcZ79tln24sXHx/2tyooKDiCey4iIvUVXz/S0tIQExPjGqYuIiJVi/1w+YU2W4i4f6HOL9z5RTQ/MzBwYjsQd+wny8mQFu9ajC8WfYEflv+Ad7a9g6I5jqF1JbGJOSujWkS3QM+GPS1I4VA19kHqktjFekPl5OdY03POvsfKJzYCr8/4mHEmPS4MqVrHtnaFVKyk4mPGvlpSOyiUqgc4Kx2HtTl/LomBDauaGJTwDyr7JLHklGEOh5+xh9KVV15pVT/sicQ/sGzUzSGBB8Mgh7P9sQKJAREbhB+qAupIsTcVm4Zfe+21Vh3GhumsSOK47YO9Ub/66qutMTmDIvaAio6OtmGNrGR66623EBgYaH2peBkDJJbW7tixw8aKX3LJJXZfGepxezZZZ9UZ+2c5cdgiH2MO2WO/Lg4lZMPz0047zS5nGMbQjqEX+3Dx22594y0iIuXB12z2gWQ/qZJD9EVEpGp8+OGH1r7DiW1ArrjiCpvhu7Qvw/ml+YJtC/DF4i9sWb5rean7ZTUTm3mzATcXzjrHmeuIVT+s9mHw1KFBBzufQcuerD1oFtXM+kIdrKdUfVUypJLaRaFUPeHe26g0bELO/lOchY9D1Zjqs3rozjvvtMvZi4mVRAyuODtEz549rSk4hwaW5ZlnnrHL+W0A3yQz1GHjv6rE4YccHsfwjOEOwyWGRu5NyEvTsGFDC+F4jMcff7yV2bLyiVVmzjCLoRqrqDgMj83TOayPYR2ddNJJ9tgwCON12buL27OnljMM3LVrlwV8HG/Ox4Pjyzncj/gYcV//+c9/bDsGac7rioiIHOo1/uijjz7ka72IiFQM39+zusm9/6zzcxE/b7B3LGcQLznZBIOo+dvmW0UUg6gVu1eUun827GYAxYbjrIDy9fG14XhcdmbttDX3xUbk3Rt2t+FpDFrYP4o9pTgUjT2V2FNKxNN4FTlb8NdjDErYA4jfNJZ8Q5ednY01a9agadOmVi0jUhH8NWPjc4ZaFR2zreei1BesqORkB2zcrKFIIvqdEdHrjNQUfhHN2ci58Avkkl8aT5w40SZZYpsP9/f9c7fOxZeLv7QgauXulaXum0PtGC61iGphw+3Y34mhEvtGcc2eUKx6YpNurv18/RAZEGmzzjGk2pKxBaF+oVY1VZXVP3pfJlWRs7hTpZSIiIiIB+MQcQ4553D8khN5iIjI4WGoxN65nEnvyy+/tC+WicEUR5GwlYfToEGDbJ1bkItJayfhu2XfYdyycdiQuqHUYXnOiqjWMa0RFxJnM8CxMorDyhhG+fn4udashCqN+kdJXaNQSkRERMTDh5WwryEnLlEoJSKCCo9KYI8oDslj/1x3bMXRv39/7N271yq5nf2dfl7xswVRP6/82WZ3KyuISolMQduYtogPiUd0cDSSI5Lt/IiAiMMaRcH+Ubuzdqt/lNQpCqVEREREPBj7QPLbeq5FRAQ28zj733LiIbYCcE4ixOCebVmeffbZYg8Tq6Iefvhhm8jIHfvAXn755dYvis3L1+9bjxenv2hB1KR1k5Bf6KiicscKp4ZhDdEwtCGaRDRBo/BGiA2JRXK4I4jirG/OKqh92fuwN2cvvOHNBMuBzXW8HIGWddr538+FRYVWRcUG5+ofJXWJQikRERERERGpE5YuXYpzzz0Xc+bMKfXyDh06HHDe999/XyyQ4oRP1113nU1ClFWUhbGLxuKj3z7C3+v/LnWfAT4BVv3EmfIahTVCiF+IDc9LiUixHlAxQTHFmpBn5WVZA/Ngv2B0bNDRekoxdCrif0VFxX7mf3a6qMi25/5E6hKFUiIiIiIejA1EOYMsq6VKzvwkIlJfMLR54403bFY89tojVklxoiFWTjmxYqqkzMxM2+7000/Htddei649utqQvHO+Owc/rvjRekaVFOYfhubRzW1YHiugCooKEOofag3MOVyP57FZuTtWVm3P2G6VT82imtlse+wnJVKfKZQSERER8WD8IMWhe1yLiNRXnPCBgVJeXp6dbtOmDT755BN06dLFmpUzqMrIyLDZ5EriUL+WLVtidf5qfLDgA5z4zInYk73ngO2iAqPQvkF7dIzriJiQGKTlpNnwuujAaKuS4ix4kYEHDqVmpRN7QWXlZ1loxUCKTc4rOiu3SF2idy8iIiIiHow9Uo466ig1ORcRj8Qqpg8++AAXX3yxVTZVFEMl9oW67bbbrAfUU0895aqKYmjPGUq5OGXmZWLV7lVYsXsFZuXPwoVjL8TafWsP2G+QbxA6xndEr4a9kBCagLTcNGTkZSCvMM/CpcYRje18X+/SP1o7+0ZxCN9RDY6yUMp9KJ9IfadQSkRERMSDFRQUWAUA10fygU5EpLotXLgQ5513HubPn2+z311zzTWuyzir6A033GCXjxgxAoGBgcWuy+05K56fn5/rvJtvvhlHH300jjnmGNcMeYu2L7LgacWuFVi1ZxVW71mNtXvXYkdm8abm7hgwHRV3FHo07GFNyxlg5RXkWfVUZFAk2se3R0JIgvWCKgv7RvE2QvxDrG8Uw6sA34AjfMRE6h6FUiIiIiIe3lPqzz//xMiRI22mKBGR2o5D6J5//nnccccdyMnJsfPuvvtujB49GuHh4XaaQ+84ex6XiIgI6/fEgIqB0+LFi3HOOefg5JNPxkMPPeTaL4P5o/sejbfnvI1XZ72KOVvmWKPw8mCfpxbRLdAloYs1KGclFBUUFljzcg7N4/A9Ds8rq9KJfa3Sc9MtDPPz8bOeU+obJXJwCqUqiM3uSpsCtKowrS/ZKE+qD9/sDxw4EHv27NGU2yIiUqtwOEqPHj2KDUsREamtNmzYgAsvvBATJ050nde+fXt89NFHrkCKxo8fXyx8f/vtt21JSkqymfIYZi1atAjHH388+vfvj5W7VuK56c/h438/tlDoYDg7Hns6cUgdK58iAiIQHxJvn7cCfQIRHhCOxPBEu5xLkF/QQffH4Iq3mZ6Xbs3OW8a0dIVY6hslcnAKpSoYSM3YOMP+6FSXUL9Q9EzqWe5giiX8999/v/1x37p1Kxo2bGh//PkNhPMPI5P8++67D2+++Sb27t2Lvn374tVXX7Xx2MQ/9Jdeeim+++47JCQk4JVXXsFxxx3nuo0nn3zSympffPHFgx4Lj+Pbb7/FvHnzyn1/mzRpYuW6XERERKRsHLrCCin3ISwiIrURq5/++9//WsjkdNNNN2HMmDEHDM9jKMXgip9nWC2Vnu747LVx40bXNm3btcWMtBm469278Pf6vw+oimKglByRbNVNkQGRNmMeh9PZZyovxxf/AT4BdpoBUnxoPKKDoi2kKk/fp5z8HBvSx6oqXp9hFGfd422ISPkolKoAVkgxkPL39q+WccH8Y8fb4+2WN5R6/PHHLWB6//33rfnprFmzcNFFF1np63XXXWfbPPHEE3jhhRdsm6ZNm+Kee+7B0KFDrRyWLwqcUnX27NmYOnUqfv75ZyuR3bZtm4Vaa9assTCL+63tjRP9/VVhJiIidRf7qvB1mRUGpU11LiJS03bv3o2rr74an332meu8xo0b47333sOgQYNKvQ6bk7MKiktmZibGjRuHjz/+GL/88gvyA/PR7cpuWN9gPW6eeXOx63l7eVs/KC5xwXH2eY2foRg+hQWEWR+oYN9gq34K9A20RuZcH07zcecQPR8vHzQIbYDG4Y2t8opD9kTk8CiUOgL8A8c/YNUVrhyOKVOm2BjrE044wVV59Omnn2LGjBmuKqnnnnvOKqe4HXHWi/j4eKtqOuuss7BkyRKcdNJJFmo1a9YMt9xyC3bu3Im4uDib0YLBl3uJbXmxYouVWf369cPTTz9t9423x+Pht7zHHnss1q1bhxtvvNEW5/HS33//bWPPGYbxW+FRo0bh0Ucfdc04xPt5ySWXYMWKFXY/Tj31VCxfvtxKenm8Tiz5ZfXY77//buPSP/zwQxvXvmzZMtsXXxx5PA0aNDjs+yciIlKd2OScU6G3atVKoZSIVEsQ/uuvv2L69OkWHIWGhtrC99DOdVRUFHr16uW6DmfFcw+kzj33XLz00kvlbovBwJ2fF0aeOhIXfXURvlrxFWYXzQYy92/Daqgu8V2sLxSDJwZSKZEpVsHkDKAYWJUHP3uwIIALq6BsXeBY5xflWyUUZ95rFN5IQ/REjpBCqTqqT58+VunEQIZvUjmjBQOdZ555xi7nN6oc1uc+HI9VVHzxYGUU/+h36tTJwhq+2eULT2JiogVB/IaClVQMhCrqjz/+sP1xzTfS//nPf9C5c2dcdtll+Prrr+22L7/8cjvttGrVKgwbNsxe1N555x0LljhDB5d3333XtR2nf7333nttaCLx2xRWhT322GOuoYuff/65hVIMqygvL8+aJLZu3Rrbt2+3MmKGZz/99FOF76OIiEh14Ie/IUOG2FpEpCo9++yz9h47LS3toNulpKRg7dq1xdp5cAgev5h+7bXX7L3/4dqStgXDPhqGBdsXFGtO3iqmFdrFtkNSRJIFRByux8bkMcExhwyhGDJxlrys/Cxr0eIMpPiZgUP7fH184evla9VUHNbHMIo/sypKQ/REKodCqTrq9ttvR2pqKtq0aWNTpbLHFMdq81sJYiBFrIxyx9POyy6++GIsWLAA7dq1szBq7Nix1uibgQ8bf7PKit94NG/e3EKiRo0alfv4+MaZ347w2HiMrOhi1RJDqOjoaDufDVvZy8qJFVE8fmefKfa+4vDDAQMG2FBF5zh0Vjn93//9n+t6Z555pl2HoZwzhOJ49rPPPtsVUvG+OrEqjPtl01iOXec3PiIiIiIi9Qm/mOYoBlZDOfEzwaECKXKOYnDi6Ap+8cxRCIfzmcFp4baFGPLREGxNd3xO4VC8bg27oVV0KySEJliTcoZR7AlV1kiWwqJCZOdnu0Io9p9i4MTto4OjERUQZSNhOASPw/38vP+39vGzgEpEqoZ+u+ooBkisaGL4wuF3bDLOYIbVQRdccEG59sEXoZdffrnYeexLxZ5Uc+fOteFxrMBiFRLP++qrr8p9fDwmBk9OrJr6999/D3od3hZDMt4vJ36TwSllWfnVtm1bO6979+7FrsfhhhyLzusxlOK2rAZ7/fXXXduwdxa/weFtMHjjPomN3BnKiYiI1Fb8EmratGk2/L28Q2FERMoamsdesvws8cMPP9joghEjRrguZ2sPfok9fPhwawHCYXX8EjcjI6PYurTKzS5dulToQf915a84deypyMxzjNVjE/ITW56INrFt0CSyic1yx/NKznLHGfHY+4nX4xA8Vk0F+gXazHtJ4UkIDwy3n12Nz0WkRiiUqqPY/4nVUhyGRx06dLA+Taw2YijlrEBi43IGQk48zWF0peFQO067+tZbb9n++QLFb0FYicSqp8NRcoYgvog4g6Cy8AXuiiuucDVqd5ecnFzmNzPECitejzMFMqjj48GF+OLJBu9cGFwxxGIYxdOH28tLRESkuvFLHn4wdP+yR0TkcP31118477zz7H2w0xdffFEslGK7j82bN8Pbu3y9mY7UKzNewXW/XIeCogI73TC0IU5sdSJ6J/VG27i2B1QwsRqKQVRqbio4EV+ofygaRzS2flMMnxhCsTKqZIAlIjVHoVQdxRkqSr5Y8M2qM/jhbHsMpjhkzhlC8ZtWNixkE/PSvjXhjBkMbZzDAZ3Nx9mPiacrE2fMK7nPrl272syALVq0OOz98Zsc9qhifymGUqNHj3ZdtnTpUuzatct6TnEWEKrtswqKiIi4fxnTsWPHUr+UERE5FL7nfuSRR2zUgPuXxKx2YluNkqojkOLnjGt/vhYvz9w/aoO9o4Y1G4bujbpblZSzXxS3tSAqJxWFKESYfxiaRTZDg5AGiAqKUhWUSC2nUKqOGjlypPWQYgURh8pxuB2bnDt7J/HbAQ7nY9Nw9mZiSHXPPffY8L5TTjnlgP2xCTi/JXGW3fbt29eqpTicj1VSPF2ZOIve5MmTrdIrICDAxq/fdtttOProo62x+aWXXmpvvhlS/fbbb4es1OK2vF+8j5xVkP2knPgYMQRjFdWVV16JhQsX2v0VERHxBPwQmZOTY+vqql4Qkbph06ZNVh3FfrFOnJn6zjvvtD6tJUc3VAf2fDrls1MwfvV413k9GvZAv+R+6J7Y3cIpcgZRHKbHKijOtMeeUmx2zt5QIuIZFEodgZz8nFp7OwxYGMD897//tdnkGDZx6BublDvdeuutNnSNFUScCaNfv35WSeRsGO7EkIbjytmXyun000+3Fy/2aOKMdaw+qkwPPvigHS+bqPONNr8B4bfAkyZNwl133WW3y/N4eXln7+AQPgZrfKF1H+7H4XrvvfeevfiywTkrsjiDH8fMi4iI1HZ8DZ84caJ9IcUvcUREyuPHH3+0th4cMUAMtTmzHt9r19Rw4A37NmDoR0OxZOcS1+x6g5sORteErtbYvFlUM+QU5GBrxlariOLQPFZEcWa8shqci0jt5lXkHINVj3HYGsdH79u3z2aGKDlsjY2xWUnkDGs4XeiMjTOQnpdebccY6heKnkk9VX7qofhrlp+fb7OXVHQMe2nPRZG6iNUeDNM5Q4+qPkTK9/qwbNky+5JIrw8iep0p75C9bt262SQ/lJSUZG06+OVtTZm+cTpO+uwkbM/Ybqc5+93IViOtMqp7w+7W1Jxf1jOQahHdwpZgv+AaO976Qu/LpCpyFneqlKoAzs7AgCi/MB/VhU38NCuEiIiIlMQh6JwNi2sRkfJgJdSnn35qs1YPGTIEb7/9NmJiYmrswftq8Ve44NsLkJGXYafZoHxU61FWCcWhe1y7B1Lt4tod0ORcRDyTfpMriAGRQiIRERGpDZVSnC2L30JyFj4R8Xz88pu9kiqzN1JaWhrCwsJcp9u2bWuT+7Rp06ZGZ6N7duqzuHXCra4v/Dkc76RWJyExNBE9GvVAw7CGNlKFgRSH7ymQEqlbFEqJiIiIePiMu5z4o1mzZgqlROpAy4dtGduwctdKZOVnIS4kDnHBcYgMjLRm3hUZpjdlyhS8+uqrWLRokc207T7Ml8FUTd7XG369AS9OfxFFcHSUYeg0rPkwu88MpBJCEyyQ2pK+xS47Ku4oVUiJ1DEKpUREREQ8GKdsHzZsWKlTt4uI50jLScOqPauwbu867M3ei0CfQGTkZmDNnjXWOykqKArxIfEWUIUHhJdZ3ZSXl4c//vgDX3/9Nb799lts27bNddnNN998yFmrqwODpv988R98u+xb13ldErqgf3J/xATHoFejXogNjkVeQZ4FUk0jm1og5edT/bMBikjVUiglIiIiIiJSxRYvXYxfJ/2KxNhENE9ujpSUFJvUg8ELZ52btmkaZmyagZW7V1q1VMPQhuia2BVNIprA28sb29O3Y1PqJmshEhEQgcSwRAuqGFDl5eTht99+w1dffYVx48bZrJwlceje0UcfXSn3JTUnFev3rbcm5Ifb0mR31m4M/2g4Zmye4Trv2JRj0bFBRzQIbmC9ezmbHh+XTWmbHBVSDRRIidRVCqVEREREPBj7xMycOdNmzeIsNyJSu6SmpeK2u2/DGy+/gcKCQsAHQBww8KyBaHNcG8zcNBPLdy+3oKek8UvGIyEjAUk5SYgNiEVsSCxCAkPQe3Bv7MjcYUPZWEV19yV3Y9qf0w64flBQEIYOHYrTTjsNI0eOrPDfCA61W7JzCX5a8ZMtf63/y3pAsZrp4s4X4+qeVyM5IvmQ++GwxKEfD8XqPavttBe8cELLE9A8qjmaRjVF54TO1uScgdTm9M12HgMp9fIVqbsUSomIiIh4MA7h8fX1rdFGxSJSepDz0ecf4ZabbsG2wm3AEDZNAhALwBv4g//N+uOgD122TzbWhq/F2oK1wCIAMwFsAPwS/NCvTz+E+4ejoKgAXfp3cYVSQSFB6H5sd/Q9vi9aHd0K6zLX4eddP+PnCT/bzHWsbmKz8JYxLS0AKguHDv6x9g9XELVu37oDttmZuRNPTHkCT055EgOaDMBlXS/Dya1PLrX/1d/r/saosaPsOuTv7Y+TWp+EJpFNbGhe27i2FrIx7GIglRKRgvYN2iuQEqnjFEqJiIiIeLDQ0FB06dLF1iJSOyxZvgSXXXcZ/tn1D3AigEYH3z7YNxhx/nFYN3EdwBZQOQA6A2hp5USO6qqO/1u2ApN3TUbWKkcjdDYDb9anGfqe0hfJxyQDScCa1DV4a9db2PmzIwAqS1RgFFIiU9AyuqUNk+OSlZeFn1b+hElrJyGngAdyIA4ZZG+rjakbUVhUaI3K/1z7py2snhrafCjO63ge2sa2tdn0xi0bh0vGXYKMvAy7PsOwkS1HokVMC+sl1Ti8sQXrDKQ4ZE+BlEj9oVBKRERExMOrMfLz820tIjWroLAAz3z/DG7/8HYUdi8ESvTl5nA1zizHYWkMdhgKJYYmwsfbxxqUp8WmIS81D/lp+fCFLzKLMrG8cDlWFq1Ejtf/AqIEYEbmDCyYuwAd4jtYKMRm4Nu6bMM/qf8Ai8t/vHuy92DP1j2Yt3XeQbdjTyv2uGoc0Rgp4SloENrA+lqxP9TMzTOxeMdipOel27ashPr434/x2cLPrCqLTcrHrx5vgRPx/o9oOcKqtbomdLW+WJSdn229tBhQsUIqwDfg8B58EfFICqUqiN8gcNaI6sJx1EF+QdV2e1Lce++9hxtuuKHUppEiIiI1ac+ePdbgmP1iYmM5LkhEqtuWtC14ffbreGfuO9iQugHoUPzy2KBY9E/pb/2X+qX0syqjrelbMXvzbPh4+ViVEIfLpSWlYU/WHpt9jyFPfkE+2vm3Q5BvEBbvXIx/NvzjGkaXXZBtgVBZODyuYVhDq1TiwhCM+96dvdv2zx5WXJzVSyWF+IVYQMThdc2jm9t94Mx4DJUiAiNsfwySjk46Gqt2r8KsLbMwf9t8x/1nQFdUYH2ouDglhydbIMXeUQyeAn0DkZ6bbsfFmfUYYHEYnwIpkfpDoVQFA6nvln1nfzyrC79B4Pjs8gZT999/Px544IFi57Vu3RpLly51nc7Ozsb//d//4bPPPkNOTo41QXzllVcQHx9vl+/evRsXXHCBTSnbsmVLvPPOOzY8wOnqq69Gs2bNbB8Hc+GFF1qYwylpy4svzN988w1OOeWUcl9HRESkPgoJCUGnTp1sLSKV68UXX8SsWbOsQXh4eLhrHRwWjG0+27AybyXm7J2DObvnWAjjzjvfGx0TO+L8LufjlDanOGbR8/Z2Xc5hd61jWmPh9oUWGnHYmxOrivhZg5VDnOWOQRK3Ob/j+RYkTd80HXO2zEFeYZ7rOjFBMTYUjxVN0YHRCA8MR1hAmM1o56xGYkUl/2PlE2XnZWNvzl6b1Y+N03dl7UJOfo5VcjWNaIqEsASbCY8BFCujGBy5Y6jEgI39qbokdrHhfAympm2chqW7lhb7Er9NTBuc2OpEdEvsZsMEGUZtz9hujdoZeiWFJ9m+1B9PpH6p0VDqYMEJA5H77rsP48ePx/r16xEXF2cBxUMPPVRs1ghedtVVV1lwwl4KDFEeffRRa/hZVfjHlS8S/MaCf4irGr+B4O3xdg+nWuqoo47ChAkTXKdLPiY33ngjfvzxR3zxxRf2mF5zzTU49dRT8c8//9jlY8aMsRl95syZg1dffRWXXXaZvSjTtGnTMH36dLzwwguozVgG7edXom5aRESkDgkICEDDhg1tLSKVi58x+EUp/GG9mpDyv4U9osp4i8lwhT2VLuh8gQUwDF3KwvCHFVGcjS4pLMmG8REbfrNfFJc2sW1sSBwrqxgecZveSb3RP7m/VWixqig+JN6G8WXlZ9ntMeBilROvzyGDqbmp1t+JodLuzN02bI9ftOcF5CExLNH6OjmDKvaR4mecMP8wC4g4Ex7Dr7TcNPs8wsCMwRb/R9wmwCfAqqfiQ+NtWN7AJgOxdOdSq+xasXuF4zFpNtSCK+6bfaO4f27Lai6GZyJSP9V4pVRZwcnmzZtteeqpp9CuXTusW7cOV155pZ335Zdf2jYFBQU44YQTkJCQgClTpmDLli0YPXq0hRCPPPJIlR87/6CWNrNEVeALzOHiY8nHpjT79u3D22+/jU8++QSDBg2y89599120bdvWAqejjz4aS5YswVlnnYVWrVrh8ssvxxtvvOEKevhv8dZbb8HHx/HCeTiOPfZYdOzYEYGBgbYPf39/2x9DSmrSpImtR40aZeuUlBSsXbvWfv7uu+8syFy8eLG9AWcIedddd7meN3xRZLXXzz//jN9//92quFjhxW0YXjrNnTsX3bp1w5o1a2z/zzzzjN3/1atXIzo62oZAPPHEE2oaKyIitR6rnTdt2mRfMHH6dxGpnN5Qv676FbNjZgOXAUh0zJhXFu8MbwxoNwDndjoXw5sPt3DGGTAdDLdh6JSZl4mtGVvRKOzAjugMqFhVxYWz1DGgYg8pViUxdGIYxSot9yCKVU18X8xqJA7V41A5VifxPA7HY9DEy7jsy9mHXZm7bBgfq6QsiMpxhFAMtBhkcSggP/vwNtiknF+Us70IHyfug9fn9twXz+NnJAZnHeM7WgUW98tgiuFWsHcwOsV3siqsgwV2IlI/1HgoVVZw0r59e3z11Veu082bN7fKnfPOO8+aefJ6rKJiOMFQi0POOnfubJVUt912mwUcDDvqsxUrVlhww/Cnd+/eVkGWnJxsl82ePdvCpeOOO861fZs2bezyqVOnWijFoQATJ07EpZdeil9//dWCJGJYw2Cpe/fuFT62999/HzfddJNVW/H2OMSvb9++GDJkCGbOnIkGDRpYSDRs2DBX8PXXX39Z6MjqrP79+2PVqlUWlhGr6pz4b//YY4/hueees+dJVlaWhW/uodTHH39st8dAilhKzf02bdrUgqn//ve/uPXWWy3gEhERqc0yMjKwYMECe01TKCWCI3p/2rx1cyzyXYQnpzyJVXtWOaqjShFUEITIrEjEZ8cjel802iW2w50j70RiDNOrw8OwhxVDszbNssDJfRhfSQyIWNnEhQEVAx+OquDQPVYqOaudyBlIcTtnIOW+Hw7p49IYjS3YYk8rZ1DFsIzVT6zC4vHx55JD99xx+B6DJwZb3I8z6CryKkKCt+OzHocBcnghq7rUM0pEak0odbDgpLTqHo7hdlbFMMzo0KGDqwcSsS8Sw4dFixYV639U3/Tq1cuac3M4JCvIWF3EIGfhwoUICwvD1q1bLbSLjIwsdj0+lryMbr/9dnssGQiyeomVVfz34gs2H3tWNzEYZDj15ptvFhtWeSgMuJxBEvtVvfTSS1bZxFCKQzWJx+YeWPI+8JhYHUXsZ8UQkuGReyh1zjnn4KKLLnKdPvfcc/H000/bUE8+twoLC62P1t133+3ahk3MnXhfH374Ybt/CqVERKS2i4qKwvHHH29rETl87LN014N34dHfHoV3H28UhhQesA17HTWLbGbVP+d0OAdHNz66WAB0pLj/dg3aWeNzhkKsRjoUBjusPioNgyEGUmwazn5Nh+rTxPvCIXRHMoyOx8OF4ZMz6GIFGI+Fw/0YtrHqS0TEnW9tDk7c7dy50wIIZ2UMMTxxD6TIedoZrJRV5s7FKTU11dYMK7i442lrCPi/hdzX1TH9ckVujxVGTgzuevbsaWHL559/jksuueSA+1Ly9rgwAGRFkbvBgwdbpdRHH31kFUXs/8V/E/7bMfgpz/1wHpP76cTERGzbtq3YeSXv7/z5863fFSvmnDiEkw3b+S1xcLCj/JfD8tyvx4ovDkvkfWGo9eeff2L79u04/fTTXdux2o7VVbw/fD6wGs99vwd7vMrrSPfhfDxKe56K1CXOv7t6nouUD39fWPGr3xupr9gDlRX2y5YtQ58+faxH6sGqBt1fZzbu3YiRD4/EgoAFwBCgEPvfYyWGOnotDUgegGNSjrFqptCA/4VFRbDQpTLFB8ejVUwrLNq+CH7efjY8riIYBO3O2m3DAhmkVddnltIE+wbb4qTXds+j92VSUeX9fa/RUGr48OHFKmcYUrH0fOzYsRacODEkYO8o9pZy9h06EqzGKtlgnXbs2GFBhDsOceODyZCCC3HNMIRjtzlmuqrZ7RQUFDuGw8Um8KxIWr58ue2D1Ui5ubkW9rlXSzEY4tC50m6HFVIMqvhvccYZZ1jfJX7rwt5PfDzLOjZniOK8nC+KrHZz357nOe+j636XOJ2eno5777231Bn53PfHqruSx8LeWBzCd/PNN1s4xW+UWdnF7divivfliiuusPvBb5rZo4xhW2ZmplWUOX+hKvr4O+8fVXRGEd42j2PXrl1q3i51Gp/nrIx1ftAWkYPj6yO/uOGXMHy9F6krVu5dibf+fQs7snbgmKRjcELTExAbtH9oG7/UZiX/hx9+6PqS+bXXXsO1115rwRSr59kSpLTXmYWbFuK9ie/h8+WfozDC7YNTEdAmsg1GpIxA74a9bdhbbEisBUSZ+zLB/6pSWGEY4hGPrdu2Ii447rDfN+bm59rQucYRjRGeH46dO3ZW2bFK/aD3ZXIkXxiUR62qn2Q4wqbaK1euLHZHWPXDyinOfOE+kxqHds2YMaPYPhiqOC8ryx133GH9jJz4Ita4cWMLahi6uGNIxWNg6OEcNsg1+xz5ePmUq4HhkbLb8fEpdgwVecPKyqbzzz/f9sHKKT6WkyZNwmmnnWbb8NslDnFjr6WSt8PAjhVK7OvEy5whC392hk5lHRs/VHJxb0bOxX37kts4/53dt+natasNH2Tvq4M+Xv97rNyxFxmH+PFN+9dff22zCTq34Xk8fjY7d34A5jbO2+fiPP9IZ3U8kpkAnccRExNjwZtIXcXfR/6N4N9khVIih8ZZ97jw9eFwhtKL1FaLdyzGmL/G4PNFnztmeQPw05qfcOffd2JAygCc1vY0DEseZj1OnWGUO36xwcopLnz/yDUnV1qzdw1mbJqB75d/j7GLxjqqopzffRQAyV7JuGjARTi+xfFoGtkUMcExNTLcLCImAnO2zLF+UZyhjkPqynMcnE1vX+Y+tE5obRVXlTm8UOovvS+TiirvZ9ZaFUoxOGHzagYnxBcZ9ojiG61x48YdcKfYg4pBCYdisbqHfvvtNwuWWFV1qDdvJTmDkZLnOUMU5zcV7uuKVr0cjorcHiuCWP3DyjPOWMhAhmENvzHiPhgAshqNs9PxTSwfM36rxMeUS0k33nijbZuU5Bi3zuCKQ/j478N+Ujx9qGNzv7ys++I8j0MN2WS9X79+9m/F6iVWSZ144ol2nzj0jv82DJQ43JM9oA62bzYwZzk3m7YzTDv55JNd27CCjBVx7GvFx4xDBF9//fVi+yr5b3+4GOId6T6cx1Ha81SkrtFzXaT8GESxvyPXen0QT7Zg2wI8PPlhfLn4S1cY5Y7D5f5Y+4ctDFwSrk5A6m+p8Fvlh9Gnjrb3cfxi8YsvvkCWVxbQEJgfPR//N+f/MPeXudiVtevAG80BfBb44JqTr8HFJ12MlIgUhAeEV8t7/LKEBISgc2JnbE7bjK3pW7E9c7vddw6D47GV1nCczc53Zu1Eq9hWaB3bulq+OJf6Q+/LpCLK+56kRkOpsoKTs88+2wIpDrHi8CmGHzzt/CaE355zO17O8IkhFvscsY8Um1dfffXVpYZOlY1//KtDRW5n48aN9jhyqBcfL4Y706ZNczURp2effdaeKKyUYo8tBkylNfbmzHusXmNptNM111yDWbNm2ZBLVl25NxqvDOxPxWo2Bl6NGjWyIXY8vh9++AEPPvggHn/8cas6YtUUg6byYMNzzqrHGfzc+wxwuAOrpLhPVtEdc8wxNsST24mIiIhI1Zq3dR4enPQgvln6TbHzQ/xCcGzysfBb64fJSyfDu6O3BS/EkGZzwGbgRKDAqwCrU1ZjXsQ85J6Ui/gu8Vi7b61tV4ACTFg34cAbzQAwHYheH41X330VJ/U7yWaZqy1YHdU6oLU1Kd+Xvc96RDGk4ux8eYV5CPYLtioqNhbnZ4XtGdutOop9pBRIiYgn8Sqqqa53/+vzM3ny5GLBCSufONsbm1EPHDiw1OutWbPGKmlo3bp1NkMctw8JCbGZ2diw+nCGWTHs4reLztn9Sg7f4+2x0sZZqcXS2O+WfYc9WXtQXThd68mtT0aQX9lNG6X24q8Ze0LxeVnRb95Key6K1NUycWcFrKo+RA6N/SG///57+6IvNrbsqeRFaptZm2fhockPYdyycQeEUYOaDkLCugR8++K32LF5h51/xV1XoO2JbfH7mt8xfdN0C2LKiyEOG5c3CGyAmS/MRP7yfLRs1RK//PQLmiU3gydgL9vUnFQLqLakbbHeUbkFuVZV1jK6pTViVyAllU3vy6SiDpaz1JpKqc8++6zMyzhGvDx5GausfvrpJ1QnBkMMiPgiUF3YXFGBlIiIiJTEL+XYzJlrkdrIqprSNmP5ruWuZe7Wufhz7Z/FtmPlz8CmA9Eupx2+eeIbfD/v+2KXr5i/AmdfejbaN2hvAQ17TzGgmrl5JrZlOPrKOt83J0cko3F4Ywuiuid2R3Jksg17W/TPIkxbPA3HDTkOX3z+RbEJf2o7Bk78oppL06imFlDtzd6LvII8O61ASkQ8Ua3qKeVJGBApJBIREZGaxpYFnLClOloXiBwqfGL1E8OiFbtWYNmuZVi2cxlW7ll50HYU4f7hFkb1DOuJX177BY/98Fixy9nC4Z577rG+p+l56diYutFGLLSJa4MW0S1wVY+r7DZ5Ww3DGqJ1TGsb/saKKw5vC/AJQHRwtAVUJ7U+Cf933v9h9+7dB/3mvrZjT63IwEhbREQ8mUIpEREREQ+Wm5trfTVZ8aHh3VITVu1ehffnv4/35r2HDakbyn29qMAoHNvkWPRL6Icpn0/Bg+8+iJzsHNflbdu2tT6jw4cPd53HRt8cpsYRFWm5adiVuQubUjfZeWxSzmohhlzhgeF2OjY49oAKoiOdTVlERCqP/iKLiIiIeDDOXjx37lybIVehlFTb8y433WbJe3feu5i8bnKZ23nDGzHBMYgLjrNhZ6zs4c+NwhohITTBwqPcXbn4/p3vkZvjaI0RHR2NBx54AFdccYVNbFMa9uhkQMWlSWQTC6hYPcUhetFB0bWqabmIiJRNoVQ51WA/eBE9B0VEpEyskBo8eLBH9cYRz30//Ne6v/D85Ofx09qfkF1UfEieF7zgvdYbBUsLgF2wpXBvIfb47UFBQgFyE3OBJCCocRCCjw5GUsMkG14XHRuN666/Ds8985zN8HzvvfciKiqq3MflHlCJiIhnUSh1CD4+Pq7S+KAgzXwnNYfPQffnpIiICHGWSn9/f81WKVWCTbTHTRuHF35+ATPzZiIrOOuAbWKCYtA8qrktsybMwoppK4pdnp+Tj93rdtuyEivtvIhbInBc3+PsOqykand3O1x68aVo3bq1/iVFROoRhVKHeoB8fREcHIwdO3ZY+bCmJ5eKfrOYn59vzyd+m1eRqVj5HORzUX0QRESk5PC9+fPnWxNoT27cLLWjUTlnxpu5aabNaDd943TM2TQH+V75AEfRuY+kY+unRcDwU4ejcVRjG0LHGe7639UfG1duxOYNm7F1w1bs2LQD2zdux7ZN21zD82hw18Ho2ain63RYWJgCKRGRekih1CEwQEhMTMSaNWuwbt266vlXkToZSjFYYqhZkVCKeN3k5OQKX19EROomvr5kZ2fbWqS8CgoLsHbvWszbOs8CKC6cOS81J7X4hiXedvhs8EHsnlgkhyajydFNMLD1QMSExsDP28/eo8S1jEOXo7rYbHeh/qE2A16wXzB8vHywZcsWe0+9evVq9O/XX/9YIiKiUKo8WBLfsmVL1/ApkcPFDwq7du1CTExMhavtNDRDRERKw+qoXr16qUpKSpWZl4llO5dh6c6lWLJziWu9YtcK5BTsn+muTOwNtQVo2bAlhvQdgqTBSQjwCUCoX6jNbBfsH4ww/zA0CGmAiMAI+znIr/SWF40aNbKlX79++tcSERGjSqlyYpCgGW3kSEIpDv/kc0hDQEVERKSqKrNnb5mNb5Z8gzlb52DJjiVYt6/8lf5sFM5Z8RLDErF10lYs/nQxUpql4KJ7L0KLNi0sjGLgxAoo52x6YQFhVg2lSm4REakIhVIiIiIiHmzPnj0YP348TjjhBKvIlfrXB2rGphn4cvGXtpQnhPL28kZ0ULQFS6x2Cs0PRVJcEqJCoixwigiIgFczLyxMXogRZ4xAeFC4DcHjtlwYRHEfIiIiR0qhlIiIiIgH4+zArVq10izB9SyImrphqiOIWvIlNqZuLHW7QN9AC54SQhNseB0XzpTHgImKCosw58c5mPDGBBx/wfE49opjbQheiH+IbTeq4ygbjsegysdbs/+KiEjlUyglIiIi4sE4NLxJkyZqM1APhub9vf5vjF00Fl8t+Qpb0rccsA2rl1rFtEKXhC7o1KATGkc0hp+Pn4VTvt6+KCgqsEBr7669mPLzFPz21W9YvWS1XXf8O+Nx66W3omNKRxuOpxBKRESqg0IpEREREQ+Wl5eHHTt2ICoqCgEBATV9OFIFFm5fiOt+vg5/rP3jgMs4q13r2NYWRHVL7IZG4Y0siPL18rWKKC7+Pv7wLvDGjIkz8M3Yb/D7+N+Rn59fbD/nnH0O2qW0s75SIiIi1UWhlIiIiIgHS0tLw6xZs5CYmKhQqo7Zm70X9/5xL16Z+YpVOTmx6qlNbBt0bNARvZN6IzE8EUE+QRZGcehdw7CGFi5x6F1eTh5uuOEGjB07Fvv27TvgNrp27YonnngCgwcPruZ7JyIiolBKRERExKNFRkbi2GOPtbXUDRxi987cd3DH73dgZ+ZO1/ns83Rc0+MwsOlAJIUn2bA8VkGxMTlnzGMwlb43HQmRCa7r+Ab5YtKkScUCqYYNG+K8887D+eefj/bt21f7/RMREXFSpZSIiIiIB/P29rYm51yL55u+cTqu+fkazNo8y3Wev7c/+jXqh655XeG33g8L5y3EzH0zkb47HTu378S2bdts2blzp/WeysrKcvUY8/LywujRo/Hoo4/i1FNPtZ8HDhwIHx81LhcRkZqnUEpERETEg2VkZGDhwoXo1asXwsLCavpwpIK2pW/D7b/fjvfmvVfsfPaKGtFiBIqWFeGRqx8p1762b9+O5ORk1+lrrrkG119/PUJDQ/XvIyIitYpCKREREREPVlBQgNTUVFuL58kryMMTk57AI1MeQWZBpuv8yKJIjOoyCsckH2ND82KTY/EISg+l2OA+Pj7etRQWFha7PCIiosrvh4iISEUolBIRERHxYOHh4ejTp4+tpfbbvHkz5syZg1lzZ2HchnH4N+Jf5Ie6zYSXDeAPoF3Ddhhy2hA0DG+I9nHtERMcg3vvvRdxcXHFAqiEhAT7t+cwPREREU+jUEpEREREpJKxcm316tVo2bJlsfOvuOYK/LDlB6APgEZuFxQBmAvgdyAiMAIxbWJshj0uQX5BtskDDzygfycREalTFEqJiIiIeLC9e/fi999/x/DhwxEdHV3Th1PvsdH4uHHjcPPNN2PDhg1IT0+Hr68vUnNS8crMVzCx40SgU/GHKXBLIJqmNkX/Xv3R9ZquaJTcyMKoplFN4eOthuQiIlJ3KZQSERER8WDsJ9SkSRNbS81iw/kbbrjBQkKnGf/OwPh94/H89OexN3sv4DbKrmVIS/Rr3g+9TuiFFtEtkJaThvDAcLSLa4eE0ISauRMiIiLVSKGUiIiIiAcLCgpC8+bNbS01Y9euXdbv6bXXXnM0GfcGEAM0Gt4Ix/90PDLyM1zbesELHRp0QM9GPdE3uS+aRzVHYVEhdmXtQqOwRhZIhQVoFkUREakfFEqJiIiIeLD8/Hzs2bPHhu75+/vX9OF4jILCAqzftx7Ldy3Hit0rbGFglBSeZAsrlZxLREBEqY3E92bsxZjXx+CVL15BZnAmcAaAWEcgxWBqEzYB/+th7u3ljY4NOqJXo14YkDIAjSMaIys/CzsydyDYLxhtYtqgZUxL+Pn4Vf+DISIiUkMUSomIiIh4sNTUVEybNs1mZYuNZSIi7janbcbSnUuxYpcjeLIQatcKrN67GrkFueV6sAJ8AhAfGo/E0EQkhiUiKy8L8zbNw7bsbY4NhpV9XR8vH3SM74jeSb0xqOkgxAbHIj03HTuzdiIyIBKd4juhQUgDVUeJiEi9pFBKRERExINFRETgmGOOsbXsr4L6btl3eHbas/h7/d9H/LDkFORYVRWXQ/H19kVccByiAqMsgOIwvX7J/RDqH4q03DQLpBhCNQpvZNupMkpEROozhVIiIiIiHszHxwchISG2ru/YKPydue9YU/E1e9eUuR2H0oUHhFtwFB0Yjfx1+dj01yZkpGYg3z8f+QH5KAouAkKxf2Gbp+D9+/D38YfvXl947fRCl85dcFSLo9AwtKFVUrGyin2hQvxCUFBUgOz8bJuVjzPqxYfEIzIwstThgCIiIvWNQikRERERD5aZmYklS5YgNDTUlvpo3d51eHHGi3hzzptIzUktdhmDp9YxrZEckYy2cW3RMrolmkQ2QURgBML8w/Di4y/i6ceePuRt+Pn7YcLyCdiwb4NVYjWNbIrAokALBH19fC3oYpPzjLwMZORmWHVVXmGehV9HNTjKqqKC/NSMXkRExJ1CKREREREPlpeXh507d9q6vpm+cTqemfYMvlr8lVUkuUuJSMGoNqNwbc9r0TSqaZmVSTddexNefu5lZGdnIzk52UKmwMBAWzijofu6f3L/clc45RXkWc+qQN9A+Hirik1ERKQ0CqVEREREPBh7SfXv379e9ZT6ecXPeGjyQ5i6ceoBTcXbN2iPiztfjLM7nI24kLhil//111/YunUrzjiD0+Q5NGzYEC+++CLatGmDfv36VdoxsleU+kWJiIgcnEIpEREREfEIW9O34vpfrsfYRWOLnR/kG4ReSb1wY68bMbjZYIT4hxS7fO7cubjrrrvw888/IyYmBkOHDkV4eLjr8ksvvbTa7oOIiIjs540KyM/Px4QJE/D6668jLS3Nztu8eTPS09MrsjsRERERqaC9e/fizz//tHVdVVhUiDdnv4m2L7ctFkjFBMXg7KPOxqQLJ+G383/DSW1OskCKTcVXrVqFsWPH4swzz0TXrl0tkKJdu3bh7bffrsF7IyIiIhWulFq3bh2GDRuG9evXIycnB0OGDEFYWBgef/xxO/3aa68d7i5FREREpIICAgJsCBrXddHSnUtx2bjL8PeGv13nsU/Tme3OxH0D7kOTqCbWZJz4fnT8+PGYM2dOqSEde0Y98MADOO+886r1PoiIiEglhVLXX389unfvjvnz51v5s9OoUaNw2WWXHe7uREREROQIsAl3q1atbF2XZOdn48FJD+KpKU/ZLHZO7aLa4aygsxC6PhTNopsVu86UKVMwceLEA/YVHx+Pu+++296r1tXwTkREpF6EUmwQyRd8f3//Yuc3adIEmzZtqsxjExEREZFytFXYt28foqOjD3h/5qlhFBuZ3zT+Jqzdu9Z1vn+OPyL/jsTivxbjXtxrs+Fde/W18PXd/3a2W7duGDduHBITE+1nLvwyddCgQQgODq6heyQiIiKVFkoVFhaioKD4lLu0ceNGG8YnIiIiItUnNTXVvjBkBXtsbGyteuhz8nPw4YIP8dact7AvZx9ig2MdS1AsYoJjEBkYiTD/MOsDFegTiCIU4YM5H+CXtb/s30khS6CA3Em52J633XV2dnY2Fi9ejI4dO7rOu/LKK60aiqGUiIiI1MFQ6vjjj8dzzz2HN954w057eXlZg/P77rsPI0aMqIpjFBEREZEycBa5Pn36FJtNrqal5qTi9Vmv49lpz2JL+paK74hF+N9z2j3HSR8fH2tafswxx9jStGnTYps3aNDgCI9cREREanUo9fTTT9s0uu3atbNvqM455xysWLHCvpn79NNPq+YoRURERKRUHL4WERFRbBhbTdmavhXPT3ser8561Sqj3Pl6+yK/ML98O2ILqd8Bn9k+6Nm9JwZcOAADBgxA3759VZkvIiJShxz2u5ekpCRrcv7ZZ59hwYIFViV1ySWX4Nxzz61zDTZFREREarusrCwsX77cwpqQkJBqu122c5gxYwYyMzOR6puKb7d/i8+XfY6cgpxi2zWNbIoBKQPQJ7EPFk1fhOl/T8eCuQuQWZAJhAAxzWJw3PnHIS0nDWm5aYgOikbvrN7oPrA7jj766Gq9TyIiIlK9KvSVGr+J01S6IiIiIjUvJycHmzdvRvv27astwNm2bRtOO/00/LP6H6AvgLYAvPdf7u3ljRbhLbDj7R3whS+WRS7Dl/O+tC8zS0pfkY4X33oRcXFx1XLsIiIi4sGh1AcffHDQy0ePHn0kxyMiIiIihyEyMhLHHnusratKYVEhVu5eiblb5uKneT/h88mfI6dPDnBc8e38vP3QOaEzzmp/FpoVNsOoG0dhD/ZgBVYU247h2QknnIBRo0ZZT9La1A9LREREanEodf311xc7nZeXZ2XbnIKYU+0qlBIRERGpPaZNm4Zdu3ZZCFTeAGrR9kWYs2WOLXO3zrUlPdetyqlR8ev45vmiW2Q3XD3kavRO6o3EsESsWb7GgjLODsjZm6Ojo3HyySdbEDVkyBAEBgZW8j0VERGROh9K7dmz54Dz2Oj8qquuwi233FJZxyUiIiIi5bBv3z789ddfOO644xAVFeU6n32m7rjjDnz99ddo2LChnXYf3sf+oLwOJ6uhbenb8O68d/H67Nexdu/aQ96ud7Y3kmOT0bdpX5zX4Tx0TOiIuOA4+Pn42eUcTsj3jUVFRcjIyLAvL7293cb4iYiISL1XKdO0tGzZEo899pj1mVq6dGm9f1BFREREqoufn58FS1w7+z098MADeOONN6wZObHn1Ntvv43rrrvOTs+aNcsmqYmMisQVj1yB1dGr8fWSr5FXyGnvDuST6YOCdQXAFtjSo2MP3H3/3WjeoLlVRUUFRsHLy6vU6/L80NDQKrv/IiIi4rkqbe5gNj/nGx4RERERqT6sQGrbtq0FUPfffz+eeuopq0xyio+Pt/M5W7LTjXfeiMKehdjdfTce3fKoI2z6Hy94ITE00cImrpPDk7Fx4kaM+3wcvH28cefDd+K6a69DVFAUfL0r7a2kiIiI1EOH/U5i3LhxxU6zJHvLli146aWX0Lcvp18RERERkeqSnZ2Nd999Fy+88AK2bt3qOp/VSWytcNNNN9nPfM82feN0vDb7Ncw6ZhbgKKLaLwNoUtgEg/sORqPIRkgITbAKqLiQOMT3iEfjosY45cRTcNzgEt3NRURERCrIq4jvUA5DyV4ALMnmFL6DBg3C008/jcTExHLvi9/asbzcXevWrV1DAPkm6//+7/+s5wGnOx46dCheeeUV+8bPaf369dbP6o8//rA3XBdccAEeffRRq9wqLzbgjIiIsJ4Mmv1FqgIbvG7fvh0NGjRQPw0R/b6IVJq35ryFMePGoHdeb/yS/YvNdAcvICgkCIFBgSjyKkJBYQEKigpsnVOQc8A+fDf5In9qPrAEFlQ1adUEw04fhquuuwoNQhogOiga/j7++leTOkPvy0T0+yJVr7w5i29F/ohXpqOOOgoTJkzYf0BuYdKNN96IH3/8EV988YXdmWuuuQannnoq/vnnH7ucZeqcSSYhIQFTpkyxii3O/seeCo888kilHqeIiIhIbbMvex82em3EBP8JSPNPc52fxf9yssq8XoBPADrFd0K/lH5oF94O3+R8g58X/4xCFGLt8rV47ZHXMKznMHQ8uWM13RMRERGpj2q8EQBDKIZKJTFNY0POTz75xKqwiKXp7JnAqY2PPvpojB8/HosXL7ZQi9VTnTt3xkMPPYTbbrvNqrD8/fWtnoiIiNRdIf4hCA8MR1pWmlUzBfsFw9vL2/pCsZrduWZhPH8O9AtE14SuOL3t6WgS2cQqpzLyMvDoE4/irv/ehf9e+V/MmzfP9s3q8zVr1hSb0U9ERESk2kMp9iIor2eeeeawDmDFihU2TXFgYCB69+5tQ++Sk5Mxe/Zs5OXl2VTFTm3atLHLpk6daqEU1x06dCg2nI9D/Dicb9GiRejSpUupt8mhgFzcy8qcVWCVXQkm4nxu8QOBnl8ih6bfF5Hyu7zr5RjVbBR++OsHeMV7wTfA10Ipf19/BPkGIdA3EAG+AVYZxXCKQ/j8fPzsNWlbxjbbtkODDkiOSIZ3nDemT59urRImTpyIK6+80irV9doldY1eZ0T0+yJVr7zvH8oVSs2dO7dcOytrKuCy9OrVC++99571keLQO/aX6t+/PxYuXGiNOlnpFBkZWew6DKCcTTy5dg+knJc7LysLg6+Svaxox44d1sdKpCp+IVn9xw8BJfuyiYh+X0SOxLad25CxJQMpsSmI9I2Ej4/P/158AOQ6ljzkubbPLczF7qzdCPUPtTAqODcYO3fsdF1+1lln2ULshyhS1+h9mYh+X6TqpaXtbytwxKEUm4hXheHDh7t+7tixo4VUKSkpGDt2LIKCglBV7rjjjmLVX6yUaty4sTVsV6Nzqao3P85JARRKiej3RaQyBYQFoEl2E8TExVhVVFn4xUhWfhZ2Ze5CUmIS2sS2sWBKpL7R+zIR/b5I1eNoOI/oKeWOVVGtWrXCypUrMWTIEOTm5mLv3r3FqqW2bdvm6kHF9YwZM4rtg5c7LytLQECALSUxLFBgIFWFoZSeYyL6fRGpbHxtsb5RKEJeYR5yC3KRX5iPvII8O82Z9+x1CF42dI9hVMuYlvazSH2l92Ui+n2RqlXebKVCodSsWbOsmmn9+vUWHLn7+uuvUVHp6elYtWoVzj//fHTr1s1m0fv9999x2mmn2eXLli2z22TvKeJ6zJgxVlreoEEDO++3336zaqd27dpV+DhEREREPEV6Wjo2Ld6E7KOyERIWAj9vPwucQgNCEeYXhiC/IGuCzoWVVGH+YYfdckFERESkKhx2KPXZZ59h9OjR1lCcs98df/zxWL58uVUojRo16rD2dfPNN2PkyJE2ZG/z5s247777rA/C2WefbY01L7nkEhtmFx0dbUHTtddea0EUm5wTb5vhE0OsJ554wvpI3X333bj66qtLrYQSERERqWtCA0PRKLYROid1RmREpCuAUvAkIiIidS6UeuSRR/Dss89a8BMWFobnn38eTZs2xRVXXIHExMTD2tfGjRstgNq1a5f12unXrx+mTZtmPxNvhyVfrJTibHkMwjgjjBMDrB9++MFm22NYFRISYtMXP/jgg4d7t0RERERqTFERsHMnsGoVsHr1/vWWLcDPP3OoUdnXDQsNQ48uPdAgtoHaEIiIiIhH8Spi18vDwOBn0aJFaNKkCWJiYvDnn3+iQ4cOWLJkCQYNGmSz6HkaNjpnZRZnR1Ojc6mqhprOYabqWyai3xepf/LzgV27OJudI2hyBk/O8IlLWZPU7NgBxMYebN/52LBhg03a4utbq9qFitRKel8mot8XqT05y2G/c4mKinJN7deoUSMsXLjQQik2JM/MzDyyoxYRERHxQEuXApMmOUKn0hYGUof3NeB+a9cePJTiezB+SciWCLEH21BERESklil3KMXwqX379jjmmGOsmTiDqDPOOAPXX389Jk6caOcNHjy4ao9WREREpBZZvBh44AFg7NiK74PFTU2aAM2aAc2bOxbnz02bAmFhB78+2yl0797d1iIiIiJ1MpTq2LEjevTogVNOOcXCKLrrrrtshrwpU6ZY3yc2GRcRERGpD5VRbGH52WcHr4AKCgLi4wFOEuxceJohlDOASkpyBFMVxfdi7MfJtYiIiIgnKfdboEmTJuHdd9/Fo48+ijFjxlgIdemll+L222+v2iMUERERqSVWrHCEUZ98wr40+89n2HTDDUD79sUDqJCQqj+m7OxsrF271vo1BAcHV/0NioiIiFR3KNW/f39bXnzxRYwdOxbvvfceBgwYgBYtWuCSSy6xWe8SEhIq67hEREREDsv48cBzz7HHkqN6qbSFQZKzsolvW9q0Adq23b9mS6bSZrpjQ/KHHgI++ggoKNh/Pre/9Vbgv/+tngCqNFlZWVi+fDlatmypUEpERETq9ux77lauXGnVUx9++CG2bt2KYcOGYdy4cfA0mn1PqppmeRHR74tUrXfeAS67rHj1UkVERxcPqlq2BL7/HnjvveJhFLe75RbgmmuA0FDUKL3GiOh3RkSvMVJvZt9zxyqpO++8EykpKbjjjjvw448/HsnuRERERA7b008DN99c9uWsfHIu3t6ONb+Sy8s7cNvdu4EpUxxLaaKigP/7P+Daa4GDvL8SERERkXKocCg1efJkvPPOO/jqq6/g7e2NM88804bxiYiIiFQHBkt33QU8+uj+866/HnjqKcDHp/RheO7X3boVWLLE0bSci/PnjRsP3D4iArjpJsf++XNt+yZy+vTp1lYhMjKypg9HREREpGpCqc2bN1svKS4cutenTx+88MILFkiF1FQjBREREal3OJTu6quB11/ffx4bkHMi4IOFUU7cJjHRsQwaVPyytDRg2TJHQMU1+0ZdcAFQW/MefjkYGBhoaxEREZE6GUoNHz4cEyZMQGxsLEaPHo2LL74YrVu3rtqjExERESkhNxc4/3xg7Nj95730kiOkqgxhYUD37o7FE4SGhqJTp062FhEREamToZSfnx++/PJLnHjiifBhTbyIiIhINcvIAE47Dfj1V8dpX1/g/feBc86pv/8UbHSem5tra1VLiYiISJ0MpTxxVj0RERGpO/bsAU44AZg61XE6MBD46itgxAjUa3v37sXvv/+OkSNHWkW7iIiIiKc4otn3REREREravNkRICUlOWaoK0+Pp0PZsgUYOhT491/HaTYb/+EHoF8/Pf4cttelSxcN3xMRERGPo1BKREREKkVqqmOGurff3n8e2xwxnOLSuPH+n50Lm4ezaXleHpCfv39xP80he9deC6xe7dhngwaO4XudO+sfjvz9/ZGQkGBrEREREU+iUEpERESO2B9/ABddBKxbV/z89HTHLHZcKkNKCvDbb0DLlpWzv7ogJycHGzZsQEREBIKCgmr6cERERETKTXMHi4iISIVlZgLXXw8MGrQ/kGJ1FBuPDx4McKLe4ODKeYDbtQP++UeBVEkZGRlYuHChrUVEREQ8iSqlREREpEKmTQMuuABYvnz/eQMGAO++CzRtuv+8oiI24wY2biy+bNgApKVxhl/Hwpn0uLj/7DydmAice66jl5QUFx0djeHDh9taRERExJMolBIREZHDkpMDPPgg8NhjQGHh/pnweJq9n7xL1GGz0XlUlGPp0EEPtoiIiIg4aPieiIiIlNv8+UDPnsAjj+wPpHh67lzHML6SgZRUvbS0NMyaNcvWIiIiIp5ElVIiIiJiONMdq6Cysw9ceP7EiY4KKc6MRxxWd999wG23OYbZSc3w8vKCt7e3rUVEREQ8id5CioiI1EHLlgHjxwOpqY6FRTSlrblwhjwGTwUF5d8/h+F98AHQuXNV3gspj9DQUHTt2tXWIiIiIp5EoZSIiEgd88UXwFln7R9eV5k4PI+VUayQCgio/P3L4SsqKkJBQYGtRURERDyJQikREZE65LvvgHPOOXQg5eMDhIcDYWGOJSjIETKxYTkX95+dp1mIc8opQNeu1XVvpDz27NmD8ePHY+TIkYiNjdWDJiIiIh5DoZSIiEgd8fPPwBlnOHpD0bnnAmee6QifnAGU82cGTWpBVDeEhISgY8eOthYRERHxJAqlRERE6oDffwdOPXV/E3IGUu+/76iIkrotICAAjRo1srWIiIiIJ9HEzSIiIh7ur7+Ak05yNCun008H3ntPgVR9kZOTg82bN9taRERExJMolBIREfFg06YBI0YAmZmO0wynPvkE8FUtdL2RkZGB+fPn21pERETEkyiUEhER8VBz5gDDhgHp6Y7T/HnsWMDPr6aPTKpTVFQUhgwZYmsRERERT6JQSkRExAP9+y8wZAiwb5/j9MCBwNdfO2bJk/rFy8sLvr6+thYRERHxJAqlREREPMySJcDgwcDu3Y7T/foB338PBAXV9JFJTUhPT8fcuXNtLSIiIuJJFEqJiIh4kJUrHYHUjh2O0z17Aj/+CISE1PSRSU0pKipCfn6+rUVEREQ8idqgioiI1FKcTY8h1NKlwLJljvVvvwHbtjku79IF+OUXIDy8po9UalJYWBh69OhhaxERERFPolBKRESkhhUWAtOnAwsXOoIn57J2reOy0rRvD4wfzybX1X20IiIiIiKVQ6GUiIhIDSkoAD7/HBgzBli8uHzXYS9rDt/76CMgNraqj1A8we7du/HLL7/gxBNPRKyeFCIiIuJBFEqJiIhUs7w8R6j06KPAihWlbxMaCrRuDbRp41icP7dooYbmUlxwcDDatWtnaxERERFPolBKRESkmuTkAO+9Bzz2mGNonrvevYFzzwXatnUEUA0bOqqiRA4lMDAQycnJthYRERHxJAqlREREqlhmJvDWW8ATTwCbNhW/bOBA4O67HWuFUFIRubm52LZtGyIjIxVMiYiIiEdRKCUiIlIFw/O2b3fMkvf778BTTzlOuxs2zBFG9e2rh1+OTHp6OubMmYNGjRoplBIRERGPolBKRETkf3bsAJYvdzQgL23hTHjOn1n9xNBp69YD17t2lf2QnnyyI4zq3l0Pu1QOVkgNGjTI1iIiIiKeRKGUiIjUe0VFwNNPA3fcAeTnV/7DwWF5Z5wB3HUX0LFjvX+4pZJ5e3sjICDA1iIiIiKeRKGUiIjUa/v2ARdfDHz99ZHvKygIiI8HEhL2rxs1Ak4/3dHAXKQqZGRkYMGCBejduzfCwsL0IIuIiIjHUCglIiL11oIFwGmnAStX7j9v9GhHmOTjwwoUx9q5uJ/mRGcMntxDKOYBalYu1a2goACZmZm2FhEREfEkCqVERKReev994KqrgKwsx2m24/nwQ+DEE2v6yEQOT3h4OI4++mhbi4iIiHgShVIiIlKvZGcD118PvPHG/vO6dgW+/BJo2rQmj0xEREREpH5RR0wRETkiixcDq1bBmoXXdmvWAH37Fg+kLr8c+OcfBVLiufbs2YPffvvN1iIiIiKepNaEUo899hi8vLxwww03uM7bunUrzj//fCQkJCAkJARdu3bFV199Vex6u3fvxrnnnmsl65wK+ZJLLkF6enoN3AMRkfrn3nuBo44CWrQAmjQBLrkE+OQT/v1GrfPjj46KqDlzHKfZE+q994DXX3f8LOKpgoKC0KJFC1uLiIiIeJJaMXxv5syZeP3119GxxDzZo0ePxt69ezFu3DjExsbik08+wZlnnolZs2ahS5cutg0DqS1bttg3hHl5ebjoootw+eWX27YiIlJ1Hn4YeOih/afXrwfeecexUPv2wODBjmXAAPa9qd5/jYwMYMsWR0D2/ffAE0/sv4whGr/jKPGyI+KRAgMD0bRpU1uLiIiIeJIaD6VY1cRg6c0338TD/ITjZsqUKXj11VfRs2dPO3333Xfj2WefxezZsy2UWrJkCX755RcLtbp3727bvPjiixgxYgSeeuopNGzYsEbuk4hIXffUU8A99+w/3asXMG8ekJOz/7yFCx3L8887Zqvjn3IuMTFAdDQQFeVYnD9zzWbjnOHOiUMC2YicBbClLfv2Adu27Q+f3NdlFc2OGgW8+y4QEVGFD5BINeKXcjt37kRUVBQCAgL02IuIiIjHqPFQ6uqrr8YJJ5yA44477oBQqk+fPvj888/tcg7NGzt2LLKzs3Hsscfa5VOnTrXznYEUcT/e3t6YPn06RvGTRylycnJscUpNTbV1YWGhLSKVjc+roqIiPb+kTnj5ZeCWW/YnR08+WYibbnKER1OmABMnemHiRGDWLD73vWwbzlQ/dapjOZSwMC8EBsYhO9sL6elFKCpy7ONI+fgU4bHHinDjjYCXF4+tUnYrUuP4PoZf0MXHxyOGqa+IHJTel4mUn35fpKLKm63UaCj12WefYc6cOfZGqjQMof7zn//YGyxfX18EBwfjm2++sb4Jzp5TDRo0KHYdbhcdHW2XleXRRx/FAw88cMD5O3bssNBLpCp+Ifft22fBFENTEU/10UdBuOWW/SVGt92WhvPOy8D27Y7THTo4Fs5ut2+fF6ZM8cfff/vjr78CsGJF+V5y0tK8kJbmU+FjDA8vRFxcIeLjC9CggfPnQgwenIM2bfKxY0eFdy1SK+Xn56Nz5872hdt25y+jiJRJ78tEyk+/L1JRaWlptTuU2rBhA66//nrrBVVWD4R77rnHekpNmDDBekp9++231lPqr7/+Qgd+6qmgO+64Azfxa323bxgbN26MuLg4a5guUhV/zNnIn88xhVLiqT74ALj11v1VS3fdVYQHHwwBwOVA/M6gZUvgggscp7dsKcTq1ZyggrOFAXv38mcv+7n4eXwRK0REhDdCQ3GQpQghIUB8PJCQACQmOn4ODuatMfwtGQCXfpwideE1xsfHR68xIofxO6P3ZSL6fZGqVd5elzUWSrEvFL/N44x6TgUFBZg8eTJeeuklLFu2zNYLFy7EUZzaCUCnTp0skHr55Zfx2muv2ax8Jb8R5LeFnJGPl5WF/RZK67nAsECBgVQVvvnRc0w81eefO2bWY48nuvlmNjn3sud1eTVq5FjK82Fh+/YdVgl78L/JlTOsT8TTZWRkYPHixdaDMywsrKYPR8Qj6H2ZiH5fpGqVN1upsVBq8ODB+Pfff4udx5nz2rRpg9tuuw2ZmZml3hF+E+gcm9i7d2+rpGLA1a1bNztv4sSJdnkvdt0VEZEj9s03nOl0fw+ma65xzGR3GHmUiFQhfiHH90Nci4iIiHiSGgul+E1ee84X7iYkJMT6R/F8ziTD3lFXXHGFzaTH8zl8j8P9fvjhB9u+bdu2GDZsGC677DKrnOJ1rrnmGpx11lmaeU9EpBL8+CPwn/84GpXTZZc5ZtNTICVSe0RERKBv3762FhEREfEktbbjsp+fH3766SfrjzBy5Eh07NgRH3zwAd5//32MGDHCtd3HH39s1VWsvOL5/fr1wxtvvFGjxy4iUhf89htw2mmcbt5x+vzzgddeYwVrTR+ZiIiIiIjUBTU6+15Jf/75Z7HTLVu2xFdffXXQ63CmvU8++aSKj0xEpO5jv6gNG9jzD+CkqM89B+TkOC5jtdQ77yiQEqmNOHSP7QtYPc73RSIiIiKeolaFUiIiUn0B1KZNjgBq1qz96x07Dtz2lFOADz8EfPWKIVIrcfKW5OTkUidxEREREanN9BFDRKSe4DC8jz4CWIDKAGrbtkNfhxVS77/PIdXVcYQiUhFBQUHWh5NrEREREU+iUEpEpB6EUax0evhhYM2asrfjqJ/u3QFOZso1l+Tk6jxSEakIzrq3Z88eG7rn7++vB1FEREQ8hkIpEZF6GEZFRe0Pn5zrlBTNqifiiVJTUzFt2jSbHCY2NramD0dERESk3BRKiYjUMvn5wIQJwKefAuPGAT4+QP/+wIABjqVjR8d5FQmjhgwB7r0X6NtXAZRIXREREWGzD3MtIiIi4kkUSomI1AKFhcDUqY4gauzYAxuOf/utYyF+7uzXzxFQHXMM0LWro+fTocKo++5zhFEiUrf4+PggLCzM1iIiIiKeRKGUiEgNzoD377/AJ58An30GrFt34Dbh4Y6qqD179p+3bx/w44+OhUJCHGHTihUKo0Tqo8zMTCxduhShoaG2iIiIiHgKhVIiItUsPR148UXg44+BRYsOvDwwEBg5Ejj7bGD4cIB9ixcuBCZNciyTJxevpMrIAMaPL74PVUaJ1B95eXnYvn27rUVEREQ8iUIpEZFqlJYGDB4MzJxZ/HxWQzFIOucc4OSTHRVS7thHisu11zoqrJYu3R9Qcb15s2M7hVEi9Q97SR1zzDHqKSUiIiIeR6GUiEg1ycpyVEC5B1LsDcWKqDPOAOLiyrcfLy+gbVvHcuWVjpCKPaQYbHEGPREREREREU+gUEpEpBpwVA2DJ1Y1UXS0Y4a9Ll2OfN8MqZo1O/L9iIhn2rdvHyZNmoTjjz8eUVFRNX04IiIiIuXmXf5NRUSkIgoKgNGj9zcmZx/iX36pnEBKRMTPzw8JCQm2FhEREfEkCqVERKoQh9ZddZVjdj1nE/Pvvwd69NDDLiKVIzg4GK1bt7a1iIiIiCdRKCUiUoWB1K23Am++6Tjt6wt8+SVw7LF6yEWk8hQUFCAtLc3WIiIiIp5EoZSISBV55BHgqaf293368EPghBP0cItI5feU+vvvv20tIiIi4kkUSomIVIEXXwTuvnv/6ddeA846Sw+1iFS+8PBw9OnTx9YiIiIinkShlIhIJfvgA+C66/affvJJ4PLL9TCLSNXw9fVFRESErUVEREQ8iUIpEZFK9M03wEUX7T99113AzTfrIRaRqpOVlYUVK1bYWkRERMSTKJQSEamkpuZffeUYoldY6Djv2muBhx7SwysiVSsnJwcbN260tYiIiIgnUSglInKEYdQPPwBHHw2cfjqQm+s4f/Ro4LnnHA3ORUSqUmRkJAYOHGhrEREREU+i5gMiUi+lpwPjxztCpYEDgejow7s+q6G++85RCTV3bvHLTjsNePttwFuxv4iIiIiISJn0kUlE6o28PODHH4FzzgEaNHCER6xuiosDevcGHngAmD4dKCgoex+87PPPgU6dgFNPLR5IdewIjB3rWNRvWESqy759+/D333/bWkRERMSTqFJKROo0VkJNmwZ8/LEjTNq5s/SqJ27D5f77gZgY4PjjgWHDHOuEBCA/H/jsM2DMGGDp0uLX79oVuOce4KSTVB0lItXPz88P0dHRthYRERHxJAqlRKROWrbMEURxWb36wMs5XO/MM4HgYODXX4FFi/ZftmsX8OmnjoU6d3YM91u5svg+evUC7r0XGD5cvaNEpOYEBwejXbt2thYRERHxJAqlRKROyM4Gpk4Ffv8d+PlnYM6cA7cJDHRUM517rqMKyt/fcf7TTwMbNjjCqV9+AX77DUhN3X+9efOK76dfP0cYddxxCqNEpOYVFBQgIyPD1t5qZiciIiIeRKGUiHgk9naaPdsRQnH55x9HMFUSP58NGgScdx4wahQQHl76/ho3Bi691LGw9xR7SzGg4sLbIe6Hw/QGDFAYJSK1B3tJTZ48GSNHjkRsbGxNH46IiIhIuSmUEpEasXYt8O23jhnsli8HoqIAfpZi03Gu3RfneQyY/vrLEUL9+Sc/iJW9f/Z5YhB11llAYuLhHRvbsrAaisvDDwM7djiCqoYNj/hui4hUurCwMPTs2dPWIiIiIp5EoZSIVFvD8QULHEEUl5JD4jZvPrL9JycDgwc7loEDKzdAYigmIlJbscF5TEyMGp2LiIiIx1EoJSJVOsSOw+qcQdSaNaVvxyqozEzHUl6cIY/D6ZxBVPPmGlInIvVTdnY2Vq9ejfDwcDU7FxEREY+iUEpEKh1nu3vySeDLL4GdO0vfpkcP4JRTHH2e2rRxBEoMpbh9yYXD57jmDHicCY8hVMeOjuF8IiL1XVZWloVSrVu3ViglIiIiHkWhlIhUGlZCsQfT++87qqSK/bHxBY491hFCcQa8pKQDr8/ZzDkMj4uIiJRPVFQUjjvuOFuLiIiIeBKFUiJSKU3Lx4wB3nsPyM/ff35ICDB8uKMiasQIRzNzEREREREREYVSInJE1q1zhFHvvls8jIqIAG68Ebj+eiAyUg+yiEhVSk1NxdSpUzFw4EBE6o+uiIiIeBBVSonIYVu/fn8YlZe3//zwcEcYdcMNCqNERKqLj48PQkNDbS0iIiLiSRRKiUi57N0L/P03MG6cY5ieexgVFuYIohhIaYieiEj1CgkJQYcOHWwtIiIi4kkUSolIqTjb3eTJjmXSJGD+fKCoqPg2DKM4RI9hVHS0HkgRkZpQWFiI7OxsW3trWlIRERHxIAqlRMRs3lw8hFq8uOwHJjQUuO464KabgJgYPYAiIjVp7969+OOPPzBy5EjExsbqH0NEREQ8hkIpkXqGDclXrADmzXNUPzmXLVvKvo6XF9CpE3DMMcCAAcCgQeoZJSJSW7CfVLdu3WwtIiIi4kkUSonUYTk5wIwZ+4MnBlELFwLZ2Qe/Hnvldu3qCKC49O2rXlEiIrWVv78/GjRoYGsRERERT6JQSqQOYhPyd94BHnzQMSzvUNicnJVQffo4qqG4Zr8oERGp/dhPat26dQgPD0dwcHBNH46IiIhIuSmUEqlDCgqAzz4D7r0XWL269GF4LVo4AqjOnR1rLklJjstERMTzZGVlYenSpWjRooVCKREREfEoCqVE6gDOivf998BddzmG57kbORI44QRH+NS+vaNJuYiI1B1RUVEYOnSorUVEREQ8iUIpkSq2ZAnw1FNeiIgIxYknOobGBQZW3v4nTgTuvBOYPr34+YMHA2PGAL16Vd5tiYiIiIiIiFQWhVIiVWjNGmDgQGDbNo6NC8WzzwIBAY5giudzFrsePdik9vD3zQbmrIyaMKH4+QyhGEYxlBIRkbovLS0NM2bMwIABAxAREVHThyMiIiJSbgqlRKrI7t3AiBEMpA6cEe+PPxwLez+xJ22/fo6Qikt8PLBrl+P6Za23bgVmzy6+Xw7NYxjF4XrqDyUiUn94eXnZzHtci4iIiHiSWhNKPfbYY7jjjjtw/fXX47nnnnOdP3XqVNx1112YPn06fHx80LlzZ/z6668ICgqyy3fv3o1rr70W33//Pby9vXHaaafh+eefR6ga50gNys4GTjkFWLrUcbpNmyJceWUq5s0Lxx9/eGHduv3bZmYC48c7lopo1swxy95ZZwE+PpVz/CIi4jn4nofvj/TeR0RERDxNrQilZs6ciddffx0dO3Ysdj4DqWHDhllY9eKLL8LX1xfz58+38Mnp3HPPxZYtW/Dbb78hLy8PF110ES6//HJ88sknNXBPRIDCQuDCC4G//nI8Gqx8+vHHIgQHZ+Haa8Pg7e1lw/qc1VLsCbV5c8XCqFtuAS65BPDz0yMvIlJfFRUV2XsgrkVEREQ8SY2HUunp6RYsvfnmm3j44YeLXXbjjTfiuuuuw+233+46r3Xr1q6flyxZgl9++cVCre7du9t5DK9GjBiBp556Cg0bNqzGeyLiwKfr5587fubQvB9/BJo0AbZv3/8INW3qWC6+2DFz3ooVjoCKQVZuLhATA0RHF1+7/8wJlnxr/LdXRERqgz179mDChAkYOXIkYmNja/pwRERERMqtxj/WXn311TjhhBNw3HHHFQultm/fbkP2GFj16dMHq1atQps2bTBmzBj0YwOe/1VSRUZGugIp4n5YScXrjho1qtTbzMnJscUpNTXV1oWFhbaIVNQrrwBPPumo5PP2LsJnnxWhSxfHc4vfYJf1/GrRwrFcdln5b0tPVamrDvX7IiLFBQcH2/A9rvV7I6LXGRG9L5PaoLzvSWo0lPrss88wZ84cq3QqafXq1ba+//77reqJb7Y++OADDB48GAsXLkTLli2xdetWNGjQoNj1OMQvOjraLivLo48+igceeOCA83fs2IFsNgMSqYBffw3A9ddHuj3PUtGjR5ZVSPEXct++ffZB2334qYgcSL8vIof/OxMYGIi9e/fqNUaknL8zel8mUv7XGP2+SEVnB67VodSGDRusqTl7QfGNVFmp2hVXXGF9oqhLly74/fff8c4771iwVFHsUXXTTTcVq5Rq3Lgx4uLiEB4eXuH9Sv01YwZw1VVeKCx0zHx0++1FuPnmMABhruczZ0Xic0yhlMjB6fdF5PBkZWVh8+bNSE5Odk0EIyJ6nRGpDHpfJhVVWs5Tq0Kp2bNn2xC9rl27us4rKCjA5MmT8dJLL2HZsmV2Xrt27Ypdr23btli/fr39nJCQYPtwl5+fbzPy8bKyBAQE2FISwwIFBnK4Vq0CTjqJHwocp885BxgzxssamrtjKKXnmEj56PdF5PBCqX///RdNmjRBSEiIHjoRvc6IVCq9L5OKKG+2UmPjiDgMj2+g5s2b51rYG4o9pPhzs2bNrFG5M5xyWr58OVJSUuzn3r17W6k6Ay6niRMnWprbq1evar9PUv/s3AkMH86hn47Txx4LvPMOfwFr+shERKS+iIqKwtChQ20tIiIi4klqrFIqLCwM7du3L3Yev92LiYlxnX/LLbfgvvvuQ6dOnayn1Pvvv4+lS5fiyy+/dFVNDRs2DJdddhlee+01mw75mmuuwVlnnaWZ96TKsTLq5JMdM+cRi/q+/pqVeHrwRUSk+r/B5lpERETEk9T47HsHc8MNN1jj8RtvvNGG5DGcYg+q5s2bu7b5+OOPLYhi5RXfkJ122ml44YUXavS4xfNxQsYtWw6+bNrk2I44WvSnn/htdU0fuYiI1MdGoqwa5+zEERERNX04IiIiIp4ZSv35558HnHf77bfbUhbOtPfJJ59U8ZFJfbBrF/D++8CbbwJLl5b/emzfwUDqf6NKRURERERERMTTQimR6lZUBEyZArz+OjB2LJCTU77rcSKBxESgRQvggQc4M2RVH6mIiEjZLRG6detmaxERERFPolBK6qV9+4CPPgJeew1YuPDAy9knn6NEGTyVXDhUj6Mj1LpDRERqg6KiIpvkhWsRERERT6JQSuoVTtTIIIojPjMzi1/GflAXXghcfjnQpk1NHaGIiMjh2bNnD3799VeMHDkSsbGxevhERETEYyiUEo/FL4QnT3ZUPO3eDeTlHXzJyADWrTtwP336AFdeCZx+OhAUVBP3REREpOI4e3GHDh1sLSIiIuJJFEqJxykoAL77Dnj8cWDGjIrtg203zj8fuOIKoGPHyj5CERGR6hMQEICkpCRbi4iIiHgShVLiMbKzgQ8/BJ56Cli+vHzX8fYG/Pz2L61aAZdcApx9NhAaWtVHLCIiUvVy/5+9+wBvqm6jAH5aVhll77333nvvKUMUFRBFFAFFFJFPFFFBUZzgQFQEJ4qiqOy990b23nuVspvvOf/LbZOQtmnpSnt+z3NJm3mTNjQ5ed/3f/MmTpw4gYwZMyKAK3GIiIiI+AiFUpLgXbwIfPEF8MknwKlTrqexyunll4EGDcKCp5Qpw75mKCUiIpKYBQUFYdOmTciXL59CKREREfEpCqUkwTp6FPj4Y2D8eL7gdj2tUSNgyBCgeXOtgiciIklbpkyZ0LRpU3MoIiIi4ksUSkmCEBJiteStW2etkMfD1autAeU2Vj117gwMHgxUqxafeysiIpJw+Pn5IUWKFOZQRERExJcolJJ4CaD27g0Ln7ht2HBvNZSNc1t79QJefBEoWjSu91ZERMQ32vdq166N9OnTx/fuiIiIiHhNoZTct6VLgUGDgP/+A5Ilsyqa7ENPX58/D1y+HPn1FioEPPIIMGAAkCOHflAiIiKeOBwOM+ychyIiIiK+RKGU3NdqeMOGAR9+yBfE9/dA5s8PVK1qbVWqWFuWLPrhiIiIRCYwMBDVq1c3hyIiIiK+RKGURAtb7nr0AHbscA2W0qUD7tyxWvTCO+Rq1ZUqWcGTHUJlz64fhIiIiIiIiEhSolBKooSDx0eOBN5+2wqZKGVK67gXXrDa80RERCTuXLhwAbNnz0bbtm2RRWXGIiIi4kMUSiXRGVAzZwJ58wKNGwMlSnDlnsgvt327VR3FoeS2ypWByZOBMmVidZdFREQkHKlTp0bJkiXNoYiIiIgvUSiVhOzcCQwZAkyf7np8rlxWOGVvBQu6ns6KqI8+suZH3bhhHceKKH7/6qtAihRxdx9ERETEVUBAAAoUKGAORURERHyJQqkk4PRpYMQIYPz4sJY7ZydOAD/+aG32qnd2QFW0KPDii8CyZWHnL1XKqo7iPCgRERGJX1x57/Tp08iYMaOCKREREfEpCqUSseBg4OOPgXffBa5cCTs+d26rwunqVWDBAqudj1/bDhwAvvnG2pyxxW/QIOCtt9gqEHf3Q0RERMIXFBSE9evXI3fu3AqlRERExKcolEqEWA31/fdWe92xY2HHp01rte8xWOLXNHgwP2EF1q61AipuK1ZYxzlj9dR33wH168ftfREREZGIsUKqUaNG5lBERETElyiUSmTmzrWCps2bw47z9weeegp44w0gZ857L8PV8+rUsbbXXgOuXbOCKQZUK1cCFSta7X+BgXF6V0RERMQL/v7+pkKKhyIiIiK+RKFUIrFjh1UBNWuW6/Ft2wKjRwOlS3t/XWzNa9LE2kRERCRhu3r1KrZu3YqaNWsiUJ8giYiIiA9RKJWIhpk7B1KVKwNjxgCNGsXnXomIiEhsu3PnjpkrxUMRERERX6I670SiQQOgXTsgf35rnhRnRCmQEhERSfzSp0+PWrVqmUMRERERX6JKqURkwgS+MNXKeCIiIiIiIiKS8KlSKhHJkUOBlIiISFJz4cIFzJs3zxyKiIiI+BKFUiIiIiI+LHXq1ChcuLA5FBEREfElCqVEREREfFhAQIAJpXgoIiIi4ksUSomIiIj4sFu3buHcuXPmUERERMSXKJQSERER8WFXrlzBmjVrzKGIiIiIL1EoJSIiIuLDMmTIgPr165tDEREREV+iUEpERETEhyVLlgxp06Y1hyIiIiK+RKGUiIiIiA8LDg7Gf//9Zw5FREREfIlCKREREREfxgHn58+f16BzERER8TkKpURERER8GGdJ1a1bVzOlRERExOcolBIRERERERERkTiXPO5vMuFxOBzm8PLly/G9K5JIhYSEmKW6AwIC4O+vLFhEzxeRmMPWvfnz56NJkybInDmzHloRvS4TiTF6HyPRZecrdt4SHoVSgAkLKF++fNF+wEVERERERERExDVv4aiB8Pg5Ioutkkj6e/z4cQQGBsLPzy++d0cSaUrM0PPIkSNInz59fO+OSIKm54uInjMi+jsjkjDodZlEF6MmBlK5c+eOsFtIlVIcrOXvj7x580b7wRbxFgMphVIier6IxAb9jRHRc0YktuhvjERHRBVSNg23ERERERERERGROKdQSkRERERERERE4pxCKZE4kCpVKgwfPtwcioieLyL6GyMSf/S6TETPF0k4NOhcRERERERERETinCqlREREREREREQkzimUEhERERERERGROKdQSkRERERERERE4pxCKZEY8O6778LPzw8DBw50OX7lypVo3Lgx0qZNi/Tp06N+/fq4du1a6Onnz5/Ho48+ak7LmDEjnnzySQQFBelnIknyOXPy5El0794dOXPmNM+ZypUr4/fff3e5nJ4zklS88cYb5jnivJUsWTL09OvXr6Nfv37IkiUL0qVLh86dO+PUqVMu13H48GG0adMGadKkQfbs2TF48GDcvn07Hu6NSPw+Z/i3Y8CAAShRogRSp06N/Pnz47nnnsOlS5dcrkPPGUkqIvsbY3M4HGjVqpU5/c8//3Q5Tc8XiSnJY+yaRJKotWvXYvz48Shfvvw9gVTLli0xdOhQjB07FsmTJ8fmzZvh7x+WBTOQOnHiBObOnYtbt26hV69e6NOnD3766ad4uCci8fuc6dGjBy5evIjp06cja9as5nnQtWtXrFu3DpUqVTLn0XNGkpIyZcpg3rx5od/z74jthRdewL///ovffvsNGTJkQP/+/dGpUycsX77cnH7nzh0TSDHkXbFihflbw+dYihQpMGrUqHi5PyLx9Zw5fvy42caMGYPSpUvj0KFDeOaZZ8xxU6dONefRc0aSmoj+xtg+/vhjE0i50/NFYpRDRKLtypUrjmLFijnmzp3raNCggeP5558PPa1GjRqOYcOGhXvZ//77z8Gn4Nq1a0OPmzlzpsPPz89x7Ngx/VQkyT1n0qZN65g8ebLL+TNnzuyYMGGC+VrPGUlKhg8f7qhQoYLH0y5evOhIkSKF47fffgs9bseOHeZvysqVK833M2bMcPj7+ztOnjwZep4vvvjCkT59eseNGzfi4B6IJJznjCe//vqrI2XKlI5bt26Z7/WckaTEm+fLxo0bHXny5HGcOHHC/H2ZNm1a6Gl6vkhMUvueyH1g6wQ/iW7atKnL8adPn8bq1atNu0Tt2rWRI0cONGjQAMuWLXOppGLLXtWqVUOP4/WwkoqXFUlKzxnic2XKlCmmzSIkJAS//PKLaVFq2LChOV3PGUlq9uzZg9y5c6Nw4cKmSpCtErR+/XpTXev8PGLbBVuS+DwhHpYrV878/bG1aNECly9fxvbt2+Ph3ojE33PGE7bucXyCXR2i54wkNRE9X4KDg/HII4/gs88+MxW37vR8kZik9j2RaOIb5g0bNphWJHf79+8P7ddmqXjFihUxefJkNGnSBNu2bUOxYsXM/ByGVi5PyOTJkTlzZnOaSFJ6ztCvv/6Khx56yMzI4XOBc3CmTZuGokWLmtP1nJGkpEaNGvjuu+/MDBy23o0YMQL16tUzf0P4XEiZMqX5YMMZAyj77wcPnQMp+3T7NJGk9JwJDAx0Oe/Zs2fx1ltvmZEJNj1nJCmJ7PnCFnF+WNihQwePl9fzRWKSQimRaDhy5Aief/55MwsqICDgntNZ5UFPP/20mRNFnIkzf/58fPvtt3jnnXf0uEuSEtlzhl577TUzU4rzDThTigM1OVNq6dKlpuJDJCnhYFkb56/xDUSBAgVMeMtBzSLi/XOGC8nYWC3Iil3OluKHhyJJUUTPl2zZsmHBggXYuHFjvO6jJB1q3xOJBrZOsEWPq4OxooPb4sWL8emnn5qv7U+j+YLHWalSpUJLY1kKy+twxlWR2LrkqUxWJDE/Z/bt24dx48aZ0JYVhRUqVMDw4cNNeytLx0nPGUnKWBVVvHhx7N271zwXbt68aUJcZ1x9z/77wUP31fjs7/U3RpLac8Z25coVswgNK0FYicvB/zY9ZyQpc36+MJDi6zIeZ79mI67yao9U0PNFYpJCKZFo4JvmrVu3YtOmTaEb3zyzH5tfszebPdq7du1yudzu3bvNpxBUq1Yt84aCb9Zt/CPAKit+WiGSlJ4znF1AzqtTUrJkyUIrD/WckaQsKCjIvEnIlSsXqlSpYt5Ms/rWxr83/NCDzxPiIZ9zzh9+sFKRM3TcPzARSezPGbtCqnnz5qb1lau8ulft6jkjSZnz8+WVV17Bli1bXF6z0UcffYSJEyear/V8kRgVo2PTRZIw95XEPvroI7PKEVdH2rNnj1mJLyAgwLF3797Q87Rs2dJRqVIlx+rVqx3Lli0zq5J169Ytnu6BSPw9Z27evOkoWrSoo169eub5wOfJmDFjzGqU//77b+hl9JyRpOLFF190LFq0yHHgwAHH8uXLHU2bNnVkzZrVcfr0aXP6M88848ifP79jwYIFjnXr1jlq1aplNtvt27cdZcuWdTRv3tyxadMmx6xZsxzZsmVzDB06NB7vlUj8PGcuXbpkVkUuV66c+fvC1cTsjc8V0nNGkpLI/sa4c199T88XiUmaKSUSSwYOHGhWDuOgQLbksR2Jn1IXKVIk9Dw//vgj+vfvb6pIWCHCsli2M4kkNaz6mDFjhvl0rl27duYTOw44nzRpElq3bh16Pj1nJKk4evQounXrhnPnzpn5HnXr1sWqVavM1/Yn1vbfjRs3bpiV9T7//HOXKsN//vkHffv2NZ9op02bFj179sSbb74Zj/dKJH6eM4sWLQpd2dhePMN24MABFCxYUM8ZSVIi+xsTGf2NkZjkx2QqRq9RREREREREREQkEpopJSIiIiIiIiIicU6hlIiIiIiIiIiIxDmFUiIiIiIiIiIiEucUSomIiIiIiIiISJxTKCUiIiIiIiIiInFOoZSIiIiIiIiIiMQ5hVIiIiIiIiIiIhLnFEqJiIiIiIiIiEicUyglIiIikoA8/vjjeOCBB+J7N0RERERiXfLYvwkRERERIT8/vwgfiOHDh+OTTz6Bw+HQAyYiIiKJnkIpERERkThy4sSJ0K+nTJmC119/Hbt27Qo9Ll26dGYTERERSQrUviciIiISR3LmzBm6ZciQwVROOR/HQMq9fa9hw4YYMGAABg4ciEyZMiFHjhyYMGECrl69il69eiEwMBBFixbFzJkzXW5r27ZtaNWqlblOXqZ79+44e/asftYiIiKSYCiUEhEREUngJk2ahKxZs2LNmjUmoOrbty8efPBB1K5dGxs2bEDz5s1N6BQcHGzOf/HiRTRu3BiVKlXCunXrMGvWLJw6dQpdu3aN77siIiIiEkqhlIiIiEgCV6FCBQwbNgzFihXD0KFDERAQYEKqp556yhzHNsBz585hy5Yt5vzjxo0zgdSoUaNQsmRJ8/W3336LhQsXYvfu3fF9d0REREQMzZQSERERSeDKly8f+nWyZMmQJUsWlCtXLvQ4tufR6dOnzeHmzZtNAOVpPtW+fftQvHjxONlvERERkYgolBIRERFJ4FKkSOHyPWdROR9nr+oXEhJiDoOCgtCuXTuMHj36nuvKlStXrO+viIiIiDcUSomIiIgkMpUrV8bvv/+OggULInlyvdwTERGRhEkzpUREREQSmX79+uH8+fPo1q0b1q5da1r2Zs+ebVbru3PnTnzvnoiIiIihUEpEREQkkcmdOzeWL19uAiiuzMf5UwMHDkTGjBnh76+XfyIiIpIw+DkcDkd874SIiIiIiIiIiCQt+qhMRERERERERETinEIpERERERERERGJcwqlREREREREREQkzimUEhERERERERGROKdQSkRERERERERE4pxCKRERERERERERiXMKpUREREREREREJM4plBIRERERERERkTinUEpEREREREREROKcQikREREREREREYlzCqVERERERERERCTOKZQSEREREREREZE4p1BKRERERERERETinEIpERERERERERGJcwqlREREREREREQkzimUEhERERERERGROKdQSkRERERERERE4pxCKREREfHIz88P/fv316OTBBQsWBCPP/546PeLFi0yP38eioiIiMQWhVIiIiJJzL59+/D000+jcOHCCAgIQPr06VGnTh188sknuHbtGpKKtWvXmtCtTJkySJs2LfLnz4+uXbti9+7dUbqe5cuXo2PHjsiRIwdSpUplAp5nnnkGR44cQUKyYsUKvPHGG7h48WKc3/bBgwdNyOVpq1mzJhK7+HzsRUREErLk8b0DIiIiEnf+/fdfPPjggyY86dGjB8qWLYubN29i2bJlGDx4MLZv346vvvoqSfxIRo8ebQIlPh7ly5fHyZMnMW7cOFSuXBmrVq0yj01kxo4di+eff94EfAMGDECuXLmwY8cOfP3115gyZQpmzpyZYEIXBiMjRowwFVEZM2Z0OW3Xrl3w94/9zyq7deuG1q1buxyXLVs2JHYRPfYiIiJJmUIpERGRJOLAgQN4+OGHUaBAASxYsMAEKLZ+/fph7969JrSKCVevXjXVRwnZoEGD8NNPPyFlypShxz300EMoV64c3n33Xfzwww8RXp6B1sCBA1G3bl3MmjULadKkCT2tb9++pvqsc+fOJuhL6EEEQ8q4wMDvsccei/HrvX79uvk5xkWwJiIiIjFHf7lFRESSiPfeew9BQUH45ptvXAIpW9GiRU3Vj7s///zTVA0xuGCrGwMYZ2xLYhvWf//9h0ceeQSZMmUyQQ3dvn0bb731FooUKRLa2va///0PN27ccLkOHt+2bVtTsVW9enXTVsjqo8mTJ9+zP/v37zfVTZkzZzZBECuRPIVprGLi/vI83KeqVauaEMpWu3Ztl0CKihUrZi7DaqfI8H7xfk+aNMklkCLeXz7ex48fd6k8a9iwodncsYKGj4GzMWPGmH3MkiULUqdOjSpVqmDq1Knhzv6K6OfEnxEr4ahQoUKhrXNsq/M0Uyo8q1evRsuWLZEhQwZznxs0aGDCuZjizc/Wnnf1yy+/YNiwYciTJ4857+XLl6O0j8eOHcOTTz6J3Llzm8eMjwvDRFYO0vnz5/HSSy+ZkDJdunSmzbVVq1bYvHlzlH7XInvsRUREkjJVSomIiCQRf//9twl6GHR4iyHRH3/8gWeffRaBgYH49NNPTfXP4cOHTVjijGECQ51Ro0bB4XCY43r37m1Cmy5duuDFF180gcE777xjQp9p06a5XJ6VWjwfg4KePXvi22+/NUEJwxi+4adTp06Z/Q8ODsZzzz1n9oHX3759exPYcLYTTZgwwZzO62PQxkqaLVu2mNtncBYe7jdvw7698PD258+fj3r16pmgwRNWXfXp08c87i+//DKiijO+eL8effRRE5QwhOFj/M8//6BNmzZR+jl16tTJzMr6+eef8dFHHyFr1qxRbp1jdR1DGf48hg8fbqqSJk6ciMaNG2Pp0qUmTIwMH7ezZ8+6HMfwKEWKFF7/bJ1DQYaKDI4YcvJrb/eRYSG/5own/oxKlixpQireDm+f18WAjEEfH3P+jLl/48ePNyEXA1iGWd78rsXEYy8iIpJoOURERCTRu3TpElMiR4cOHby+DM+fMmVKx969e0OP27x5szl+7NixoccNHz7cHNetWzeXy2/atMkc37t3b5fjX3rpJXP8ggULQo8rUKCAOW7JkiWhx50+fdqRKlUqx4svvhh63MCBA835li5dGnrclStXHIUKFXIULFjQcefOHXMc72eZMmUcUfX999+b6//mm28iPJ99355//vkIz1e+fHlH5syZQ79v0KCB2dz17NnTPAbOgoODXb6/efOmo2zZso7GjRtH6+f0/vvvm+MOHDhwz+3ztrkPtoULF5rz8pBCQkIcxYoVc7Ro0cJ87byPfOybNWsW4ePA2+T1edrs2/D2Z2vvW+HChV0eo6jsY48ePRz+/v6OtWvX3rOv9mWvX78eepvO94O/k2+++Wbocd78rkX02IuIiCRlat8TERFJAuzWJlbRREXTpk1NK5qNA8HZxsQqEndccc7ZjBkzQmc3OWPFFLm3ZZUuXdpUHtlYSVKiRAmX2+J1ssLFbg8ktlax2oXtUKxgIc5wOnr0qFlhz1s7d+40s7Vq1aplKrUicuXKFa8eT55unzeq2LJnu3DhAi5dumQenw0bNtzXzyk6Nm3ahD179pjKn3PnzplqJ26cHdakSRMsWbIEISEhkV4Pf05z58512SpUqBCln62NPyPnx8jbfeTGCqh27dqZNjt3bK0jtvTZM6ru3LljrpP7w99J559BdH7XRERExKL2PRERkSSAAQVFNSDJnz//PcdxZg5DEnfubWyHDh0yb+o5q8pZzpw5zRt5nh7V2+JlatSocc/5SpUqFXo65yoNGTIE8+bNMyEHb7958+YmrODwcU+48h5b4thKxhauZMmSISJ2GBXZ48nTs2fPjuhgm97bb79twhbnGVx2aBLdn1N0MOyhiMI6hma8zYiwvZMBmife/mzD+33zdh/ZCsmQNrLVFRlesYXy888/N4sEMJiyObeuRvV3TURERMIolBIREUkioRRn4Gzbti1KlwsvnLFnRjlzrlpx5ilEud/bigyDjF27dplghwO/f//9dxMuvP766xgxYsQ9QQXnEHG+EOcO2bOCIgtXkidPbmYHhYdBEvfBedYSHwtP98c58CDuB2cp1a9f3+w3B9Nz7hLnIzkPa4+Nx84Tuwrq/fffR8WKFT2eh1VEccn9983bfeQAc29wNtprr72GJ554wsyv4vB1hqxccdG5Kiwqv2siIiLiSqGUiIhIEsHV7bgS3MqVK02LWmwrUKCAefPOCha72oU4MJoBEE+PznUyAPDUemefbkubNq0ZNs6N1TEcOD1y5EgMHTrUrO5HHErNNi4Ooma1C1sIvcFV1tgSxsuwgsfTffn1119NMMVB2TZWEnlqqXOvGmOwwX2cPXu2aSOzMZSKLm/DQU/s1kCGm+FVOt2vqPxs72cf2RbK80QW0LJirlGjRma1Smf83bWHlXv7u3Y/j72IiEhipplSIiIiSQRXgOObZ66Ix2DI3b59+0y7Ukxp3bq1Ofz4449djv/www/NofsKct5e55o1a0ywZuPMIIZtBQsWDA2VOP/HGVdT42msHLp161ZodRJDBF7Xb7/9FuWgbtiwYeb6uELgtWvXXE5juxcf73z58qF79+4uwQlDljNnzoQet3nzZixfvvyeyicGGc4VVJyrxFlI0cWfvR2qRBVXs+O+jxkzBkFBQfec7nx/osvbn+397iOrnR544AGzKuK6devCrS7jz8C90oy/J1ylz5k3v2v389iLiIgkZqqUEhERSSL4hp2tXwxiWLnUo0cPM1eHlR0rVqwwb7gZsMQUDrDmfB+GCnwz3qBBAxM6TJo0yYQCrEKJqldeeQU///yzabd77rnnTEsVr48hEKuL7MHUnOvD2VWc65MjRw7s2LED48aNM0GYPQ+KA9enT59uKqXY0vXDDz+43NZjjz0W4b5wIPdHH31k2rk4WJyPHdvsGDpNmDDB7AtDJM7PsrEVjKFcixYt8OSTT+L06dP48ssvUaZMmdBh9MT95Platmxp5hPxfJ999pmZWRRRy2BkoQ29+uqrePjhh007IO+7HZhEhPfl66+/No8797VXr17IkyePCWgWLlxoKo8Y8twPb3+2MbGPbM2bM2eO+Z3kIHU+H06cOGGeA8uWLTM/M1YWvvnmm+Z6ateuja1bt+LHH39E4cKFXW7Xm9+1+3nsRUREErX4Xv5PRERE4tbu3bsdTz31lKNgwYKOlClTOgIDAx116tRxjB071nH9+vXQ8/FlQr9+/e65fIECBRw9e/YM/X748OHmvGfOnLnnvLdu3XKMGDHCUahQIUeKFCkc+fLlcwwdOtTlduzrbNOmzT2Xb9Cggdmc7du3z9GlSxdHxowZHQEBAY7q1as7/vnnH5fzjB8/3lG/fn1HlixZHKlSpXIUKVLEMXjwYMelS5dcrpv7Hd7mraVLlzo6dOjgyJo1q8PPz89cNnv27I4TJ054PP8PP/zgKFy4sHnsK1as6Jg9e7Z5PPkYOPvmm28cxYoVM/tfsmRJx8SJE0Mfa2fe/pzorbfecuTJk8fh7+9vLnfgwAGP5124cKE5nYfONm7c6OjUqVPo48rLde3a1TF//vwIHyPeDq/v/fffj/B83vxs7X377bffPF6Ht/t46NAhR48ePRzZsmUz5+PPhI/jjRs3zOn8HX3xxRcduXLlcqROndo8R1auXHnP76Q3v2sRPfYiIiJJmR//ie9gTERERCSx4FBsDrlmVQxXzxMRERERz9S+JyIiIhKDuGLb8ePHzaDr/Pnzm/YwEREREbmXKqVERERERERERCTOafU9ERERERERERGJcwqlREREREREREQkzimUEhERERERERGROKdQSkRERERERERE4pxW3wMQEhJiVskJDAyEn59f3P8UREREREREREQSCYfDgStXriB37tzw9w+/HkqhFGACqXz58sXlz0dEREREREREJFE7cuQI8ubNG+7pCqUAUyFlP1jp06ePu5+OJKlqvDNnziBbtmwRpsQioueLSFRdunQJy5cvR506dZAhQwY9gCJ6XSYSY/Q+RqLr8uXLpvjHzlvCo1AKCG3ZYyClUEpi6z/z69evm98vhVIier6IxLSMGTOaQEqvY0T0ukwkJul9jNyvyEYkqWRDRERExIelS5cOFStWNIciIiIivkShlIiIiIiPDxK9deuWORQRERHxJQqlRERERHzYhQsXMG/ePHMoIiIi4ks0UyoKvbQ3b96M3Z+GJOrfH36KzblS0Z0plTJlSs2jEhGRe6h9T0RERHyVQikvMIw6cOCACRZEooMtFfz9uXLlSqSD3sLDMKtQoUImnBIREbHx70KuXLn090FERER8jkIpL8KEEydOIFmyZGY5Q62cJtH9Pbp9+zaSJ08erVCKgdbx48fN72L+/PmjHWyJiEjic+PGDRw9etSsvpc6der43h0RERERrymUigSDhODgYOTOnRtp0qTx/pEVicFQirJly2aCKV5PihQp9PiKiIhx9epVbN26FQULFlQoJSIiIj5Fg84jcefOHXOolimJb/bvoP07KSIiQpkyZUKLFi3MoYiIiIgvUSjlJbVLSXzT76CIiIT394HjBfR3QkRERHyNQikRERERH8ZFNNavX28ORURERHyJZkqJ1zirYuDAgWbzxqJFi9CoUSNcuHABGTNm1CMtIiIiIiIiSdJHH32EefPmha7M7rw5nI5744030KRJEyQVCqUSocjK94cPH25+0aNq7dq1SJs2rdfnr127tlktjqsBxSY7/LLve2BgIAoXLoxmzZrhhRdeMMtkRwWvY9q0aXjggQdiaY9FRERiDv/uValSxRyKiIhIwrRlyxbMmDEj0vOdPnmSK2XxjSmSArXvJUIMguzt448/Rvr06V2Oe+mll+5ZFc7b1d+isgIhB3PnzJkzzmZc7Nq1y6xOx/BsyJAhJoUuW7asWZFIREQksbI/XeWhiIiIxB8uSvXHH3+gS5cuuHXrlstp3r4vDtmxAzh1CkmFQqlEiEGQvbFKib/89vc7d+40n6TOnDnTfKqaKlUqLFu2DPv27UOHDh2QI0cOpEuXDtWqVTOhjnv7HkMuG6/366+/RseOHU1YVaxYMUyfPt2lgonnuXjxovn+u+++M218s2fPRqlSpczttGzZ0gRlNgZkzz33nDlflixZTLjUs2dPr6qWsmfPbu5j8eLF8fDDD2P58uUmSOvbt2/oeRhYsYIqa9as5rFp0KABNmzY4HIfifeJ+25/783jIyIiEh/YJs+/rTwUERGRuBcUFISxY8ea96KdO3fG77//bjZnn3zyCc6ePYvz58+b98iXz59H0MGDuLpxI67Nno0bU6fi1u+/o1uFCnxjnGR+jAqlkqhXXnkF7777Lnbs2IHy5cubJ1Hr1q0xf/58bNy40YRF7dq1w+HDhyO8nhEjRqBr166mFJGXf/TRR82TLDzBwcEYM2YMvv/+eyxZssRcv3Pl1ujRo/Hjjz9i4sSJJlS6fPky/vzzz2jdx9SpU+OZZ54x13P69GlzHIfAMuRiELdq1SoTpHG/7eGwDK2It8+wzP4+uo+PiIhIbGNrfbly5aLUYi8iIiLRx+rkq1evYs+ePaaQIl++fKa4Yv/+/aHn+fvvv10uw+KQLBkzIlNICDKcPo3ALVuQdvNmpDl4EAH+/kiZNy+SFygA/5Qpk9SPRjOloqFqVYBtnnEtZ05g3bqYua4333zTVAzZMmfOjApMZO966623zFwlVj71798/3Ot5/PHH0a1bN/P1qFGj8Omnn2LNmjUmtPGEJYxffvklihQpYr7ndXNfbEyXhw4daiqVaNy4cV713YanZMmS5vDgwYOmkqpx48Yup3/11VemKmvx4sVo27atqawiHseqKxsfm+g8PiIiIrGNVc958+Y1hyIiInJ/zpw5Ywoljh07Ziqa3n77bdMxY5swYQKeffbZcMfgNG/eHIMGDTKHoYKDgePHgWPHgMuX2efHT5UAXm/ypB3LJO17H00MpPi75MuqMllzwkogDj//999/TYUQn2DXrl2LtBKIVVY2fkLL+VV2VZInbPOzAyniEHL7/JcuXcKpU6dQvXr10NOTJUtm2gw5KyM67Pkadv8ur3/YsGGmtZC3y55fVm9Fdj+j+/iIiIjEtps3b5q/TfxAJSAgQA+4iIhINE2dOtWMf2Gbna1fv34uoRT/1roHUpynzK4hLrTF6uVQ165Z4cHBg1YYlS4dhzUDKVK43vDt2xySDHC0zIoVQPv2wLBhSeLnqFAqGpwKaHz2dt1L/NlCN3fuXNNaV7RoUdP6xuFsfKEbkRRuTyaGPxEFSJ7OH5uDWdmeSPZsKLbunTt3zvTzFihQwHyqXKtWrUjvZ3QfHxERkdjGD042bdpkWgcUSomIiEQd3yMyfJoyZco9p9kzkm158uRBpUqVzIdBnFPMr/v06ePSaYMbN6ww6sABVl8AXJE+f/6wFfU4BH37dmDjRiuI2rzZqqayMbxSKCXhiakWuoSEc5fYime3zfEFLlve4hKf0EygOcepfv365jhWMnEQecWKFaN8faxkYnser8tuy+P9/Pzzz818KDpy5IhLCm4HZ7zdhPb4iIiIeJIpUyY0bdrUHIqIiEjU/PXXX3j66adNV42N7/uef/55M+bGudOHOBLGebEsFyxa4EJenC3FBUjSp7fCKB6/fn1YCLVlixVchWfPHrb9hIVYiZgqpcTgwG8uXcnh3axeeu2116LdMnc/BgwYgHfeecdUI3EeFGdMcTUhb5bPZDve9evXzdDy9evX47333jOBE++X8/3kkHW2L3KI+uDBg03VkzNWVXGgeZ06dUwlFV/kJ5THR0RExB3/LvEDFW+XmhYRERFr9VoGT3x/aON7v88++8ys5h6lv6usfOKcH4ZR585xqjmQL581R+q77wCuUn93cS2PMmUCChQAsmZlfyAwcGCSCKRIoZQYH374IZ544gnUrl0bWbNmNSsIMLSJa7zdkydPokePHmaeFMsgW7RoYb6OTIkSJcx/HOnSpUPhwoVDB8w5l1F+88035jorV65s2hw4nN159T/64IMPzOU4wI6lmayISiiPj4iISHjte/wbxdmOIiIiErlt27a5BFJc+IqdNrkyZwZ277ZCJo6f4cYV8eyN702dNwZSbNNjB06aNOzvs9qr2Aq4bJlV8eSO71HZDVSwoHUZdupw4DlDKc6WSiKBFPk5YnOgj49guMDWMQ7adn8xx8qbAwcOoFChQprTEA9YjVSqVCl07drVrHjnq/g04zC85MmTR/uTbP0uSlJ63rPykStm+vv7x/fuiCR4fP3CVWQbNGhgXs+ISMT0d0bEe4n9+TJw4EB89913ZuZwj+7d4cdFuNg6x0NmA4xLGBixS4aH/N49QuFpDJYYWM2cCfz2G3DokOt5eBpXgq9ZEyhVyrou3s7581ZlFIMwe/4yW/u6d7fOn0hzFmeqlJIE5dChQ5gzZ455YX3jxg2MGzfOhIKPPPJIfO+aiIhIghQYGGhWruWhiIhIYsPFpWKiTX3NmjVmjItzuGZ3zuRl+9y2bVaYxOonzoGKLIS7ft0aZs4h5ayIWr363jlRrHxq08ba+MER503xdjj8nMPM8+a1bi8JUyglCQr/g2BSzf8YWF1UtmxZzJs3z1RLiYiIiIiISOJ09OhRLFmyxKUggQtQde7c2YxV4bxh99XcvcHrYNfNm2++aSqiOMfYliZVKqRhpdOqVVZQlCOHVbkUEc6GOnIEWLoUmDPn3qooYgtfhQoAh6Rzn9essUIuBln2SnyJsPIsOhRKSYLCOU9c6U5ERES8H9Q6e/ZsMwsjS5YsethERMSnXLx4EaNHj8bHH39sRp5Uq1bNLDRFr776Kv755x/z9c6dOzF16lQz49dbbD189NFHTaEDcTZw+/btUYBDxS9etFrojh61qpYYFIVXjcWWPQ4wZwDFyiheH+dOOWP4VKUKULcukDt32PF26x8P2caXhOZFeUOhlIiIiIgP4yqyXLHWfTVZERGRhIzjWj7//HO8/fbbOM/ZSnexqmny5Mnm6zJlyiBlypSmhY/zE9mu/vfff5vjI7N06VI89NBDOMGWubtdOVxFPR+rofbutTa22+XKFTbPyR3DJA48P3gQ2LfPatNjKMXjbZwHxSCqenVrtpQ7VkSpKipcCqVEREREfFhAQID5xJeHIiIivjA8/aeffsKwYcPMTGEbw6d+/fqZ6ihb9+7dTdXUAw88gFOnTpl5wzVr1sTPP/9sKoTDu/4xY8bgf//7n2ndI67Izss0LF0aWL8eOHXKCpOyZfO8kzdvWvOi9u8PmxvFFrxr18LOkzYt0Lw5ULt2kp8LdT8USomIiIj4MH56zPaEjBkzKpgSEZEEbf369ejduzc2bdrkcjxb7FgxVbBgwXsuwxBq7dq1JpjasGEDgoKCTAveu+++i8GDB7sMQGfFVc+ePUNb/qhx48b46dtvkePqVWDtWuvI8AaM37plzYtiax5X4DtwAOB4GadKLiRPDjRoYK2Opyrl+6ZQSkRERMSH8cU5X+Tnzp1boZSIiCRYc+fONdVN/DDF1rx5cxMuVapUKdLZw2zH69WrF3799VezKBbnQ23btg1fffWV+fu3fft2tG7dGocPHzaXYVg17NVXMbxvXyRj692ZM1ZllKcWu9u3rdlSDKNYRcVAiq16DKhsDL+qVgVatgS4Wl9scDiQ1CiUEhEREfFhrJBq1KiRORQREUmoatWqhcKFC5uB5RUqVDAtdk2bNvX68mnSpMEvv/xiVmh//fXXzXHff/+9qa7iynq5cuUKrZriMPQfvv0WLQoXttr1WBWVL1/YbCe29dmVUNu3W9vx49YKfNwYUjkrXhxo185aVe9+8Hq5sSLLeQsJCTtPqlRJqh1QoZSIiIiID+PgVn5CzEMREZGEKl26dPjtt98wadIkjBw50syQugfDIm4MbnjIyiFWNrFl7m71E4eVly5dGj169ECJEiVMxRRlzpzZVFG98sormDxmDPJeuQLs2gVkz84BjMDs2cCcOVb1E6uiGAZFhkPQObuqZMnorZrH+xEUZG0Mnhg2cag6N97/TJmslf84n4phFDeu8sfVAZOIeA2l3njjDYwYMcLlOP5SMTl1xtI8luHNmjUL06ZNM72kNpbm9e3bFwsXLjS/5Owffeedd5D87i+tiIiISGJ29epVbN261czcCAwMjO/dERERMe/hv/nmGzRp0gSFChWyHpE7d1A2f368/8ILVjDEUIir37Gdz64YYojD8IabHUpxbhOHknNjgBMYiM6dO5uqK1ZEpWWgc1f1cuUw/+OP4cfV8hj8sDqKLXnvv28NK48Mc4QsWaw2v3LlgCpVor5yHu8TAzHOsGIIxX0uVswKx7ivDKMYPvHQz0PQxfuehPKMeL+nXMpx3rx5od97CpM+5i+Vhx8WJ+m3adPGTNJfsWKFWeqRaWmKFCkwatQoJFWeHitnw4cPN4FgdK/bPRiMbB9YZsk5F3Xq1MGAAQNQhU/sKGjYsCEqVqxofg9ERETk3tdDnCtlrzAkIiISE65cuWKqklauXGnek7Vo0cK0i0f2fpN/k55++mmzwl61SpWw7NdfkZIBDYeFBwdbIRSvg2EPQxv70P6amQA3OwziinesbGKrHY9n5VSmTKjEkIpfMwRiwHPihAmg/C5csAKg69eB0aOBP/5wndXE68iQAciRwzofA6isWa2Nx0c1hOJ1834xiLL3hdfDIIrXzWoohlCSMEMphlAMlcLDqfwffPAB1q1bZ3pEnc2ZMwf//fefCbVy5Mhhgou33nrLlO8xdPFYDpgEMJyzTZkyxfTb7mLZ4l2sKIsLEydORMuWLXH9+nXs3r3bDKCrUaMGvv32WxMeioiIyP1Lnz69mdPBQxERkZiwZMkSPP744zjAIAjAmjVrzIp2HCYebjBz7Rq2rl2LB594Arv27zdHr924EX9PmIDO9eqFVTx5+z6dFUOsnmLAw41YScUAiO95OdCc4RarjxhOnT1rXTdzgz//BD7/3AqKbJy9yBlWHKp+P6vm8UMgBmXcGHzZ1VwMuHLntiqteFtJaC7U/Yj34QN79uwxVTQsveMykPakfAoODsYjjzyCzz77zGNwxcS2XLlyJpCyMb29fPly+E+WJICPlb1lyJDBJNnOx3E4XKlSpcz8iZIlS+JzPlnv4koI/fv3NwEgTy9QoIBphyR7ec6OHTua6/S0XKczDlzl7fF8XFVh6tSp5mfM67/A9Bpslz2Hbt26IU+ePKaiij/Pn3/+OfQ6+B/h4sWL8cknn5jb5Hbw4EHzafCTTz5pSkFTp05t2j55HhEREREREYkeFhS8+OKLpjLKDqRsfE8XihVB58+jRYMGeLJTJ0wZMQLjX3kF1Zs3Dw2kAtOkwa8jR6Jz165WUMSgxptAikHPhAlsmQHq1wdY0MCumcWLrZY4fgjDfICtebxetukxfGIYdOgQ8OijVoWUHUjx9GbNgFdeAWrXjnogxft68aI1CJ3Xz0PuI1vmy5YFGLjxsWnQwBqIzv1QIOUblVKsmvnuu+9MoMDqHs6XqlevnlnWkTMRXnjhBdSuXRsdOnTwePmTJ0+6BFJkf8/TwnPjxg2z2RhiUUhIiNmc8Xv2w9qbr7H32T788ccfTeXU2LFjzbKbGzduRJ8+fUwgxHlcDHamT59uKqzy58+PI0eOmI2XZzrOx5eVTqyASpYsWYSPiafHbODAgZg8ebKpcuvatSuuXbuGypUr4+WXXzaf8P7777/o3r27CSmrV69uWvZYZcU2T66oQNmyZTOhFIMsDrLLkiWLad9kiShDMF6vL/wsonN5bp5+T0USE/v/Xf2ei3jn/Pnzpmqcf5s55FVE9HdGJDrWr19vigLYjWSrW7cuhg0ditNHj6JMwYII4fxnDuK+ehVHjxzBnCVLzPm+nTbN5boqFi+OKe++i6L58iHE2/c/PN/ChfDj+B6n7h9wf7j98IN1tqJFgYoV4WDFEze2xx0/Dr8334TfihWuV1m5MhxcNc+utGLroF3dxI3vq5wPnY+3Z1ox1GIlVv78VosfwyhuPM69lTGmMgPH3X3wYd6+lo/XUKpVq1ahX5cvX96EVKzMYdDA4GHBggUmNIlprPxxH7BOZ86cMcmws1u3bpkH8/bt22azMSzxpjKHLYWcweSMlUZsS4zM888/b0KcmPhFsPedbY2jR49G+/btzff58uUzIeD48eNNFdOhQ4dQtGhRMyyVVUkMfvg1L5+JT3Ym3oGBZqCc8/V6wuDI/XReN+3fv9+cxpDL+T5yaP3s2bNNKMawikPrOCOM1VD2bfLNqr3qgu2hhx4ywRQv16lTJyQ03Gd71kdkPdjh4ePFnyery/iYiCRW/D2/dOmSed5oNTGRyPEDHv495eyPiP4ui4j+zoiEh+9vOTbH/jvCUTivvPQSenfujKDTp1EuVy74BwfjNMfC3F05btm5cwhImRLXGfQ46dGhA0YMGICAVKlw2u39dXiS79+PwE8+QaoNG0KPcyRLhjt58iC5UzcV+e3dC+zdC7+pU833t7Nkgf+VK/Bz2o9b+fLh8kMP4dbd95+GPVSd42z4nszeOEPKnmvF7+1DzoFiayArqxhAuVc/ORW6xLhLl6zH2YfxdYlPzJRyb/cqXrw49u7da1aR2bdvnznOGafss5pq0aJFpiqG1TvOTp06ZQ4jmlM1dOhQDBo0yKVSiuEMgzD3eQwMqfhgcvaV8xB2Dm87duxYpPeJ1+s+vJ2hgjeX5W3c7yqC9hs6Xg9X5+Fjyooihj82/sfDNj+ep1evXqYss2zZsqYVsm3btq5lmuBzMZlX++XpfDzO+TQGNRxKz6VB+ZiwfZBVbAyj7MvabXvu18W2Ts6tYssnX5DzsgwBE/LKi/cTJvF+8efJyjC2Vook5lCKz3n+n6xQSsS75wz/Lug5I6K/MyL0119/mffRpUuXNn8bvMHXXHYgVblCBXw3ciTKpEqFkEOHcCZVKmRj8OPWevdw48Z4oE4dLNu0CYf/+AMFN29GttKlUa5GDWu+E9+LOlcfOVf/2N9fvQo/DiKfPx9+TpU1jjJl4Hj0UfjnyIEQvnf+7z/4sS2Q7XOnT8PPqSIpOSu37MulTQtH69ZIVqMGMvH2OX+KeMh9KlWKq62FDVWP6lDzuJIhgzWjyod5+541Qb17ZwjD0ITtW2zB6t27t8vpnDf00UcfoR3L7wAz1HPkyJE4ffo0st/9gc2dO9cES3wChidVqlRm8/REdH8DxO/tUMS5woUhDquIIsP/BNwrY3icN5e150HdD/vyPGQoRRMmTDBVac4YEvE8XBmPvcMzZ840rQCsQGratKmZB+V8nd7sl6fz7WS5J2Da83jamDFj8Omnn5pknj9fhlGsnGLA5HxZ9+viXKzBgwebNJ+/B6zeev/997F69er7fsxig13dRdHdP/sx8PR7KpLY6HddxHus6mYLH1v3EvIHMyIJif7OSGLGAgS7WIPvPfnemBtHotiH7u9T2VEzd9YstK5RA8PatkUKVhQxVMibF343bphAyt/D+5g0Dgeaz5wJLFhgHbF0qbXxw3gO/eb73rx5rZXu7EojO5DiHOjly612OhuLROrXhx/fL/I+nDljXRdXsmOYxPfxDM8OHmT7DbBvnzXwnGrVgl+LFvBjdZMzBlK8HmYEFSpYq+8ldH53K7h8mLfvWeP1p/HSSy+ZgIkte8ePH8fw4cNNOMLB13ySeKp24pwjDrcmVvDwScUQ67333jNzpIYNG4Z+/fp5DJ1iEiutnKutooIzm+IDS/s5VJ6tc2zVCw9DPYZR3Lp06WJmVNgvdlnpcz9LTjN84vUz6KLly5ebmWGPPfZY6Ke9nCHlHCqydNT9Nnk5zht79tlnQ49joCkiIpLUsKLbnvsY269/REQkYWNXjh1I2SNquHAUN2d8Pzhp0iQkY3Bw7hxSHj2KFW+8gRSsVmJ7m71ie3gzkng+zm/iolhOtxeKq+axqokbscqKC2UVKcKkzFRGwbl7iKc3aWINN4+su4ShUsmS1mbflt1+584XA6kkJl5/IkePHjUBFJ84DKE4RG3VqlVelxgywOKylEyCWS3DKhsO67YHYsu9OEvrueeeM1VYDJvYKrdu3TqzGh5Dtg8//NCsvMch6Ew22VbHcNBuo+RKevPnz0edOnXMC197zpQnFy9eNEEhb4NBE+dW/fnnn2bQuX19xYoVM1VYnAfF6+Lt8z9R51CKt8kKKK66ly5dOhOO8XK8Hs6fYkj5/fffY+3ataGBpYiISFLBv+n169c3hyIiknTwPRS7TvheyB4TwsMvv/zSrEbPgeU89LQIGOc4v/zkkyjP8Imnh4QgBVeNi2xlOoZRXH3u66+BGTPC2vF4+61bW+ESZz6xYODugmIGK69277Y2dxxW3ratNbA8OsILsRRI+YR4DaXYghUVnlYtY5XVDD4ZxCtsieRKe2x1Y/sbgzy2zdnDxtkGx6qzPXv2mNCvWrVq5vG1S+/YLsfwii2AbEFkUBQezqeye0l5XoaO/CSXA8xtrGxj5RbnV3G/uBLgAw88YIYcO1fUMWxkUMXZUWwv5FwsDsFnNRfLThlusmqKbYciIiJJCf9e8++5PbdRREQSN849ZpcRR6Gw04TtePYiUOxK4XslZ+x6YUBlb9s3b8aO//7DZ6NHY3z//gDDqMgqbdm5wvBq3Trgu+9YYRJ2Gtvz2InDFj2qVcuqsOIMJzug4ub0Hs/gQlasjOLlORSbm/PgcW6sbGJLX1Rn8yqQ8hl+juiuT5+IcNA5P11kEOJp0DlDEFbgaLi0RBefZhwcyFkf0Z0ppd9FSSr44sqeFaj5aSLezeTkhz7Vq1c3FcUior8zknitX78ePXr0MOGSjdWyXLk+0g8nWK105IgVFF27Zg3SjiSMCgkKwulz55B93z74L1pktd3Zq87xfU2jRkDLlpG3xXFuFG+XYRa/Ll/ezI4KDbzsja14nBnFfeXXDJfOn7duK3NmaxW8xB5IHT0KVKlihXWJNGdx5mM/HRERERHxNOichyIikjjx/3gu8vX222+Hztvl7N233noLL774YsSBFOtQTp8G9uyx5j9x8ak//7QqmRh85MtnbfnzW4PJGfxcvGi16Z05Yy24NG2aWQEvFMexPPIIULRoxDvOcIm3w30oWxbo2NGqqPJ2iDcDKlZocTYVZ1AxbGK7OkMOT9fBsM2XA6kkSD8hERERER/GTyHZIq+ZUiIiibPjYsmSJXjhhRfM+BIbZwBzxm5ZBj0RCQqyVqnj2JVNmzhMylr1zuZpHAvDHoY+mTPDL3t2ZNmzB37nzrnOgOrSJeL5U3YYxQCNQRdXz8uVK+oryjFUYnDG62DFFCu9GFBxxT2ussc5VHbwxECK4ZsCKZ+iUEpEREREREQkAeJK5X///Xfo9xwHwrm8//vf/0KHm9+DQRBb7BjgcLD4ypXAX3+5VjoRq6s8razO4eWslLp4EX7794eFBgEBQOfOVmtZeFi1yzCKh7lzA8WLW2HU/c49ZPseZ19xY8DFKi7OqeIhr5sBFWdWJcRAigEdAzO2LXozPen2bSQlCegnJSIiIiJRxdVuFy5caBYN4Qq1IiKSeNSrVy80lOJA80mTJqFKeKEQQ4+tW4HVq4ETJ6wQioPJnYeS2wPGa9YEuHI5L8PAhBsrkRgo2ZtTW7gjd274tWhhtc6xSskc6bDCIvtr4vc5c1phFEOp2AiHGEAxmCpY0GrtY7UX2xITQiDFQM9+PO0QiuEhq8rYtujNvvn5AUloRqRCKREREREflipVKuTNm9ccioiI7+GCSAyePvvsM7OVKFEi9LQnnngCs2bNMquod+7c2cyRugeDDwZFHES+ebNVIbV2rdXm5ixbNqB5cyu4YXVRRAswsVpn716EXLqEC8WKIVPFitaCTbwtbgxfnA/trxkYsdUuLoIhhj2chcX2PlZJMciJjdt1v7/u95mPFQMoVkSxPZEVZXwcChTg8vbWfvH7hFS9lYDoURERERHxYalTp0axYsXMoYiIxD97gXvnVbcvXLiAkydP4saNG6HbzZs3sXr1aowfPx5HGCQB+Pzzz/HJJ5+EXi5LliyYzxXvIpoZtXQpsGyZ1c7GyigeuldGMYyqXNm7mU5XrgCcIcVKpLJlcYtDzfk3JpqriMc67hf38X6wjZHBEtseecigyb6/POTGx84+dP6aAR+rwjjfiuETQygGUwn18UpgFEqJiIiI+Pgn7Fxuma17Hj9BFxGROHH9+nV89913+OCDD7BgwQLkYxXPXTx+0KBBkV7H8uXLTajlHGh5xAqdLVuAOXOAbdusVj0OQufxNrZ0M4xiu583M53sle5YgVSxotWCxypchjSJiV3ZZG8MERku8b5y5UHOwGKFE4MlO4By35zDKT629zszKwlTKCUiIiLiwy5fvowVK1aYT9Oz8tNwERGJU1evXjXVTmPGjMEJznICC25uuJwnohZrBlBtWrVC/+eeQ7NmzSIPpI4dA2bPtmZHsSpqzRqrusnGqqGmTYHq1b1vGWP724ULVusdV/Tj/CPyZjB3Qg2eOBOLLXX2Zgd2fEwYODF4YosdK5tYCcZAShVOcU6hlIiIiIgPy5AhA+rWrWsORUQk7rBKddy4cfj4449xloPB3YIqZ6VKlcLjjz9uwqlUKVMi5c2bSHXpEjJduYJOpUqhEKuqTp8G2KrHNjB7Y8Bkt9wxeGKr3oIFwJ49VqUUh3zbGLY0agQ0aQJ4WznL4IZDwnl+tvexOiq+q24ZhPHx4/212+icwzHntjq7aokbz2sHT6xc4v1g1RcfRwZQDJ0YDtoBVHzfTzEUSkm0LVq0CI0aNTL90RkzZjQlqQMHDjSrAImIiEjcSJYsGQIDA82hiIjEPgZQDKIYSDGYctaxY0e8+uqrqMBh4k74vqlR/frWQHIOId++3QpeGKowFAoOtkIVzjZyrubhjCJWwXJIOQeX83K7d9/bqleqFPDAA9b5vMXKqMuXrWHhrI6632pbzrdiyMX9ZvjjzfwqG+8LL88gyh6YzgHmWbJYgZP7oHE+Ts4bj2PYxI23zS06+yFxTqFUIsUUnsuFPv300/jyyy9dTuvXr58ZoNezZ08TJMWUhx56CK1bt0Zc3Td3e/bsQdGiReGLFOiJiEh0BQcHY9euXUiXLp3ZREQkFly7Bpw5g/ETJmDQBx8gmN/f5e/vj4cffhhDhw5FWYY77tg6xsqmVauAHTvM9WDrVqvSyQ6hGJxkzw7kzGltDIhY5cOZR7ws50ZxGDpb9hgkOc+NYhhVpoz3g7UZgHEfGPxUqwYUKWLdVnTx/rHKy65CYtjGQekMiuzV6OyQyPl2GMIxiOLGwInVTIUKWfed1U08vyR6CqUSMQ7W++WXX/DRRx+FrsjD4Xs//fQT8ufPH+O3x9uIq5V/WrZsiYkTJ7ocly0qnwo44aoXGgwrIiK+6tatW2ZFJx6KiEgMYlDCLhAO/+YcpytXUCBZstBAKkXy5OjRujVeef55FC1XzppN5B7+MHxiGLVrlxUwsd1u5cp7h4czwOHtcHPG91ccvM3T3Vv1Gje2Nm/b0OzwiJW1bNMrUeL+Vq3j48PwifeFVU0Mt9Knt77nY8T7z4CKFVl2UMW/Vbyc3XLHIKpYMasiivsSwewtSZxUx5aIVa5c2QRTf/zxR+hx/JqBVKVKlVzOGxISgnfeeQeFChUywRLLTadOnepynhkzZqB48eLmdJafHnT+T/FutQ/b+Gz79u1Dhw4dkCNHDvPJbbVq1TBv3jyXyxQsWBCjRo3CE088YVoPuG9fffVVpPeNvdg5c+Z02ey2hcWLF6N69ermPLly5cIrr7xiViayNWzYEP379zethhwI26JFC3P8tm3b0KpVK7Ov3Ofu3bu79IbzMXrvvfdMNRavm/s6cuTI0NOHDBliHp80adKgcOHCeO2111zeIGzevBmNGzc29zN9+vSoUqUK1q1bZ9oge/XqZUp/OdSQ2xtvvBHpYyAiIkKcJdWgQQPNlBIRiSk3byLk6FHM+PhjLOV7EwZKfK+RLx9atG2LuhUrYkDXrtj300/4+plnUJQtfCtWAEuWWIHT+vV88wSMGQN8/bXVcscw6K+/gIULwwIpVg3VqWOtjsfgyVMbNsOd/ftdA6nSpYGXX+Yn9d4FUqzGYosgA6/cuYEGDawh6PcTSDFkYisiQ6SqVQG+v7TnX3FeE0MmtgWWLAnUqgWwdbFuXaBmTYCtjazsql0bqFfPuj8crK5AKklSpVQix7CHFUWPPvqo+f7bb781AQiDEGcMpH744QfT6lesWDEsWbIEjz32mKk+4gvdI0eOoFOnTqb1r0+fPiZMefHFFyO87aCgINPOx+CGIc7kyZPRrl0702LgXKnFJVPfeust/O9//zNBWN++fc1tlmByH0XHjh0zt8kWP97ezp078dRTTyEgIMAl6GH7H2+HS64S52AxMOrdu7epLLt27ZoJmbp27WqWcyWW406YMMGczoGyXFmD129j2MRgLnfu3Ni6dau5XR73Mv9gAKZdkkHhF198YQK0TZs2IUWKFKhdu7bpSX/99dfNY0NqvxARERERiWNXriD44EFMnjgRH//6K3YdO4a65ctj6bffhp6FDXKLv/rKtOy54IfRbK/jrCfOfmKVEKuAGDTNmQMcOBB2XlYIMchp1co1GOIH6WyrO34c4Cp+9mbP7GWrXseOVqDjDVYk2XOj2BrIVj1WNHm7Ip8n3Ee72oqBE9vtvOmWYXjGTYtyiBs/h8NX13iM2aWU+SkjK1VYweKM7W4HDhwwFUQMNgz+B+JeVhkX2Fu8bp1XZ2Uow6CFIQqrpeywo2TJkiZgYvhiDyfncqWZM2c2VUy1mGLfxfNwTgXb/RgY/fXXX9jOlP8uViCNHj06SoPO2WP9zDPPmEolu1KqXr16+P777833/HVk1dOIESPM+cK7bwzQQn8e4P/nrfDbb7+ZoYK///47duzYEbqUKudnMWDiz5d/PFgpxZ/5hg0bQi//9ttvY+nSpZjNpVXvOnr0aOhjx4orBnQcZsjHxRtcEpbtkwzweL/4O/bpp5+a/XfnzWPn8XdRJBFiVeLp06eRPXv2e1/wicg9+Hd47ty5ZhnxTJzBISL6OyPeYyXSpUs4vmULxn37Lcb/+y/Oc8aRk/U//IDKDGA8YdUTQySGTgxr2GbHoImtcv/+C2za5Hp+zsBt394Kh7zFgIsDwDlrydtFLXgf2PXBEIgf9hcsGK0ZTSEOB05fv47sqVLBn+9VWCHFqi7eD1ZDiUQjZ3GmSqnosHuKfQCDlDZt2pjQg8EIv2bLmrO9e/ea8IkvZt1nLdltfgx5atSo4XK6c4AVXqUUq5P+/fdfU1XEFjpWIB1mmaeT8uXLh37NIImhFN+QRoTtg6w4sqXlkL67+8n9sgMpqlOnjtkXhkx2hRZb55yxtW7hwoUeK5TYhsiwiOFdEy6vGo4pU6aY0Inn5+3x/jo/+Z5//nlTPcVArWnTpnjwwQdRhH3XIiIi94FVtwxxeSgiIsyYLpkPfDm6hO8L+F6hYsWK5n2JqR5iYHPxIt4ZPdq8duf5/1q7FrecRn5Qg8qVMejRR1GBM488zZo6etQKo1iJxOoju4qILXwsJnC+PlYqtWtntap5O5DcxnY4bu774L4Cnb0xOGIrHCuqODuKFVvRxdth8MYKLr63qVwZyJPH+3BMJBIKpaJbseRDt8sWPrsy6bPPPrvndAYoxP+k8/A/GCdsu4uul156yXxyy4ohzmHiLKouXbqYsMuZ+4to/uFgpURE+Iflflbas0Ms58eArYWs/HLHKqn97OOOwMqVK02LJCu8OKOKiTCrpNiaaGN7HlsiOZtr5syZGD58uDkPl40VERGJLs4yZCU0D0VEkro1a9aYVcGd598ydMrL91IMkFhgwEDp2jX8s2ABVnA1PCccXv5w8+YY+Mgj91ZHsUWPoRPfG3A1PH7YzuvicayW8rTgBN93cPYTZylFNchhIHTjhlUpxc39PRKvz94YirHCnK10vK8M0tyKEbzCII3VY9x42wzQ+H6NH6Zzc3sfJXK/FEpFh5ctdAkFV6pjEMSwxx7q7ax06dImfGIFE2c5eVKqVClMnz7d5bhVXEUiApzXxFY1O3Rh8OM+HD2mcT/ZvseqMLtaivvB2U55IyiR5awnXo7thMk99FhzzhZDtfnz53ts31uxYgUKFChg2gdth9hL7oaD0Dkr64UXXkC3bt3MvC8+Plz97469HKyIiEgU8O/HlStXkCVLFrW8ikiSxQ+1P/zwQzMH1l7kKDBdOuTOlg1Xg4KQi8EKW+kY2rDiJ3t2BDu9/s6cIQOe6dgR/du1Qy6+H2DYxPmznMnEwMme88RDVg25VVXdg0ERx75wwDcrlXh+vj+JaDQBQyd71bq7K/yZiicGQXwvw/3m/eDGfbQ35++jEnzZoZcdQnEfeR18jNiax1CLH3iwUopDy1UdJbFAoVQSwKHabGuzv3bHwIZVTQxK+J85h3jz0wSGOWw/44Buzndi1c/gwYNNKLN+/XrTEhgRBjksmWUFEgMirkYXWQXU/Xr22WfN0PABAwaY6jDOg2JF0qBBgyJ8oc4B7py/xaCIg8k5Y4ttjaxk+vrrr80MJ86l4mkMkNgSeObMGTNj68knnzT3laEez89VBll1Nm3atNDrZ9siH2O27HFlPrYSrl27Fp07dzanMwxjaMfQiysf8tNufeItIiLe4N/sZcuWmXlS7i36IiJJAUd/8D3LrFmzQo+rVaECfn7+eRTgrD2GOgyG7A4NhlF792Jeixbwy5MHAfv3I3VQEPx++IHDXqO3E7wdtujx/2GODClXzhrsza4UBj88ZCUV3w8xnOLG0xkC8Xi7KokhEPeVlU6cTcUgyh6YHlMYMjF0YwcL50zxNrn6HW+PjxVHmtir+nF/WQkW1ZZDES8plEoiIhosRlz9jvOnuAofW9U4uJzVQxxwTpzFxEoiBldjx45F9erVMWrUKNMaGB5+UsHTubocXyQz1OGws9jE9kO2xzE8Y7jDcImh0bBhwyK8HFfMYwjHfWzevLmZH8XKJ1aZ2WEWQzVWUbEN7/jx46atzx7G3r59e/PYMAjjZTm7i+e3V/xjGHju3Dnzx/LUqVPm8eBqhmz3Iz5GvC6WGvN8DNKcVwsUERGJ6G98zZo1I/1bLyLiKzjrle833EduhIcfLNsrZvPD8Fe6dsWIzp2RggO5WfXDaid2eWzdarXdcfGmq1cR7THdrCJi5RKvn4PEuXFlPAZSrChiwGPPqmWow/CHQRA3hk88ZGUS3xtx/hMvy8vw/3FuvN8xHQKxKorD0i9dssI57qtdfcXb0+IyEk+0+l50Vt8TiSK2E7KMmKGW8xD2qNDvoiQVWn1PRM8ZEf2dSRr4YTg7CspwIPdd7EbgB8YcL8J5tPxQlyNGIup62LJxI6rXqoUMadLghwED0KxePWDLFmDePCuI4kDyiPC6+T6Q1UF2u5wdNvFre2NFEc/HyiaGSTw/A6UCBawqKZ4/oVUUcV/vztAyFVe5c1thGquivNhXvS6T6NLqeyIiIiJJAN/QseWc7fjeVhWIiMS3H3/8EX379jWdDuvWrQv9/+vnn382H+ZymzRpktny5cuH7t27o0ePHmY+q0v1z9mzKH/jBqa++CKqliyJnBxC/vTT1jDy8DBA4hBzLvLEoInVVAyj7BDKU1jDiqdTp6zqJgZR3A9WN/HrhFhldHeFQXNfWBXFVf+yZbPuq0gCovY9ERERER/GtnHONeTCJQqlRMQXqic48uL777833+/cudOMBRk5cqQJmerVq4c+ffpgypQpppOFjhw5Ys7DjSNHcubMiXULFiAlK6C4Xb+OtmyLGzLEGkbujNVMpUpZM54YzLBSiIPEeTkGN2yz4zyoiGY2sSqKc5UYQpUta61u52FxpHjHx4AtetxfhmsFC1r3l8GZhpRLApUAn0kiIiIi4i3OgWzcuLE5FBFJyNasWWPmP7Ftz8bqp1deegk4fBg4eBCVHA6M794dH3frhr+XL8ekmTMxe9Wq0JWq2d7H7dVnnsH7HToAS5cCU6dac6OcVawI9OwJ1KxpDTZnWHXggNXOx+8ZRHE2VEQtbPaQb56fLYbcElqlEedVsXqLQRsDOFZ7FS9uVUXZc61EEjCFUiIiIiIiIhJrGCi99957ZsEgtuURW46//OILPNK8ObBrlxUasZWOFUg3byJ1SAi6Vq2KrpUr4+S5c/h58WJMmj8fmw8cQE4AdZYvh2PGDPhxVpKzatWALl2sAIl43QyjWHXF0IatbGzViwyvl+16PH/58larn7fzothWyJCItxMbFVWcE2UPSefQcgZRRYtaFVH8OiG2E4qEQ6GUiIiIiA9jewtXkGW1VCZ+8i8iEstYqbR27VqkSJEC6dKlc9m4+jVXnrYdO3bMzIPiinq2GjVq4KcJE1CY36xebR3JNrNwApyc2bPjhWLF8EKdOjj/ySfIuGUL/E+eDDsDwyJWB1WtalUIMeCy2/gYEHHAN1ea8yasYXXUmTMAwzO2+7H1Lyrz+hhGnT1rBWwMwng9XDCLVUussorOIHTeB1ZEMYTixseXA9cLF7aCKFbKKogSH6VQSkRERMSHcWVXtu7xUEQktly8eBHTpk3DL7/8gvnz54e207lbv349KleuHLoC9eTJk0MDKa5C/b8hQzD88ceRgu16nOkU2fBtzkk6eBDgDKoFC5CZ4YyN/++xMqpRI6sVz1OYE5WwhtVRbNdj0MMZVPnyeR8iMXziZXl7rFriinw8jhVNDNAYUJ07Z53OkIshlaf/t3kZ3md7u1tZZiqieBnOibKDKM2JkkRAr15EREREfBiHm3M5dQ05F5HYsmPHDlSsWBE3nQOhcLBaysYQipVTxFX2fvj0UzTksPDt2602s/z5w78iVgQxuPr7b2DWLCvcsbEtrk4doH59q2IoPN4GSqyOYnUTQyBWXLH1z9t5TLzs+fNWoJUrF1CkiNXyZ+P9Z5DE+8P7wGCK4RU3u4qK+NjaIRrvH4M6Pla8f/yaG8MsBVGSyCiUEhEREfFhrFa4du2aOfRX+4aI3Kfr16/j5MmTKMgg5a4SJUogR44cZhU84mkdO3ZEmjRpcPXqVQQFBYVuntqIe3Trhg/79EEWrgx38aLVShdeuMLTeTvLlgEzZwLHj7uGTDVqAK1aWS153mJwxDlM3Bj+2F+z2ovXyY0hGdv/GJR5+38p7w8DKQZPDLIYSoV3vxgoceN57AoqVk9xbhUvw8ontvwxfOIhg6notPqJ+BiFUiIiIiI+PlNq0aJFaNeuHbI6fzovIhIFDLdfffVVfPPNN6YqavHixaGnMfDu16+fCasefvhhVK9e3VRBRerWLTzdtCmeZsDFsImtenZlkDNWCLGCiG1627YB8+YBO3e6nocVTO3bW7OnIsMQiq2BDH143dxXtr9x47BzBkCsQGJIxPCH+8TvGQZ5gxVVnDvFyzKMYquep/sVHrbtMcjiVqiQ95cTSYQUSkUXE3a7vzcu8D8u/gcq8YIv9hs1aoQLFy5oyW0REUlQuIJVtWrVzKGISHTs3bsXDz74IDZt2mS+X7p0KY4ePYq8rGi6a8iQIVG7UoZMu3dbA8cZAnkKzRkYMdzZvx/Ytw9YuZJDqawqJhuDLIZRHDoeWRDG92gXLlitdGy/K1HCul0GRvbG91TRrSplZRXb/Pg+kBVVDJR430Qk2hRKRQf/s1uzxkrf4wr/U61e3etgiiX8b7zxBn744QfziUbu3Lnx+OOPY9iwYaGfanDw4PDhwzFhwgQzuLBOnTr44osvUKxYMXP6jRs30Lt3b/z111/ImTMnPv/8czRt2jT0Nt5//30cPnwYY8eOjXBfuB9//vln6B85b7AkeODAgWYTERGR8HH1K1ZI8VBEJKp+//139OrVC1fYigbmNgF46KGHvJof5REvx4onhkwMb/LkcR3ozfdQPJ1zpbgdOmS1wDFMun497HxsY2vRAqhdO9xV+UKDLbstkGETQ6hKlYCcOb2fC+VN5RX3j/uePbs1yJyHapkWuW8KpaKD/7nyPyQGRCzZjG0sD+Xt8Xa9DKVGjx5tAqZJkyaZ4afr1q0zf2wyZMiA5557zpznvffew6effmrOU6hQIbz22mto0aIF/vvvP/PH6KuvvjKrZ6xcuRIzZ87EI488glOnTplQ68CBAybM4vUmZPxjmlIVZiIiksjnv/Dvcvr06c18FxERb18nv/zyy/jkk09cZkdNnToVZcuWjd6DyKqnPXus1ea4Gh7fx/zwg1UJxTlR3BgeRYRBD4eYN29utdeFfwes6woOtsKnkiWtWVUMpWJqNVIGXmwB5MZWO86c4kwofQggEmOiWbcoht1/HNtbNIKvFStWoEOHDmjTpo2pOurSpQuaN2+ONazwulsl9fHHH5vKKZ6vfPnyZrnW48ePm6ome5WN9u3bm1CLPeRnzpzBWZarAujbt68JvvgCOKpYsfXAAw9gzJgxyJUrF7JkyWKu/9bdMt2GDRvi0KFDeOGFF0wA5tyvvmzZMtSrVw+pU6dGvnz5TMDG4Yo23te33noLPXr0MPvWp08f1K5d+55yY94XfqK8ZMkS8/3333+PqlWrmtYHVoUxgDvNFTFERER8YA4MW294KCLiDb7W5mtq50CqW6dOWDt9Osry9T2Hb/NDcVYIeYPhE2dA8b0Gq57Ycjd1KtCpEzBuHDBjBrB1a8SBFG+3YkVg8GCgY8d7AykGRKykYlsgV+VjAMbL1KplBVgMjFgdFVOBFO8/b4e3W6ECULOm1bKnQEokRqlSKpFiEMNKp927d6N48eLYvHmzCXQ+/PBDczo/UWVbn3M7HquoatSoYSqjOMCwQoUKJqzhi9zZs2ebAIntAT/++KOppOKKG9G1cOFCc3085AtplghzoOJTTz2FP/74w9w2AyV+b9u3bx9atmyJt99+G99++60Jlvr372+2iRMnhp6PYdfrr79uWhNp1qxZpirs3XffDQ24pkyZYloa+ceYGIgxzOKnQwyjBg0aZMKzGfwDKiIikoBxpatmzZp5XPFKRJI4hkqsJLK3mzexb/duVHvkEVy4266XMnlyfNKnjxlI7vfff2GX5QfjrL5k5RFXpmNIxIok51CGgQ0/yOXsKIZErCbiXCiO9+AsKXecfcfAyt543dxYVeXpg3iGXfwAmhvvCz+w5z5wsDgrlngdMRVC2Rjw84N4tg9yjlW+fBFXbInIfVEolUi98soruHz5MkqWLIlkyZKZGVMjR47Eo48+ak5nIEVc2tUZv7dPe+KJJ7BlyxaULl3ahFG//vqrGfTNwIeDv1ll9csvv6BIkSImJMrDfnEv8YXzuHHjzL5xH1nRNX/+fBNCZc6c2RxvVy3Z3nnnHbP/9pwpzr5i+2GDBg1MqyKDMmrcuDFefPHF0Mt17drVXMausqKffvoJ3bp1Cw2peF9thQsXNtfLobFc1jZdTPWii4iIiIjEFgZEDFQY4DCAYlWS3d7GcIf8/FA4WTLUL1sWf61ciUK5cmHq22+jMleQS5YsbJA4r4uX4WU5G4oDvhlGMahhQMUQiUENg6gDB6zLXb4MjBgBbNkStk88nq2AVaoARYpEHO4wdGLnBG+T94G3yaCKl2FrHm/TXjUvNmY58f4yjOLjULiwFXzxvopIrFIolUgxQGJFE8MXtt9xyDiDGVYH9ezZ06vrYHvbZ5995nIc51KxZW7jxo2mzY8VWKxC4nEckugt7hODJxurpraypDcCvC2GZLxfNrYhhoSEmMqvUqVKmePYhucsW7ZspnWRl2MoxfOyGmz8+PGh5+HsLA5k520weON1Ege5M5QTERFJqPgh1KpVq0z7e0atAiWSNNitbHaAw0CIbXMMpXg8T2cFEUMkhjgMd+4GTvx34siRGPbFFxj57LPIaK/cyUDor7+sqie2qTEIKl7cGlROnG/L22Nl1NGj1vUxOOJtffMNMHOm6z4y1Gnd2rouVmWxHY6zmfg621NbIK+PwRdDKC68xAoq/p/G/YtuNRQfC/vxsPfV+dB+LInvTXhfCxa0Kr4iW+lPRGKEQqlEavDgwaZaim14VK5cOdM7zmojhlJ2BRIHlzMQsvF7ttF5wla77du34+uvvzbX37p1a6RNm9ZUIrHqKSrcVwhixZIdBIWHVUtPP/106KB2Z/n5x+4u7pM7VljxclwpkEEdHw9uxJlUHPDOjaENekwAAQAASURBVMEVQyyGUfw+2quOiIiIxBF+yMMB584f9ohIIg+guBIcv7cDFz7/2TXA18EMVPz9cev2bSxctw6/zp2LwDRp8JFTJ0Gm9OnxmfPM1VWruLS2tRKeu9y5OQHddeNAcQZgDKN+/tkaOm5jRVP79laFFKuP2MbH7gwGY84b3w9wv50Pud1PCGVjAMbHiAseMZjj9fM6ef3uh6y6sh8/BmFaUU8kTimUSqSCg4Ph7/YfKl+s2sEPV9tjMMWWOTuE4ietq1evNkPMPa3sw2HkDG3sdkBWKdnzmPh9TOKKee7XWblyZbMyYFEuwRpFHObOGVWcL8VQioPQbTt37sS5c+fMzCkOT6eEvqqgiIiI84cxXLDE04cyIuKj7BXf3AMovpZngMKghfOeOEvOKZA2QdSaNSaImrZoEc7zOjg7Nl06vDtgAFK5r0rNwIgzZxcuDH9fjh+3NufzMDjiewGGPzbuU8uWHG5r7RNDK1ZVMcSqVMnrVcTvCyuy+HjxsWG7IF/bx1a7n4jECIVSiVS7du3MDClWELFVju12HHJuz05iZRLb+Tg0nLOZGFK99tprpr2PK+O54xBwVkZV4h8UcJXWOqZaiu18rJLi9zGJq+hxZTxWeqVKlcrMtOIKejVr1jSDzXv37m1efDOkmjt3bqSVWjwv7xfvI1cV5DwpGx8jhmCsonrmmWewbds2c39FRER8AT9wunHjhjl0/0BKRBKG27dvm0WIFi9ebNpsR4wY4TI7lQsLsVksgEEOW+OOHbNCqAgCKJtdEfXbvHn4Y+HC0CDK5fbv3MH2/ftRmS15DLZ4Oz/8AEyeHDZvijgOg50W9vByzpPi/rh3D9wdkm7w/526dYFmzcJmRrGii/OZeH38ADymh5E7Yzhmh3icBcvbZHVXNFYJF5G4p1Dqfjj/B57AbocBCwOYZ5991qwmx7CJrW8cUm57+eWXTesaK4guXryIunXrmkoie2C4jSENZ1RxLpWtS5cuZtg5ZzRxxTpWH8WkN9980+wvh6jzhTarsvgpMP+Qv/rqq+Z2eRxP58p93mALH4O1+vXru7T7sV3vu+++w//+9z8z4JwVWVzBrz3LjkVERBI4/g1fsGCB+UCKH+KISMLCCny+3uaHxDZ7lWjD4cBXH36IgcOGIWPatMiZKRNyZM2KVAEBSObvb8JmHrJboUzhwniLXQ0MYqZNw+3x47HrwgXsDQnBVQBcnuf83atNmzIl2pUqhQfLl0erYsWQ+vBhYP9+tglY859YUWRjmNSggRXoMNxhWxvnqnLcBb9myMSh5qdOWVVTDM0YbPH87doB2bOHXRerpzjfisPTy5ePvUCK4RoHuTMg40By7ivDKFWNivgUP4fdg5WEsW0tQ4YMuHTpEtK7JepsW+NgbFYShYY1/KRgzRrXctXYxtS/evW4KXuVGMenGT8hS548eeiKf1Hl8XdRJBFitQfD9OzZs6vqQ8TLvw+7du0yHxLp74NIwvk7w3mo/ED4k08+cZmdyteCnFuanLfNoOfwYbwyejRGe7FoUL1KlbCEK9xxW7/e43nOJU+O4Bw5kKN4caTk0G4GRqywYoAzdy6wZ0/YmbkPNWsCTZtaFVn83p6xFBG+hbRbCT21zzGMslf0iykc7cFh7NzsGVschM77yBm53H+JcXpdJrGRszhTpVR0MBhiQMQVKOIKP2FQICUiIiJu2IKeI0cOcygiCcOMGTNMxwIXGrKx6p8BFYeMJ2cYxdPYJufnh3wFCqBuxYo4ee4cTpw9i6usQvKgAc/P9joGMncx7nKO1rLcvo0srGTiRhwqzsHkvD3n9y+cucSxHWwjZMhkbwx/GExF9EEqT3MPnOwZWGzXY5VVdAI/7h+7ROzwicUAdqDH6+P/c6zc4htc3oY9QF1EfJZCqejif4h68SciIiIJoFKKq8byU0iuwici8YcrWXNu6y+//BJ6HCsY33jjDQwaOBApOGfp4EGr64IfOrOKKUUK9HvkEbPZrl2/bmZF3QkJwZ1LlxCyaxfSTZqENDt2uHZSdO0Kfy4CxMDpwAFr49fOM6AY8nA2lPPl6tUDihe3Ah8OO2fIZG/EyzP8YVsc/1+JrNLfHsZepYo12NzbzgCGYLwcO1C4n7xNO3jiDC0OVOftu6/cF5szqkQkTunZLCIiIuLjK+5y4Y/ChQsrlBKJZwsXLnQJpJo0aYLx48ejSObMwNatVvUSQxdWJ0UQrKQOCEBqBj0MmBYsAP7+23W4eNmywIMPWqENMQjiRqx04twntulxWDlvkzOhWNnUoYMJsszcJTuEsqui7K+Jt83LsTKLVV0Mglid5CmgOnfOCrGqVgUYkEUWSHH/GEJx49e8Ts7DY9UTb4NteHyMtHCDSJKgUEpERETEh2XOnBktW7Y0hyISMxj0chj5kSNHzEwUbqxGtL923rgKNedTERfgmTRpEtauXWtWvu7etSv8GCytXm3NQWLgwudqeIELgxpWUzFU4uXmzwecFhsy4VCnTlYAFF74w4ojnsaQqmFDoHBhKwDj/CVvqylZpcTLsR2PoRRX4OMhN842tQMqfs9qq2rVrPOHh/vE+2a3JbJaq1AhIEsWqxpLw8lFkiyFUiIiIiIiIk5WrVqFqVOnevWYzJ49G82bNw8dYv71118jZfLkyMYqIIZRJ08Ca9cCrKBi9REDIlYFcTg3DxkAOVcg8XTOZ5o92wp9bKxC4jwpTwE02+DsVe8YXHH4N0MihmX3U3HE8Imbc0B15IhVHcWV+BgmcdZugQLW+XmfGUDZG+dCkT0HikEUwzEGURqFIiLxHUqxt3oEV45wwpVjdu7cifPnz5tPJ+bMmWPmJGTLlg0PPPAA3nrrLfOJhI2n9e3b15TKpkuXDj179sQ777xjVjkTERERSeyuXLliqjLq16/v8hpJRKLviSeeMO8z3N+reOL+vMvDKqD9+4G9e4FFiwCuqscAx3mYt/Mgck8YUNmLpPN9TYsWQO3aVsDEsMd5AXVWHzHE4u2WKmUFUqxAiuaKzyZYYvWT8/BzYtiVJ48VpvH2WNHF41g5xaCK52OLoH2cXQXF6jCGbmw1VEueiLiJ9+SmTJkymDdvXuj3dph0/Phxs40ZMwalS5c2K1c888wz5jj7U4s7d+6gTZs2yJkzJ1asWIETJ06gR48eSJEiBUaNGhVv90lEREQkrrAyg6+feCgiMYcfkL/88su4deuWWdI8vK0Qq39YOcSZTwxnOIx87lyA73EuXnS9UgZGbOPjzCaGS+GxgyBWUrVpY81cYhBkPeldD1mFVKkSkD+/FQJFB4MyVkJx9hSv1/6A33kAuvP/MfaKfjwfK6Ds8MneGErp/yQR8YVQii+iGCq5K1u2LH7npwp3FSlSBCNHjsRjjz2G27dvm8uxior93gy1uBRyxYoVTSXVkCFDTBWWlkYWERGRxI6V4pUqVTKHIhI9H3zwAfLly4euHAJ+F4Nee0XLcKsQGeJs2ACsWGGtfLduHQdShc1OsjG4Ypsbq4wY2jDIYTUSQysGVNwYbLHVj214DHQaN7ba9Rg6he1U2CGDK16OgRKf//yegRcDI28CIbbW2UGUHS4x2GKFE1vrPAVS7sfxcqp+EhFfDqX27NmD3Llzm6VSa9WqZVrv8vM/Qw/4SQQHDNrVVCtXrkS5cuVMIGVr0aKFaefbvn27eYHmyY0bN8xmu8z/jMG/CyFmc8bvHQ5H6CYSXfbvT3R/j+zfQU+/pyKJif3/rn7PRbzDynFWcvBQJCniB9a//vqraWNt3bq1WfHOP4KgxPnvDA9feeUV053BbouMGTOiadOmkd8oX88xhOLKeBs3Aps3w2/TJvi5hVGOcuXgaNbMqiryhAEVP6DnLCiGQzwfW/DuDk4PF4MrBlKcL8XLsEqLARerqRg2cf/4nokVS9zsoIrvgXhe7qcdRDEw41wrBm9sv4sqvS5N1PS6TKLL29fy8RpK1ahRA999952ZI8XWO/Zs16tXD9u2bUOgvbzpXWfPnjVVUH369Ak97uTJky6BFNnf87TwMPjy1B9+5swZXOenC074Io8PJv/YcQvF/8i59Glc4acV/KMl8WLy5Ml48cUXze9IdPAFj/1mIbrtFfz94+/iuXPnzIsmkcSKv+f8EILPm4jeVIiI5eLFi1iyZImZKcU31CJJRXBwMKZMmYIvvvjCrJJHn376KQoWLIhHH30UDz/8MLKy7S2cvzM3b9407XkMtOzX/cuWLUP58uUju2Fg2zZg61akXrUKgQsWwJ/H3eXw88P1KlVwtVUr3OYMpogwJGKYxFCIt8v3MgyG3N6T3FPdxECJH+QzvOL7BL53YrjlPGSc+8TwikEV38fwDSIvx+HkvB1ehpVg/FvL01mpJRLO80WvyyQ6My8TfCjVqlWr0K/5nz9DqgIFCpg/DE8++aRLJRNnR3G2FNvy7tfQoUMxaNAgl+tnuS6HqbMSyxlDKj6YrM4KHZ7OQOrff+/tEY9NfJHZoYPXwRQfpzfffNPlOIZ/O9jj7nTfGLTwjzkrx1hl9tlnn4UGexw2//jjj5sh8sWKFcM333zjUn3Wr18/FC5c2FxHRHr16mVeME+bNs3ru8s3on/88YcZbp8Q2G+M73eA/v2ESbxt7keWLFlMZaFIYn7xw/CW/ycrlBKJHD/Iq1q1qnktk1ofYEkSwDCJlU0MoDx9YHjw4EEz9uO9994zIROfH+5/Z65du4Znn30WM2bMMMfx7w1fBzt/AH4PfsC4ebM1K2rdOvitWgU/p2HlDr5erFwZjiZNkCpHDqTikU5h1T3XxX3nIVe2K1nSqlqK6LY5WJzhESujeBlv5kcxiOJ7F24Mqtjmp4HjEgV6XSbR5e171nhv33PGT/eKFy+OvVyp4i4GQi1btjQvuBhqOL+p5yyqNWvWuFzHqbsrW3iaU2VLlSqV2dzxj5H7GyB+zzdH9hb6CQUDKXuIX2zjJyW8Pd7u3b72yHBfPQ2Rd67SYTD377//4rfffjN98v3790fnzp2xfPlyczqHxfPx37Bhg/kEin+k17FP/u4yuXzsx44d63XlT1QrhFwe82jiJ14xUVVk70d094efLNzvddiPh6ffU5HERr/rIt5jEMVRCDzU3wdJCvg6ngsfOQdS/LCbH2byda39+jd79uyoXLmyy/OCr8kuHTiAbl27Yu2mTeY4zqH9+eef0alTp/Bv9PhxYNYsgK+TOUNqyxbXtrVKleDHD9yzZkWkr/RY6cR2PX4QXKYMkDt3xHOZ7LY8VkUVKWJdztvXgjwfQyi3LhSRqNDrMokOb1+TJKh3tkFBQdi3bx9ycQDg3Qqm5s2bmz8U06dPvydp4wyqrVu34vTp06HHzZ0711Q7saoq1nF/WP4a21s0gy97iLy9OZcvswSTlU8ffvghGjdujCpVqmDixIlmFUMGTsSqKpY9MyhkIGVXWTHo4UqIX375JZJFo++8YcOGeO6550y5dObMmc2+OVfAseSaOnbsaP4DtL+nv/76y7y44O8Cq7TYhuncVsnzM0Br37490qZNa1o+8+bNa45ztnHjRvMk4aqOxMeB88l4GX7SzE/O+PsoIiKS0LHa+dixYy7zMkUSk8OHD7t8z9d7nAPF13LdunXDpk2bTMUTX6/yvQBn1vJ1Jqv5Q6vcWWl0+DA616uHCtWqhQZSgQEBmDV4MDqxK4Gzofbvt2Y12TPaWOk0ezbw0UfATz8Bf/wB8LJ2IJUtG/DMM0D37tYKeZF90Mz7wkN2HzRoYFU9hffGjdVNPD9vq0KFsEHp+nBSRBKReK2Ueumll9CuXTvTsnf8+HGz7CpDDv5xsQMp9or/8MMP5nt7IDlbOng+ns7wqXv37qY8l3Okhg0bZtrKPFVCJTURDZFfv369CZecBzmWLFnSnM4B8jVr1kSFChWwYMEC9O7dG7Nnzw7tr+djzWDJvRQ6KiZNmmQqtVavXm1uj22CderUQbNmzcyQSn6yxZCMVXJ28LV06VL06NHDlGpz9hgDTLvEmr87NgZc7777Lj7++GPzQoTl2T/99JMZgG/78ccfze3xd4/4oobXyyV99+/fb0Ipvpj5/PPPo30fRURE4sLVq1exZcsW8zdN7XuSmLANj+ETR3vwg1O+PrV16dIF1atXNx9SuitatChGjx5tfcMA6OBB03Z3cMUKOJYvxyh+QAtgf8qUeLpBA5TkB9w//2wNAufrTn4gzI4IrkLHyzOEYtvenj1hN8LzNWlibZFV5TMwZlUXr59DxUuUCD/A4u1x4DkDKd4GK6N4GVU6iUgiFa+h1NGjR00AxcHNDJrq1q1rqnT49aJFi0xgYf9hcXbgwAFTPcOw4p9//jFhA0MXVrn07NnznllKSVFkQ+QZ4LECzX0gKudJ2UPi+SKAj22RIkXM483KKgZdDJQYJLFaas6cOSacmjBhQvhL5XrAgMsOkjivaty4cZg/f74JpfjzJ+6bcxsm7wP3iT9j4osQVkIxPHIOpR555BEzx8rGQZdc5pefsjF0Y1/0L7/8YgJM28CBA0O/5n19++23zf1TKCUiIgldpkyZzAd1PBRJDPiBIj8E5YeM9iJEo0eOxLQ//wxdHY4fPHoKpFxa3hgirV1rhVL79yPDwoVwmXDKRYtYBcXrZGsc2+j42pMr2vF1LSumONCc1+FciVisGNC5c+Qr5PH6OQeKK+Hly2ddjpdxrnSyB5IziOL5+ME65z7xg2SGYgyv7nOchYhIQhavoRSDgfCwEoc935Hhp4L2gEKJ+hD5iDBkYoWRM7b6vf/++6bSiBVFu3btwlNPPWWCQAY/3nJf1YQtm85tmJ5s3rzZzLvi4EobV7TjixVW1KW5O2/LvYKrYsWKKFWqlLkvDLUWL15sbuvBBx8MPQ9nD7CSbOfOnaYijy2B7tcrIiKSELGViR/U3e8cRpH4xtf+nCHLanp7xAJly5ABtbNnh2PRIvhxGDgDWL4+48aKJrtDgu8dTpywgiTOfTp61AqWGCrt2YNwY1u26vFy3JxxjAbDIhvDovbtgSpVIg6KOAfWHmLO1fcYRtltd/bqebxetuVx5TzeDs/DD4tZEcXv1aInIklEghp0LnE3RJ4VSFy5hKviOVdLcVB8eEPi2U7H83bo0MEMguQwSQ4RZ7jz+uuvR2l/3IeP84U0K5giwhlPrJbyNITSed4YK+bcsVrKDqV4yLZArmJnl4a3bdvWVIUx8OKcK67UwvCOj5FCKRERScj495GLkrDi3H0VYRFfsWP7djzXrx/mLV4celzyZMkw4IEHMLxvX2Rg+MSqKYY9HDrO1418PcnXgAyl2O7GEIqvdc+ds6qUOIycc6KcP+jOkQMhrVrhYsaMyLh/P/x5Ga6gxw9H3T8Qdw6k2DrYpo0VGIWHc05ZGcXbZghVvLhVfcXr5aByzivljCuGW6zyYrjGEIrfK4QSkSRKoVQSYQ+R5/wt4mBzBkNsmeOKe8SqJ7a4sRXSHVc3YTUUwxq7QokzqYiH/D4mcd/cr5MDzrmP7u2c3mBLH9v1OEuLq7VwSLuNxzEQY6WXvUIAK8pERER8pbqEf8e8qTAXiU187cYxG6y25wI7kVbvORy4duoUXnvtNXwycSJuO732a1qtGj4ZPBilnVv0GD45j4tgSHXgAF/EWkEVsXpq925rlby7r1UNBrYtWwLVqpl2vZs8391ZqwaDJFZKMaCyNwZV/LC2XTtrrpPbvpsQipfj7XBf2IrHlfE4M4phFI+zq6+431yIie14/DoaiwWJiCRGCqUSqYiGyBNfLLASiOXRrAziJ6sDBgwwgZTzEEnnmUtcwSQPS5ABMyT8+++/NzMsvvrqK/N9TOJcJwZmvF4OreecDFZjsaKJc6E43JIBElv6OCeLM6Aiu77atWub+8wXTFydz8aQi8Ha2LFjzWPGFkHn0EpERCQh46xItq7zUCQ+cSVje7Vm/j5y5hNnk3IL/Tp/fuTPmBHJOUfp1CmkPHPGvOazA6kCuXLhwxdeQMdGjcIPtRj+2FVRrJxi9RFDo/XrgSlTXCucWEnVuDFQv77VKhcensYFcO4ugmPYYRMPT52yDp0r+3m7rNbiZVmBzwCN86h43xhG8TnJ4xhUsSoqsoHoIiJJkEKp+3F38GJCvJ2IhsjbPvroIxPssFKKy0i3aNHC42BvrrzHtj+GULb+/ftj3bp1ZlYVVz5xHjQeE1i1xMCMA9QZhLHFjvvHwfas2OKKKqym4oqBXB3QG2zh46p6XMHPeXUirjL44YcfmuscOnQo6tevb+ZL8XwiIiIiwtFMF8wKyWvWrDGLEfFDPve5rmXKlAkNpa5cuWI+POTm7vHGjTGxf38TGCXLnBljX30Vzfv1w8s9euDlnj2RxmksgwuGPQyjOMCcIREDKbbqcZD54cNW5ZKNlUi1awPNmlntcZFh2MQWQHtjSMYQia8Zeeg874kVW/bGfWWlPVvzuH926x4rrBhUhXdfRETE8HOo1tsMtmbl0KVLl+6ZxcBh1yxDLlSoUNjcIv6h+usva3BiXOGnKx06WH8Yxefwacbh6VwpJrqDaD3+LookQmxD4mIE2bNnD22pFZHwnT17Fn///bep9mXLlEhM4rxRVtP/9ttvLsfzw0G+hnZ+TcKVmqdPn47rwcHYt3cvDh09al7/uHuzTx+81qePy3HnLl5EFrdVoUNxMDiHly9ZYlVHcaVohlLhtayyfY6BFK+P4RQrmpy2kOTJcTpNGmQ/cwb+fF3PCij+veHrbIZOfB7xtTffFzDQYvjk6fUbQyj7/QAvw44CBlHehGAiPkKvyyQ2chZnqpSKDv7BYkDET0LiCsuCFUiJiIiIGy7wUbZsWY8LfYjczwdqXBzmueeew/nz5+85PV26dKaSnVXrticffhhPcgwE5zFdu2Za8g5fuYL9Fy5g3+nT2Hf0qNnq5M0LcE4pr5eteDduIIs9k4kbv75yxdoYSDGE8rAPLtg2V66cNf+JLXj2dTE4squfGJDxOB4y0GJgxblSDJRYBWVXQkX0ASIrqrhPHFxuz6ViGMXb15woEZEoUygVXQyIFBKJiIhIPOPsxXz58plDkZhw4sQJPPPMM6bqycYqPC4cw7EN3DiTM7T6mx/Usq1u/34rsGFAkykTkvv7o/DZsyh88SKa2m12bO9buPD+d5JBEudIVakC1K1rrXQXUXUtQyhWRHFfuTFc4sBxb+c88bKsimJgxk/8GYBxVpRWvBQRuS8KpURERER82M2bN3Hy5ElkzJhR7d0SIxVSbAXl6sS2hx56yCwI4zyb1GCwwyqmffus+U6sMmKV1Ny5wH//ATt3WivY3S9WIDEA4qymIkWA6tWBYsWA7Nm9D5UYoLHzgBsDKoZLbOeLCM/HCivnFj2GUXwcFAKLiMQIhVIiIiIiPiwoKAgbN25E3rx5FUrJfWP105gxY9CoUSMz2++LL75Ap06d7j0jK59YGXX8uFVFtHSptfIdZz1FhPOWWOHEYIeBEoMtBjxsneNpnFHF47mx8uniRet0tvyxVY7hlKdWVbbkMTzigHI7fLJXxvNmnicv59w+aM/C4v7YLXqcF6VZhyIiMUqhlJc0D17im34HRUTEE1ZINWnSxByKROf1BVfKcx5C27BhQ0yaNAlt2rRBFgYxzrjK3IED1mp3rJKaNw/4+2/g6tV7r5zhEWdOlSoF5Mtntbqx8ogtfqx+4u8s5zK5h0asUGIYxblNBQtyWT8rjPIULjHU4rwpzo5i0MXb5Cwqtuhxn5xnwNphFzeGTrwvDKF4e7xuBlDceD1s7bMHn2twuYhIrFEoFYlkdwcWsjQ+tWZISTzi76Dz76SIiAhxlcqUKVNqtUqJskOHDuHp3r1x4/p1zP/rL/jbrzH8/NDjgQesrxnw2NiKx+qozZuB2bOt2VCsMHJWrx7QvDlQurTV7sbLHDpkVVAxxGIwxaqj8F7PsEqJ52PlFNv02K7nqUWPQRJDK24Mznh7OXNa57XnRzlXPvGQIRTvD7/nfjN44ip7DJ3sebHcorlSsoiIRJ1CqcgeoOTJkSZNGpw5c8YsfavlySW6n0JySWT+PoUOBY3iUqz8HeTvIq9DRETEuX1v8+bNqFWrVoRLLovQjRs38M8//2Di119j1ty5uHM3VBo/bBj6tm7tOZDhcaxIWr4cmDED2LLF9XS2yLVsCXTtalVEMfzhbKlNm6wQiEERwx9WIYWH+8G5VDwsWtQKmcKr/uN1sjqKoVLFilbI5TzjyXl+FMMtdwyoeFu5c6sdT0QknundbSQYIOTKlQsHDhwwnyaJRDeUYrDEUDM6oRTxsvnz54/25UVEJHHi35fr16+bQ5HwXodw7th3332HH3/8EecZ6DjJky0bCnH1OnuQOSuNnAOcqVOteVEMcpyx9a5qVaByZetrDjfnxsswXGJIyllQkc1hYjsf94mDy9mqx5DJ02XYonf2rHVbPB8DMH4dVQzJ9CGfiEiCoFDKCyyJL1asWGj7lEhU8Y3CuXPnzFyG6FbbqTVDREQ8YXVUjRo1VCUlHk2cOBEff/wxtrhXNwHIlyMHHm/XDi8+9hgyuM9NYrDEFr2vv7aGmTtju1ytWkCFCq6DxHnIjWEUj48MX1uzrY9VTqx4YjDmqZqK7XYMoxgmsYqqQAHrNkRExOcplPISg4SAiEqORSIJpdj+yd8htYCKiIhITFdCXbp0CSdPnjQV/hnY1nbX9u3bXQKpgJQp0alhQzzevj0aV6t276xKtt6tWgV88w2wZ4/raZzv1LChNbjcmw/Z7NlO9sbh4vbXNq5sZ8+f8hRGcZU/Bl08H4eesw1QREQSDYVSIiIiIj7swoULmDNnjueV0iTRfLjFcGn16tU4evSoCZ/cN86Kot9++w1dunSxLnjzJh5v0gQffPABahQrhl4dOuChNm2Q0dOcpQsXrFlRP/xgzYJybuFjO1379kCxYhHvKEMntuFxhT1imOS84h2rsbhxRTsOFGfrHYeTu7fS2ZVRDMx426yM4u+2RhiIiCQ6CqVEREREfBhXBy5evLhWCU5klU/OMyQ5QqJq1apejZJgQGWGkvNw3z6UvXYNeydPRhFWI7nj+Tgnatcu4I8/gNWrXauYOGicw885MyqiyiiGUAyjeH2seCpb1mrDY1seN7by8fvI5jjxelgZxfOxMopb5swKo0REEjGFUiIiIiI+jK3hBQsW1JgBH3bs2DEsX74cK1asMIecZfrTTz+5/IwZSvF0d9myZUPOnDlDt6JcUW7zZuDwYSsMypsXRdxb9BgenT4N7N5tzY1atgy4ejXsdAZJTZsC9eqFPxuKlVRcBY8VVndvB4UKea58igwHmDPU4uVYFcUwim16qowSEUn0FEqJiIiI+LBbt27hzJkzyJQpE1IxTJAEXQF18OBBbNiwwayGx41fm+omt5DKvVqqb9++6NSpE0qVKhUaQDGQ4szK0Na5I0eAvXsBrhjNlezs3wcGSKyI2rfPCqy2b7dCK7bI3W37M1gNxQHmLVpYbXaecFU9BlGcPcXzsALLvb2O+3Lvnb/3ON62HWox0OJqeqzOUhglIpJkKJQSERER8WFXrlzBunXrzIBrhVIJaw4Ut+ROVUOTJ0/G448/HullM2fObGaF8dD22GOPhX8BtrxxKDlXyeOQcwY9ixcD+/cDBw5Yh86VUJ6w5a5tWyvM8oRznljNxMCJVUwMo1gd5Rxe8TyswLKDssjCJT42HJ5uh1EiIpLkKJQSERER8WEZM2ZEw4YNzaEkDHPnzsVzzz1nBoy35kymuypUqHDPeVnhVqlSJdSsWRN16tRBrVq1zHFeYaWRHTqxgomh0JgxwMqV3l2eARYHiTdqZIVDzhg+sRqKYRbnTHEmFAOrwoUBtgg6t/WxCorBGG+fFU9sv3NvGfQUUPE8HHouIiJJlkIpERERER/m7+9vhpzzUOLXoUOHMGjQIPzBoeGAac1zDqVKly6N9u3aoULp0qhUujQqFy+O/Jkzw4+zmRjaMFhk0MTvuTpdeLOZGAKx5Y8zoRgG8WfPVfOmTbPmRblLnx7IlcvacuQI23gbNl6Og8YZRDFcsgOjggWt8zIoY4jl/nvG8546ZZ3Oaivehn4XRUTESwqlRERERHzY1atXsW3bNtSoUQOBgYHxvTtJ0vXr1zFmzBiMGjUK1xjs3HXq6FFrbhOPCw5GysuX8dfAgVxOzwqfTpywAh22uzFo4pwnHnIWFCuTGCYx7GE4lCaNtTEE4twonpcWLgQmTnRtz2N4xBXzWAVVrBhg/17wullRxSooHl66ZH3NQeMMpXj9bBlksMRD3nZ4c8p4ft43VlEVLWptvLyIiEgUKJQSERER8WF37tzB5cuXzaHEvX+nT8fzL7yAfWyhuyt7pkx476mn0L1+fWtlO2IlFFveGPIwJOJgcLuiiMEOq6LsFjcGVvZ8JgZbxOCKQRWDpcuXgf/+A778klPRw3aG56lWzRpWbgdHnC/FjXhZ3g43VkLxkNVSbLfLls0KoTgjKrJZUAzZuG+8D8WLWyvuaTi5iIhEg0IpERERER+WPn161K5d2xxKLGNQxKqi4GDs37ULA0eMwN9Ll4aenMzfH/1bt8aIxx9HBrvKiFt4gQ0Dpw8+AFassAInhkP2xhXt7K8ZFLG6ire/c6cVRm3ZEnY9vP7y5YE2bazqKgZVHEKeNat1+wyruDEUYxBlf83D8FoEPWHIxTCKhyVKWPOlnFsARUREokihlIiIiIiIO4ZAbIljCMUZT1x5jt9fu4ZbN2+i/jPP4BjnOd1Vv1IljBsyBOXYxhYZhkuTJlkbb4d43Tt2WJs7ttJxuDhDpI0bXU9jMNSxo9Wqx+vlCnwcWl6lSswERqyusgOxixetiipWR3HouaqjRETkPimUEhEREfFhFy9exPz589GqVStkZnghUbZr1y58/umnOHbwIK5dvYprQUG4fu2amQ917eZNXL95E2P69EGXZs1MJVKK5Mnx+tNP4+lRo5Ara1aMGTgQ3Vq0gJ83IQ3b+d5/37Xtjj83BkicMeVpUDkDMW7OGA61b8/p6VY4xPCMVUysYKpYMfxZUBHhfCm2Dtob2wqd2w55W1xdLzrXLSIi4oFCKREREREflipVKhQsWNAcStQEBQVh8AsvYMLEiZHO5DrPiiG20TGsOXcOT7Zvj6DgYPR+4AGk5/GRhT1HjgAffwwsXx52POc6NW1qbaxGYkUWB5+fOWNVJXEQOTcGUlwVjzhMvEULoHZt6/LWHbFW4StTBqhQwfuWPFY/8TZ5nxiG8frYRsiNK+6xFZBhGW8zotUARUREokl/WURERER8WOrUqVGkSBFzKFEQHIzUx45h2bx54QZSKVOkQEDKlEgdEICUHEr+7bfAhAmmgihZ2rQYxHlPnPHE+U9sn7PnR9kDzO/eDhYtApYsscIpG8/fuLE194lBFKuR+DNkpVO5cvfujN0+x6oqntfG0IqDzxlGMZSyg6rwMIBiEMV2QYZPnH3FfbCDJx5GNAdLREQkBimUEhEREfFht2/fxoULF0zrXkrnsELuERISAn+uHMfWucOHkezyZbzbuzceHjUKL/fogZ5t2yJtQAACUqUyYVQyO+DZvRt44w3r0OY+A4pBFFehY9hkb6x4mjfPtfWOVVUdOgCVK0ct+GGAxOt3xuvl/eF1McxyDsOcsQ2PwRX3mb8jGTNa52cgxWooBVAiIhJPFEqJiIiI+LDLly9j1apVyJYtG7Ky4kXu4XA4MPWHHzDs9dfx44svoiqHhjOYyZ8frfPnx6FatZA5Q4Z7L8gqpIkTgSlTrGCHGOAULGjNf2L1ko3tbxwyzm3t2nuvi5erVg2oW9caWG7Pj7JnSPF0VimlTWsFUJFh4MUKL14nB5u7B0usyrKDKIZrvL88HyuteF/DC7BERETikEIpERERER+WIUMG1K9f3xzKvWHU4pkz8fKQIVi7bZs5bsi332LeV1+FDiXnv/cEUhcuABs2AJ9/Dhw6FHZ8lixAt27WincMkzhY/ODBsI3fe5I3L9CmjbWCHiuV7I1tctwYGrHN7+RJq0WPLXY8jgEVN+cKOM62Yrsf5zvVqGG1DhJnUvE6GJQxQGPoxPvFAI37za8ja+0TERGJYwqlRERERHwYW8zSpk0b1mqWhJ09exZr1661ttWrsXbNGpw6e9blPCH+/mZAeSDDHmcMezgs/MABYPp0YP58K+ix1akDtG0btvKc3a7HrWZNKwhildT+/db18HYZHLVrZwVSDJb4M4qoVY6VT6xuYjDFyzOk4iGvm9fFfWbwxNlPZctarYBHj1r7zuorHs+2Qbbl8TQGURpOLiIiCZhCKREREREfFhwcjB07diBdunRmS6oWL16Mhg0bhnt62SJFMHrAALSqUye0SsqEOQyB2ArH1fEYKM2Y4Vodxba3hx8Gihf3fMVc+Y6VVZQtm1W9lCsXEBgY9TvB0Mqe88RwiXOfODeKIRersLif3PdSpazAiSEUq7D4NX/2DK0UQomIiA9RKCUiIiLiw27dumUqhHiYmF28eBFLlizBwoULzda/f3/07t079PTybivWlQcwKEUKtOYKhWnSIK2/P/wmTwb+/NOa2cQAiJVJnL1kf71smeucqOrVraHk7isb8rysZmKgxSCoUCGrjS5HjqiHQqx84vU4//xYhcXrsWdBMeyqVMk6nvvCdjyGUJxBpSHlIiLiwxRKiYiIiPgwzpKqV69eopspdeXKFSxdujQ0hNq4caNZPc+2evXqsFDq0iVkOnwYj9Spg+bXr6PVmTPIfvhwWNDDgeXcvMWgqXlzK2xihZJz8MN9YFsfB4ZXrWpVNDE4igrOjGIQxZXzGDIxzOKQerbgcWMgZX/NTa2ZIiKSSCmUEhEREZEEY+LEiRg/fjzWrVuHO6xI8oDtd0Gc37R8uTV3aedOYMkS/Mhh5u7hE2dAcZ4TK5LCuT4XFSoAnTtbbXT2MHKGRNx4HQyS7JlNDKgYLjFkYtUSA6bwKqWcV8Nj0MTrYBsew63otPqJiIgk1VDq9u3bWLRoEfbt24dHHnkEgYGBOH78ONKnT5+kZxmIiIiIxEdbG1+XNW/eHJkZcPgQhk7uA9qPHTtmqqDclStXDo0aNUKjqlVRP1kyZN6+HXjvPWDLFoBVUU5VVAYfCwZMJUtagRGDH4ZMDJAYLNltcwy1iJVm9esDtWrdu6Ns6WPFFK+TK+/ly2cFXJwnxY2znnhdXBWPx9tDx7nxsleuWNVWvA1WX9mr4bEdT0REJAmLcih16NAhtGzZEocPH8aNGzfQrFkzE0qNHj3afP/ll1/Gzp6KiIiIyD1SpUqF3Llzm0NfwNlXCxYswNSpUzFt2jSsWrUKRYsWDT2dwROVKlXKCqEaNUKDBg2QjYHQjh3AnDnA7NnAxo1WGOSMwQ9XpatbF+B1epq3xHlS/BCVl2VIxRa80qU9t+Cxusm+jSJFrEDJuaqJoRPnPfF4tvTZIRWHk3PjAHTeXrFi1vlYHaVB5CIiItEPpZ5//nlUrVoVmzdvRhZ+ynNXx44d8dRTT0X16kRERETkPqROnRrFixc3h3Fp7969mDBhAq5evYqMGTPilVdecamYP3nyJC5dumROS5s2rZkP9dtvv+HPP//EBXu1OsAcN3To0NDvq1evjhMnTiBnzpxhN8bzc0A5w6h584ADB1x3hrdbs6ZV5cTgJyKsaGJglD27FUZx9Tr3iiWuysfbZMDE/WAgxVApoqHiDLgYnHHLn98KtFiNxbDQRwJDERGRBB9K8QXFihUrkJJ/eJ0ULFjQlFuLiIiISNzhWAWGP2zdc399FlvmzJmDrl27mtu1MZRy9sUXX+DNN9+M8HrSpEljQi1nKVKkCAuk2ArH9ryZM60KKbb1Oa+Ox/CHVVEVK0ZegcRKJrbg8THi+YsXt6qY3HF/zp612usqV7YGmUenuomXSZ8+6pcTERFJQqL8F5arnngaOnn06FHTxiciIiIicefy5cvmA0NWsGflCm6x7PPPP8dzzz3n8nqQc6FYDeXMObByxmqqdu3aoUuXLmYkBIMpjxgMMYyaOxdYvNiaGxV2JdYwcs6MigxnTbEyilVLnAVVpoy10p17ZRRPv3jRWumuRAmrJS+8fRMREZH4CaU4RPPjjz/GV199Fbb6SVAQhg8fjtatW8fMXomIiIiIV7jQTO3atc2hp/lNnPfJFrru3bvfd0XWCy+8gHHjxoUe1759e9N6d+3aNfOa0BnHPfA2L54+jUunTqFAunToXLcuWjRqhACGQmw3ZOWSvWqdvXIdwy5WRDGQWrAAWL/eGk5uY/XSAw9YwVREeD0MmThknC19bO0rUMC6DYZQvE6257Hyit/z9nPlsgaZO42oEBERkQQUSn3wwQdo0aIFSpcujevXr5vV9/bs2WM+mfv5559jZy9FRERExKPkyZMjQ4YM5tDmcDjwzz//4KWXXsLu3buRLVs2dOjQITS4YsDUu3dvDBw4EBXZyhYJVj099NBDmM2ZTncNHjwY77zzzj2r5xl37uCxevXwGOc2rVsHLFlitc/t2WMFUQyU7DlObKfjxhXrWG3FcGvtWmDFCtfqKFbkP/igNcg8IrduWZVRDJ04vLxaNatCitfPgIrteayeYgjF/WBFFFv1eP2qjBIREUnYoVTevHnNkPNffvkFW7ZsMVVSTz75JB599NE4H7ApIiIiktSxSonBE8cosIVu06ZNePHFF80Kd7YzZ85g5syZJliiMWPGYNKkSfjxxx8xZMgQvPbaa+Gu3sfLNmzYEP/991/ozKfx48ejV69ennYGOHjQmgPFlfKWLgVWrrSOd8aAiIPDWTHFqiSGRwzM+FqSt8NKKefqKK6Q16GDFVqFhxVP585ZgROvmxVPvF47pGLwxRCKK+HZt2eHYCIiIhIvkkf3E7nHHnss5vdGRERERKLkxo0bOH78OLJnz473338fEydONJVStnr16uHDDz807XTEWVB//PFHaMXUyJEjMW3aNHz77beoUaOGdSGGSLyOVKnMrKpixYqZUIrD1Hne+vXru+4EV6rbt89qtePKeNu3A8uXW8d7wqDo+HFrc8bqKYZKNgZHrI7iHKjwsPqJt8Ogi+13rM5i2MQKLl4fV9dj+MVKKG7uK+2JiIiI74RSkydPjvD0Hj163M/+iIiIiEgUcMW9DRs2mHY855XsChcubEKqjh07usx7YrvdsmXLTOvd22+/bYIpBk6cSzWwVy+81aMH0thzllKkgH+aNPjhf/9D7zt3MHLoUBThEHDOYmLlESuTGEBt3AhwFeaTJ622uyNHXHeyUiVreDhb906dss7H6iWn8MxwDqSqV7eqo9wr8TkrivvHjYEUK7xy5LCqo1h1xSCLq/fxa7bleVphT0RERBIEP4fzR2leyMRBkW4DNIODg80LIq6ecp4vMLz0xhtvYMSIES7HlShRAjt37jRfc2YVy8/ZKshPATnLiiu+5OALj7sOHz6Mvn37YuHChWY1l549e5oXWc5zFbxZtYazGDgvwdOQUJH7xVUrT58+bT7F9tcntCJ6vojEoFdeeQWjR48O/Z6vaV5//XX069cv3JY8E/4EBWHL6tV4YuBArL/bmkeFc+bE648/jp5t2lhzoFjVxEPn1ZcZfh09agVMDIdYWbVmjdV654zzmtq3twaMu+N1njljBVS8HnvjXKdmzYBSpazz2AEU2/m43/w7yqoovoTNnNm6blZDsUqKr1MZREXhdaAkPXpdJqLni8Q+b3OWKP/FvuChDJuDzhkMceBlVJUpUwbz5s0L2yGnFxFc4eXff//Fb7/9Zu5M//790alTJyxnOfjd8vM2bdogZ86cZinkEydOmEotzjoYNWpUlPdFRERExNf06dMHu3btwuLFi814BQZSXIDGBQOc4GCrsogr0jH8CQpC+Zs3sWrkSHw4YwZenzQJN27exP6TJ/H4u++ifq1aKJQnj+t1sDJq926rRY9BEaulOD9q1SrX0IpVS23bWkPJw5vZxMvy+u3bYADFfeT18msOOWf4xEonzoDifWJgxZCMrxcZRDGQ4mlqyxMREUkalVLhWbdunXkhZFc5eVsp9eeff5qBnO6YpnGlmJ9++gldunQxx/G6S5UqhZUrV6JmzZpmYGfbtm3NHAW7eorLHnNgJ4dysnrLG6qUktimT+RE9HwRiS1cdIZzpOrWrYtKbJOz/vBYLXbcLl+2KpJY3cTAhyERwx3OXXKqpNp18CCefOstLN+82XxfqUQJrJ08GclYmcQwau9eKyhiqMUPKfn11q1WkGTjdTZvDtSubc10Cg/3j9VVdgjF7/m6ja16rH5i6x2vixuHk/O6uA8MpBhOFSxoteypIkqiQa/LRPR8ER+ulAr3ipInN+FQVLHKKnfu3AgICECtWrVM613+/Pmxfv160xrYtGnT0POWLFnSnGaHUjwsV66cSzsfW/xYtbV9+/awF2Zu2ArIzfnBsv9AcROJafy9Yv6r3y8RPV9EYhpfQ3Xp2BHZ0qRBCGc5MTRigMMQiiEOQyhWGzHcYdjjXLnk9NlksQIFsOirrzDhzz8xf80a9O3cGX7nzyOELXkrV8Jv/34zN8qPVVZuHAyNKleGo1o167Z4HnvQuH1IDKLsfWIAxX0qUsSqduLXfNHK6ijb7dvA2bNWFZYdRrEKyw6j9LpNokGvy0T0fJHY5+173yiHUtOnT3f5nm+02TY3btw41KlTJ0rXxRVevvvuOzNHitfB+VJcIWbbtm04efKkqXTKyBcpThhA8TTioXMgZZ9unxYeBl/us6yI1VWcYyUSG09IJsR8vmimlIieLyIx6VZwME5v347bISFIYc9cYgUUq6HsgOf6daTYtg3+DHgYEiVLBgeDHefDu8c/WLgwuqZPj5SzZ+P25s1Icfgw/MJ5YcnLXq9dG1ceegghrHBieMQgicGT89f25dlyx1Y7VkAxlOJ+OodkvIy98UNDXo4zoriiHl8T8r5FYX6piCd6XSbiPT1fJLqucGRAbIRSDzzwgMv3XM2FbXaNGzfGBx98EKXratWqVejX5cuXNyFVgQIF8OuvvyK1+0orMWjo0KEYNGiQS6VUvnz5zP3QoHOJrf/M7eeKQikRPV9EYtK5Q4ewZe9etC1VCllYTcQP2PbsAXbsgN+OHZx/YGZA+TnPfIomU1fFGVCsiqpXD6hVC6kCAhDOOPUwvG1WZYXXbsfwyR5qzmoqfs+KKLsyKqJWQJEo0usyET1fJG4quWMllIrN9iNWRRUvXhx79+5Fs2bNcPPmTVy8eNGlWurUqVNmsDnxcA1XenHC0+3TwsOVaDytRsOwQIGBxBaGUvodE9HzRSRGXb+ODPv2ocG+fci4cCH8GUCxzS4GAqhQfB1WuLAJovwaNbLa7ZInh6lvYtBkt+NxY3jkabC5cxjF8IljFLgxhOJ18DJ8bcaNoVfu3AqjJFbpdZmIni8Su7zNVpIntEGd+/btQ/fu3VGlShWzit78+fPRuXNnczpXljl8+LCZPUU8HDlyJE6fPo3sLOsGMHfuXFPtVLp06Xi9LyIiIiKx7vnnkfKrr1A4ovMwKMqXD8iVy5r3xFDIDq3utuwZ/ODRrlhiYMTzly9vwijzNdvubDwfZ1exNJ/XyWDJvrz7Gjp2SGUfb6+ox7Y8rp5nt/LZm5cvYkVERMT3eRVKObe6RebDDz/0+rwvvfQS2rVrZ1r2OCR9+PDhSJYsGbp162amtD/55JPmtjNnzmyCpgEDBpggikPOqXnz5iZ8Yoj13nvvmTlSw4YNQ79+/TxWQomIiIgkKlWq4FpAAPYXLozC+/cjNQMlVjWVLAnkz2+tZEcces5wiIPEGQJ5aodjxdPp09bXDLFYEeU8VJwYOnHlPa7qx+tmYGXfBk9j2GWHU+4bMYyywyfngeYiIiKSJHkVSm3cuNHrMtioOHr0qAmgzp07Z2btcCnjVatWma/po48+MiVfrJTianlcWe/zzz8PvTwDrH/++cestsewKm3atOjZsyfefPPNKO2HiIiISELBOd5791obFzZ+6aUIzlynDq4/+CC25cqFXAUKIHWhQtaA8IMHrRX4WMnECidWOoU3z4lBEgegszqKbXPFi1uHzhVLPA/DqOBgK4QqUYKzEqx2OxEREZFo8nNwObAkjoPOWZnF1dE06FxiA2ex2W2mmlsmoueLJG185cURmAyd9u0LC6Ds75n9OGNREoubwhNy4QJOT5+O7OfPw//MGasqipVInAUVUWjE6iUmYDw/xyAwaOLqeM7hFcMonofDxxlGMfRiGJUyZQw8EiLxQ6/LRPR8kYSTsySomVIiIiIivorh0cmTVuDELjgeetpOnLByIG9xbnm5chGc4dIlqzKKaVaWLABX4Iuoep2pGOdB8XIMmnjlbPVzDrBu37bCKFZP8TrLlLHCKLXciYiISAyKVii1bt06/Prrr2boOFfIc/bHH3/E1L6JiIiIJGjMd2bNAl5/na+P7u+6mCMxGypa1HXjeKeIXA4KwoqQEDTOmhUZwyupYlUUZ0ZxtTuGV/zEkvOgODeKVVU2+3RWSDGMYmCVI4fCKBEREUkYodQvv/yCHj16mPlOc+bMMcPGd+/ejVOnTqFjx46xs5ciIiIiCczSpcD//gcsW+b9ZbjgHAuO2AXnHj4VLBi9EU2cscmi+GSsbmIJFj8wZADFQ3s1PCZebLnjDZQta92gXUrP01nmxeopVkIxhGISxoqr8OZQiYiIiMSAKL/SGDVqlBlAzhXuAgMD8cknn6BQoUJ4+umnkYtDNEVEREQSsQ0bgFdftSqknLHDrXx5azwTcx33jeu4cPG5mJY2dWqUTZYMaRkqseqJ4RPTLw44Z+UUb9R9I4ZYvAyDLJ6XA875Wo6zqKK4eI2IiIhInIRS+/btQ5s2bczXKVOmxNWrV82qey+88AIaN26MESNGRGtHRERERO4Hi4JWrrRyFhb/cLMLhTxtzF9Kl7bGKnljxw6rTW/qVNfjS5YE3n4b6NQpfrKckMBAXCtYECGZMsHfHm6eLFn4F3Bu0eP5OeCcSVqaNHG52yIiIiJRD6UyZcqEK1xeGECePHmwbds2lCtXDhcvXkQwlwkWERERiWMMotq2BZYvj/plWcXEcIpbqVJhXzOnYcjEGeL8zG3yZCvkshUoYB3/2GMRZ0Cx7WJQEBadO4d26dIhK1+LsfLJTuN4aO+0ncaxkkoteiIiIuJLoRTDp7Jly6J+/fqYO3euCaIefPBBPP/881iwYIE5rkmTJrG7tyIiIiJuzp4FWrSw2uqiw14Vb+FC1+NZQVWsmHW9HNFkY57z2mtA797RmwEV0wIzZkTVYsUQmC6d1ZrHhMx541wobv7+1sbWPrXoiYiIiC+FUuXLl0e1atXwwAMPmDCKXn31VaRIkQIrVqxA586dMWzYsNjcVxEREREXJ08CzZrxwzPre87m7t/fymJY5eS+MZPhIYuHDh0C/vvP2k6fvveBPX8eWL067HvmOEOGAAMGWKOaEooUgYHIVrUqUrC0i3dQREREJLGFUosXL8bEiRPxzjvvYOTIkSaE6t27N1555ZXY3UMRERERD44eBVikvXu39T1nRM2fb7XgRafaijOjuNlBFbdjx6wAauBA4KWXrGAqobl+/ToOHjyI9OnTI43mQomIiEhiDKXq1atntrFjx+LXX3/Fd999hwYNGqBo0aJ48skn0bNnT+TkGsciIiIisezAAaBxY2veE+XPbwVSRYtG7/pYYVWvnrU54xhNLmjH7reE6tq1a9i9ezeKFSumUEpERER8SpRrvNOmTYtevXqZyim+AGIr32effYb8+fOjffv2sbOXIiIiInft2mWFR3YgVaQIsHRp9AOpiAQGJuxAyl6Epnnz5uZQRERExJfc1+ABVkn973//M7OkAgMD8e+//8bcnomIiIi42boVqF/faqsjtuotWWJVSomIiIhIEgmllixZgscff9y07A0ePBidOnXC8uiswywiIiLihfXrgYYNw4aSV6zImZdA7txJ++G7fPkyVq9ebQ5FREREfEmUCtKPHz9uZklx27t3L2rXro1PP/0UXbt2NW19IiIikrTdugWwcPrcOSBfvrAtXbr7u94VK4BWrRjAWN/XqAHMnMnWtRjZbZ/m7++PgIAAcygiIiKSKEOpVq1aYd68eciaNSt69OiBJ554AiVKlIjdvRMRERGfmvX02GPAunX3nsZV6xhOsc3OOaxiqHT7dtjGUMv966AgYNQo4OpV67rYvvfPP9a8J2Hglw4VKlQwhyIiIiKJMpRKkSIFpk6dirZt2yJZsmSxu1ciIiLiMxwO4KuvgEGDgOBgz+e5eNHaOBPqfjRrBvz5J5Amzf1dT2ISEhKCmzdvmkNVS4mIiEiiDKWmT58eu3siIiIiPofznXr3Bv7+O+w4FlI/+yxw8iRw+DBw5Ii1HT1qVT9FFxf5nTIFCAiIkV1PNC5evIj58+ejXbt2pqJdRERExFck8EWORUREJKGaMQPo1Sts8Dj17QuMGeO5kikkBDh1KiykYmDF1rwUKYDkycM/5JYnD1CrFuDnF6d30Sewba9SpUpq3xMRERGfo1BKREREooQtei+/DHz2Wdhx2bIB334LtG0b/uU4hztXLmurXl0PekxJmTKlWQ2ZhyIiIiK+RKGUiIiIeG3jRuDRR4EdO8KOa9MG+OYbIEcOPZDx4caNGzhy5AgyZMiA1KlT64cgIiIiPkOhlIiIiIS6c4chB3D9+r3bnDnA66+HzYVi/vHBB8Azz6itLj5dvXoV27ZtQ6FChRRKiYiIiE9RKCUiIpIIHT8OzJsHXL7sebt0KezrK1fCgidvB5FXrgz8+CNQsmRs3xOJTObMmdGqVStzKCIiIuJLFEqJiIgkMnPnAu3aWRVPMY2DxocMAUaM4CyjmL9+EREREUk6FEqJiIgkIitWAA884F0gxdXtMmQAAgOtVryAgIi3dOmATp2AGjXi4p6It65cuYJ169ahXr16Zq6UiIiIiK9QKCUiIpJIbN5sDR3n6njErx9+GEif3nVjbsHDVKnie48lJvj5+cHf398cioiIiPgShVIiIiKJwJ49QPPmwMWL1vfNmgG//67gKSlIly4dKleubA5FREREfIl/fO+AiIiI3J8jR4CmTYHTp63va9UCpk1TIJVUOBwO3LlzxxyKiIiI+BKFUiIiIj7szBmrKurwYev78uWBf/8F0qaN7z2TuHLhwgXMmTPHHIqIiIj4EoVSIiIiPurSJaBFC2DXLuv7okWB2bOBTJnie88kLqVNmxbly5c3hyIiIiK+RKGUiIiID+Iw83btgI0bre/z5AHmzQNy5ozvPZO4lipVKuTJk8ccioiIiPgShVIiIiI+5uZNoEsXYOlS6/usWYG5c4ECBeJ7zyQ+3LhxA8ePHzeHIiIiIr5EoZSIiIgPuXMH6NEDmDnT+j4wEJg1CyhVKr73TOLL1atXsXnzZnMoIiIi4kuSx/cOiIiISOSYN+zcCYwbB0yZYh0XEAD88w9QpYoewaQsU6ZMaNasmTkUERER8SUKpURERBKQs2eBHTvu3ezV9WzJkwNTpwL168fXnkpC4efnh+TJk5tDEREREV+iUEpERCQehYQAv/0GfPUVsHUrcOZM5Jdh9vD990CbNnGxh5LQBQUFYePGjahTpw7Sp08f37sjIiIi4jWFUiIiIvEURv3+OzBiBLB9e8TnzZDBmhllb61aAWXLxtWeSkLncDhw+/ZtcygiIiLiSxRKiYiIxHEYNW2aFUaxMspZzpxA6dKuARQ3Hq/OLAlPYGAgqlWrZg5FREREfIlCKRERkTjAIpY//wTeeAPYssX1tJo1rZCqWTOFTyIiIiKSdPjH9w6IiIgk9jDqr7+AypWBTp1cA6nq1YGZM4EVK4DmzRVISfScP38es2bNMociIiIivkSVUiIiIjEQPF25Apw8GbadOGEdzpkDbNjgev6qVa3KKM6GUlue3K80adKgdOnS5lBERETElyiUEhERAXDnDvDLL9acJ37taeM8KPvr4OCw4Ikbv49MlSpWGNW6tcIoiTkBAQHInz+/ORQRERHxJQqlREQkyWPX0yOPALNnx85DUamSFUa1baswSmLezZs3cerUKWTMmFHBlIiIiPgUhVIiIpKkccZTx47A/v3Ru3zmzNbqePaWK5fr93nzAiVKKIyS2BMUFIQNGzYgT548CqVERETEpyiUEhGRJGvKFOCJJ8Ja77JmBcaNA3LnBpIli3hjp1T27ECqVPF9LySpY4VU48aNzaGIiIiIL1EoJSIiSc7t28DQocCYMa7znv74A8ifPz73TCTq/P39kSpVKnMoIiIi4kv06kVERJKUc+esVe+cA6mePYGlSxVIiW+6evUqtmzZYg5FREREfIlCKRERiTaHA1i0CFi50qo+Sug2bgSqVgXmzbO+T57catebOBFInTq+904keu7cuYPg4GBzKCIiIuJLEkwo9e6778LPzw8DBw4MPe7kyZPo3r07cubMibRp06Jy5cr4/fffXS53/vx5PProo0ifPr2ZpfDkk0+agZ8iIhL7gdSAAUCjRkDt2kCWLECnTsAXXwD79iW8R//HH639PHjQ+p7zoBYsAPr10xBy8W18DVSzZk1zKCIiIuJLEsRMqbVr12L8+PEoX768y/E9evTAxYsXMX36dGTNmhU//fQTunbtinXr1qES19cGTCB14sQJzJ07F7du3UKvXr3Qp08fc14REYk9w4YBn30W9v3ly8C0adZGhQsDzZoBzZsDjRtzGHPcBmZXrgAnTgDHj1uzolgRZateHeBnHFwZT0REREREkmgoxaomBksTJkzA22+/7XLaihUr8MUXX6A63z2YN0DD8NFHH2H9+vUmlNqxYwdmzZplQq2q7McAMHbsWLRu3RpjxoxBbi6fJCIiMe7994FRo8K+b90aWLWK1athx+3fD4wfb22cv8z/ymvVsla4y5zZ8xYYeO9tsS2QBbDcGDQ5H166xKpaK3iyAyj70F5Rz92TT1phmlbNk8TiwoUL5sM5vv7JwpJFERERER8R76FUv3790KZNGzRt2vSeUKp27dqYMmWKOZ2teb/++iuuX7+Ohg0bmtNXrlxpjrcDKeL1cPWZ1atXo2PHjh5v88aNG2azXebH+wBCQkLMJhLT+HvlcDj0+yWJwoQJwMsvh3V/jx0bgmef5Vwba2YT5zXNneuH5cuBW7f8zHn4XytDK24RSZbMgcyZ/ZAqVVZcv+6HoCCHOYwJKVI48MknDvTpY7Xr6b97SSy48l7RokXNoV7HiEROr8tEvKfni0SXt69J4jWU+uWXX7BhwwZT6eQJQ6iHHnrIfOqXPHlypEmTBtOmTTMvvOyZU9k5FMQJz5c5c2ZzWnjeeecdjBgx4p7jz5w5Y0Ivkdh4Ql66dMkEU1qyW3zZX38FoG/fDKHfDxlyBV26XMXp09b3+fMDTzxhbVev+mHVqhRYtCgVFi9OhT17Iv+Tc+eOH86cub8/T+nThyB79hDkyHEHOXLwkN/fQdOmN1C06J271y+SuP7G8EM6fsimuZoi3j1n9LpMxPu/MXq+SHRcYWtDQg6ljhw5gueff96UmwcEBHg8z2uvvWZmSs2bN8/MlPrzzz/NTKmlS5eiXLly0b7toUOHYtCgQaHf80Vcvnz5kC1bNg0JlVj7z5yD/Pk7plBKfNWMGUD//n5wOKzKpUGDHBg5Mi38/NKGe5lChYBu3ayvjx0LMS19bPHjduECD/1Cvw87jq15IUif3h/p0sFlY3tf2KHDHPKzCXZr58plbWnS8Nb8PazlkS4WHx2R+MPq73PnziFTpkymWkpEIqbXZSLe0/NFoiu8nCfBhFKcC3X69Gmzop6NSxkvWbIE48aNw65du8zhtm3bUKZMGXN6hQoVTCD12Wef4csvvzSr8vE6nN2+fdusyMfTwsMXbJ5etDEsUGAgsYWhlH7HxFctXQo8+KA138meyzRmjJ/5vfZWvnzW5s2Ln9Onz5hK2Ij/T46Ztj4RX3f16lWzCEyuXLmQOnXq+N4dEZ+g12Uier5I7PI2W4m3UKpJkybYunWry3FcOa9kyZIYMmQIgu9OqHW/I8mSJQvtTaxVq5appGLAVaVKFXPcggULzOk1atSIs/siIpKYbdgAtG0L2N3NDKc4vDwKeZSIxKIMGTKYeZs8FBEREfEl8RZKBQYGomzZsi7HpU2b1syP4vG3bt0ys6Oefvpps5Iej2f7Htv9/vnnH3P+UqVKoWXLlnjqqadM5RQv079/fzz88MNaeU9EJAbs3Am0aME2Z+v7li2BH37gBwR6eEUSCn5gxwopHoqIiIj4Eu/qqeJBihQpMGPGDDODp127dihfvjwmT56MSZMmmSWPbT/++KOprmLlFY+vW7cuvvrqq3jddxGRxODQIaBZM+DsWev7unWB338HUqaM7z0TEff2ve3bt5tDEREREV8Sr6vvuVu0aJHL98WKFcPvfAcUAa6099NPP8XynomIJB3XrnHuH1uqgaNHreMqVgT+/tseIi4iCQnnaXKcAQ9FREREfEmCCqVERCRu8T3s9u3A2rXAmjXWIcf93bkTdp7ixYHZs4GMGfXTEUmIOEuqTp06miklIiIiPkehlIhIEnL+vBUw2QEUh5izMio8+fMDc+cC2bPH5V6KiIiIiEhSoFBKRCQJuHQJ+Ogj4MMPgStXwj8fFzwtUwaoVg2oXh14+GFWYcTlnopIVLF1j6sPc/EXjjUQERER8RUKpUREEjHOPR47FnjvPeDChXtPL1w4LIDiYeXKXAk1PvZURKIrVapUyJ8/vzkUERER8SUKpUREEqht24C//uJy70CDBkDVqlyZ1LvLXr8OcCHSUaOAU6fCjk+eHHjiCaBjR+v6smaNtd0XkTiSOnVqFC1a1ByKiIiI+BKFUiIiCciJE8DPPwPffw9s2uR6Wrp0QN26QKNG1lapkhUyObt1C5g4EXjrrbCV8+y2vO7dgddft6qjRCTx4Kp7Fy5cMK17KVOmjO/dEREREfGaQikRkQTQYjdtmhVEzZsHhIR4Pl9QEDBrlrVR+vRA/fphIRVX0XvjDWDfPtfLde1qHV+qVOzfFxGJe5cvX8aqVauQLVs2ZFX5o4iIiPgQhVIiIvHgzh1gwQIriPrjDyuYcscZT6xuCggAFi60tpMnw06/fBn45x9r86RtW6tiqmLF2LsfIhL/MmTIgLp165pDEREREV+iUEpEJI7NnAk89RRw7Ni9pxUoADz2mLWVLBl2PM/vcAC7doUFVIsWAWfO3HsdTZoAb78N1KwZu/dDRBKGZMmSITAw0ByKiIiI+BKFUiIicWjJEmvI+I0bYcexuIEtdqyKqlPHmv/kiZ+fFVRx69vXCqnYsseAavFia77U009brXwiknQEBwdj586dSJcundlEREREfIVCKRGROLJlC9C+fVggxRX1+ve32uzYohdVDKnKlrW2AQNifHdFxEfcunULp0+fNociIiIivkShlIhIHDhwAGjZErh0yfqeX0+fDqRIoYdfRO4PZ0nVr19fM6VERETE54TTJCIiIjGFc59atABOnLC+r14d+O03BVIiIiIiIpK0KZQSEYlFQUFA69bAnj3W9yVKAP/+C2jsi4jElEuXLmHx4sXmUERERMSXKJQSEYklN28CnToB69ZZ3+fJA8yeDWTNqodcRGJOihQpkDNnTnMoIiIi4ksUSomIxIKQEODxx4G5c63vM2YEZs0CChTQwy0iMStNmjQoUaKEORQRERHxJQqlRERimMMBDBoE/Pyz9T1X1vv7b2uVPBGRmHbnzh1cuXLFHIqIiIj4EoVSIiIxbPRo4JNPrK+TJQN+/RWoW1cPs4jEDs6SWrZsmWZKiYiIiM9RKCUiEoMmTgSGDg37fsIEoF07PcQiEnvSp0+P2rVrm0MRERERX5I8vndARCSxtOz9+CPw1FNhx73zDtCrV3zulYgkBcmTJ0eGDBnMoYiIiIgvUaWUiMh9hlH//gtUrw50787ZLtbxAwcCQ4booRWR2Hft2jXs2bPHHIqIiIj4EoVSIpIk3bgBzJ5tbVevRi+M4mVr1gTatgXWrQs7rUcP4IMPAD+/GN1lERGPbty4gaNHj5pDEREREV+iOm8RSTIYJK1ZA0yaBPzyC3DhgnV8qlRAo0ZA69ZAmzZA4cIRX8f8+cDw4cCKFa6nVawIjBhhzZBSICUicSVjxoxo1KiRORQRERHxJQqlRCTRO3wY+OEHYPJkYNeue09nccGsWdb23HNAif+zdxdgUpbtF8DPdjfd3SBgoKiIiCgqFnZhxycqtljY/dmF+hkYf7sLAQMJBRQLBaQ7l+3enf91nmfe2ZktZpet2T2/63p9dzrYcWbP3Pf99LbhFEOqgw8GwsPt+b7/Hrj9duDHH30vP2gQcMcdwPHHK4wSERERERHxl0IpEWmSsrKADz6wVVEMk1jh5C0qCjjxRCAmBvjyS2DDhtLTGFxxe/RRIDYWOPxwW1XF6/HWr5+tjOL1BKsZWkQaSHp6OubMmYPDDjsMSUlJ+ncQERGRgKFQSkSajO3bbWsdB49/+CGQk1P+PCNH2plPJ50ExMXZ4xhY/fmnDad4WbbllZSUhlsffeR7HaykYmXUyScDISH18MBERKoQFhaG5ORksxcREREJJAqlRCRgse1u7lzgm2+AGTOAX3+t+Hw9e9og6qyzgC5dyp/O+U9sweN20022KopDzBlSffUVsGNH6fVwltRppymMEpHGIzo6Gv369TN7ERERkUCiUEpEGgSrk377zVY0/fsvwI6TFi2Ali3Lbzyec514mSVLSkOoH37gUugVXz/n/TI8YhjFFfKqM3ic94WX5VZcDPzyC1BQYK8nVP/XFJFGpri4GNnZ2WYfrF5iERERCSD680pE6g1b4rj6HWc9MYxatcr/yyYk2EBo587Kz8PV7zj/iRsHlEdG7vl9Znvefvvt+fWIiNTlTKnZs2dj3LhxaMEUX0RERCRAKJQSkTrFSqM5c0qDqI0ba3Y96enlj2vfvjSEGj0aaNVqj++uiEjAiYuLw3777Wf2IiIiIoFEoZSI1Dq22c2eDbz1FvDxx8C2bRVXIHHo+PjxwKhRQHa2HVRe1cah40OHlgZRfftWry1PRKQp4oDzlJQUDToXERGRgKNQSkRqFauibrnFhlJlcWEohkkMoo491s6KEhGRPZOXl4dVq1YhPj5ew85FREQkoCiUEpFawZXvbr3VrlbnjXOdxo61QdQxx9jZUCIiUntyc3NNKNW7d2+FUiIiIhJQFEqJyB75+2/g9tvtzChvPXsCt90GnHgiEBOjJ1lEpK4kJSVh9OjRZi8iIiISSBRKiUiNcOW8O+8E3njDrqrn6NQJmDIFOOccu1qeiIiIiIiISEWCKzxWRKQSmzYB//kP0Ls3MG1aaSDVujXw5JPA8uXA+ecrkBIRqS8ZGRmYP3++2YuIiIgEEtUxiEiV8vKA+fOB774Dvv8e+OknoLCw9HR2i9x4IzBxotr0REQaQkhICGJjY81eREREJJAolBIRH/n5wM8/2xCKG0MoHldWbCxw9dXAtddqeLmISEOKiYnBwIEDzV5EREQkkCiUEmnmtm4FFi8GFi60lVDz5tnqqMr06GGHl193HdCyZX3eUxERqUhJSQny8vLMPjhYkxlEREQkcCiUEmkmXC5g9WobQHlvmzdXfbmuXYFDD7XbyJFAhw71dY9FRMQfaWlp+O677zBu3Di0aNFCT5qIiIgEDIVSIk3Y3LnA++/b8Om334D09N1fhqvneYdQnTvXxz0VEZGa4jypvffe2+xFREREAolCKZEmaMkS4KabgM8/r/p8iYnAkCHA4MF2f+CBtjIqKKi+7qmIiOyp8PBwtGrVyuxFREREAolCKZEmZMMGYMoU4NVXOWPE97T27W3w5L2xCkoBlIhIYOM8qbVr1yI+Ph7R0dENfXdERERE/KZQSqQJSEsDHnwQePxx3yHlnP90xx3AscdqKLmISFOVm5uLpUuXokePHgqlREREJKAolBKpY199Bdx6axBatkzE2LHA4YcDffvWToVSfj7w7LPAPfcAqamlxyckAJMnA1deCURF7fntiIhI45WUlIQjjjjC7EVEREQCiUIpkTq0YAFw4omsXmICFYnp0+3xbdsChx1WunXsWL3rZWve//0fwy5gzZrS4zlOZOJE4OabgZSU2n0sIiIiIiIiIrVJoZRIHVm3zrbNebfTOTZvBt54w27UqxcwerQNqFq3BnbuLL/t2FH689at9rCDVVdnngncfTfQpYv+SUVEmpPMzEwsWLAAhxxyCBJYKisiIiISIILRSDzwwAMICgrCpEmTfI6fP38+Ro0ahZiYGDPAc8SIEWZ2giM1NRVnnnmmOS0xMREXXHABsrKyGuARiJTKzASOOcaGR3TIIS58/fUOPPxwiWnhi4nxfbaWL7dteOPHAwcdBBx3HHD++cD11/O1Abz4IvDRR8Ds2XZlPe9AaswY4NdfgddfVyAlItIc8fMTV97jXkRERCSQNIpKqYULF2Lq1KkYNGhQuUDqyCOPxOTJk/HUU08hNDQUv//+O4KDS7M0BlKbN2/GjBkzUFhYiPPOOw8XX3wx3nrrrQZ4JCJAcTFw+unAn3/aZ6NHD+C991woLi4y86Suuw4oKAB+/hmYNQuYOdP+XFTk37PHGVEtWtjqqptushVWIiLSfMXGxmLw4MFmLyIiIhJIGjyUYlUTg6UXX3wR93Bas5err74aV155JW7iX95uvXv39vz8zz//4Ouvvzah1j777GOOY3h11FFH4ZFHHkG7du3q8ZGIWNdeC3zxhf05MRH4/HM732nbNt/ZTwcfbDeujsfKKlZBcePwcoZOvIyzeR/W4HIREfHmcrnMF3Pci4iIiASSBg+lLr/8chx99NEYPXq0Tyi1bds2/PzzzyawGj58OFauXIk+ffrg3nvvxUHsb3JXUrFlzwmkiNfDSipe9oQTTqjwNvPz883myMjIMPuSkhKzidTUc88BTzxhK/lCQ114/30Xeva0v1v8Y6Gy3y+287Gtj9vu6FdUmrrdvV5ExBdHGcycORPHHHMMUrTKhYjeZ0T0uUwaAX8/yzdoKPX222/j119/NZVOZa1atcrs77jjDlP1xLL0adOm4bDDDsNff/2Fnj17YsuWLWjVqpXP5djil5ycbE6rzP33348777yz3PHbt29HXkVTqUX88P334bjqqtLluB98MAP9++eaCim+INPT080f2t7tpyJSnl4vItXDL9q6d++OnJwcFLOHXESqpPcZEf/p9SJ7shBLow6l1q9fj6uuusrMgoqMjKw0VbvkkkvMnCgaMmQIZs2ahZdfftkESzXFGVXXXHONT6VUx44d0bJlSzMwXaS6/v6bv6tBKC62Q2avu86FSZPiAMR5fp85gJa/YwqlRKqm14tI9V8zHHSu9xgR/18z+lwmoteL1K2Kcp5GFUr98ssvpkVv6NChnuP47d7s2bPx9NNPY9myZea4fv36+Vyub9++WLdunfm5TZs25jq8FRUVmTJ2nlaZiIgIs5XFsECBgVTX9u3Asccy3LSHuXLeAw8EITjYdxUkfvjR75iIf/R6EalepdTGjRvNSIMoDR4U0fuMSC3T5zKpCX+zlQbrI2Ib3p9//onffvvNs3E2FGdI8edu3bqZQeVOOOVYvnw5OnfubH4+4IADkJaWZgIux7fffmu+/Rg2bFi9PyZpftjtefzxwOrV9vCQIcCbbwIhIQ19z0REpLnIzs42n6m4FxEREQkkDVYpFRcXhwEDBvgcFxMTYwZ0Osdff/31mDJlCvbaay8zU+q1117D0qVL8f7773uqpo488khcdNFFeP75583KMxMnTsRpp52mlfekznGRowsvBObNs4e52ONnn9mh5SIiIvUlKSkJRxxxhNmLiIiIBJIGX32vKpMmTTKDx6+++mrTksdwijOoOMzT8eabb5ogipVXLA8bP348nnzyyQa939J0cF4sO0Q3bfLdNm9m1R7www/2fNHRNpBq376h77GIiDTXtgruRURERAJJkIvLgTVzHHSekJBgVkfToPPm7c8/geefB37+2YZPW7dyGGbVl+HfAB98AJxwQuXnYUsp559xtUjNLROpml4vItXDzy9z5szBQQcdZD7PiIjeZ0Rqiz6XSV3nLI26UkqkPhQWAh99BDzzDDB7dvUuy8/+Dz9cdSAlIiIiIiIiIuUplJJmiy14L74ITJ1qq6K8caEALuDIOVHc2rYt/dl7a9HCnldERKQh53TuvffeZi8iIiISSBRKSbPCZtW5c21VFOflFxX5nt6nDzBxInD22UAVFYYiIiKNBicxsL1CExlEREQk0CiUkoDGeU+//Qakpto2vIICu3c278NZWcC77wK//+57Hax0Ou444PLLgVGj7IwoERGRQLFr1y5Mnz4d48aNQwuW8IqIiIgECIVSEpBY4fTee8D999vh5DXBz+0XXwxccgnQqVNt30MREZH6ERMTg4EDB5q9iIiISCBRKCUBJT8feP114IEHgJUra3Ydw4bZqqiTTwYiI2v7HoqIiNSviIgIdOjQwexFREREAolCKQkI2dnASy/Zle42biwfMh12GBAeDoSF2c37Z++NM6MGDWqoRyEiIlL7CgoKsHnzZiQmJiJS37aIiIhIAFEoJY1aWhrw7LPAY48BO3b4nsYg6uabgUMP1RwoERFpvrKysvDbb7+hY8eOCqVEREQkoCiUkkY5L2rJEuCdd+wqeRkZvqcfeywweTKw//4NdQ9FREQaj6SkJIwePdrsRURERAKJQilpUC4XsGoVsHAhsGCB3X79FcjNLb9C3mmnATfdBAwc2FD3VkREpPEJCgpCWFiY2YuIiIgEEoVSUiuWLwf+/hsICbEbQyTvvffP27eXhlDcp6ZWfr2cA3XuucANNwA9eugfS0REpLL2veHDhyM+Pl5PkIiIiAQMhVKyR/LybPXSE0/U3hPZtSuw777AfvsBp54KdOhQe9ctIiLS1LhcLjPsnHsRERGRQKJQSmrsjz+AM88E/vqr5tfRsqUNn5wQap997HEiIiLin7i4OOy3335mLyIiIhJIFEpJtZWUAI8/boeNFxTY4yIigCuuABITgeJie57K9lyteuhQG0R17qyV80RERERERESaI4VSUi0bNwITJgCzZpUeN2gQ8NZbQP/+ejJFRETq265duzB9+nQcc8wxSElJ0T+AiIiIBIzghr4DUr8KC4EnnwTGjgUuugh45x07eNwf779vV77zDqSuu84OLFcgJSIi0jCioqLQp08fsxcREREJJKqUaiY4+/TLL4FrrwWWLSs9/qWX7H7IEGD0aLsdfDA/4JaeJzMTuPJK4NVXS49r3x6YNg0YNaoeH4SIiIiUExkZic6dO5u9iIiISCBRKNUM/P03cM01wPTplZ9n8WK7PfywnQ914IE2oOrZE7jxRmDVqtLznnwy8PzzQHJyvdx9ERERqQJX3tu2bRsSExMVTImIiEhAUSjVhO3cCdxxB/Dcc3bIuIOB00MPATk5wIwZwMyZNpByVpLOzwe+/dZu3mJjgaefBs45R8PJRUREGousrCz88ssvaNeunUIpERERCSgKpZro3CgGUQykdu0qPb5TJ1sJxUqnoCB7HKuhaMcOG0IxoGJQtWaN73UOHw68/jrQrVs9PhARERHZLVZIHXrooWYvIiIiEkgUSjUxX39tW/X++af0uOhoYPJkO0+qshmoLVoAp5xiN1ZMsV2PAdXcucDgwXamVKh+W0RERBqd4OBgUyHFvYiIiEggUczQRCxfDkyaBHz1le/xbLW7/36gXTv/r4tVVN272+2SS2r9roqIiEgtys7Oxp9//on9998fcXFxem5FREQkYCiUaiI2bPANpNhu9/jjwL77NuS9EhERkbpWXFxs5kpxLyIiIhJIVOfdRIwaBRx3HNCxI/DWW8CcOQqkREREmoP4+HgccMABZi8iIiISSFQp1YRMnQqwap8zpEREREREREREGjNVSjUhrVsrkBIREWludu3ahZkzZ5q9iIiISCBRKCUiIiISwKKiotCtWzezFxEREQkkCqVEREREAlhkZKQJpbgXERERCSQKpUREREQCWGFhIXbu3Gn2IiIiIoFEoZSIiIhIAMvMzMSCBQvMXkRERCSQKJQSERERCWAJCQkYMWKE2YuIiIgEEoVSIiIiIgEsJCQEMTExZi8iIiISSBRKiYiIiASwnJwc/P3332YvIiIiEkgUSomIiIgEMA44T01N1aBzERERCTgKpUREREQCGGdJHXTQQZopJSIiIgFHoZSIiIiIiIiIiNS70Pq/ycbH5XKZfUZGRkPfFWmiSkpKzFLdkZGRCA5WFiyi14tI7WHr3qxZs3DYYYchOTlZT62IPpeJ1Br9HSM15eQrTt5SGYVSgAkLqGPHjjV+wkVERERERERExDdv4aiBygS5dhdbNZP0d9OmTYiLi0NQUFBD3x1poikxQ8/169cjPj6+oe+OSKOm14uIXjMiep8RaRz0uUxqilETA6l27dpV2S2kSikO1goORocOHWr8ZIv4i4GUQikRvV5E6oLeY0T0mhGpK3qPkZqoqkLKoeE2IiIiIiIiIiJS7xRKiYiIiIiIiIhIvVMoJVIPIiIiMGXKFLMXEb1eRPQeI9Jw9LlMRK8XaTw06FxEREREREREROqdKqVERERERERERKTeKZQSEREREREREZF6p1BKRERERERERETqnUIpkVrwwAMPICgoCJMmTfI5fv78+Rg1ahRiYmIQHx+PESNGIDc313N6amoqzjzzTHNaYmIiLrjgAmRlZenfRJrla2bLli04++yz0aZNG/OaGTp0KD744AOfy+k1I83FHXfcYV4j3lufPn08p+fl5eHyyy9HSkoKYmNjMX78eGzdutXnOtatW4ejjz4a0dHRaNWqFa6//noUFRU1wKMRadjXDN87rrjiCvTu3RtRUVHo1KkTrrzySqSnp/tch14z0lzs7j3G4XK5MHbsWHP6xx9/7HOaXi9SW0Jr7ZpEmqmFCxdi6tSpGDRoULlA6sgjj8TkyZPx1FNPITQ0FL///juCg0uzYAZSmzdvxowZM1BYWIjzzjsPF198Md56660GeCQiDfuaOeecc5CWloZPP/0ULVq0MK+DU045BYsWLcKQIUPMefSakeakf//+mDlzpucw30ccV199Nb744gu89957SEhIwMSJE3HiiSdi7ty55vTi4mITSDHknTdvnnmv4WssLCwM9913X4M8HpGGes1s2rTJbI888gj69euHtWvX4tJLLzXHvf/+++Y8es1Ic1PVe4zj8ccfN4FUWXq9SK1yiUiNZWZmunr27OmaMWOG65BDDnFdddVVntOGDRvmuvXWWyu97N9//+3iS3DhwoWe47766itXUFCQa+PGjfpXkWb3momJiXFNmzbN5/zJycmuF1980fys14w0J1OmTHHttddeFZ6WlpbmCgsLc7333nue4/755x/znjJ//nxz+Msvv3QFBwe7tmzZ4jnPc88954qPj3fl5+fXwyMQaTyvmYq8++67rvDwcFdhYaE5rNeMNCf+vF4WL17sat++vWvz5s3m/eWjjz7ynKbXi9Qmte+J7AG2TvCb6NGjR/scv23bNvz888+mXWL48OFo3bo1DjnkEMyZM8enkoote/vss4/nOF4PK6l4WZHm9Johvlbeeecd02ZRUlKCt99+27QojRw50pyu14w0N//++y/atWuHbt26mSpBtkrQL7/8YqprvV9HbLtgSxJfJ8T9wIEDzfuP44gjjkBGRgaWLFnSAI9GpOFeMxVh6x7HJzjVIXrNSHNT1eslJycHZ5xxBp555hlTcVuWXi9Sm9S+J1JD/IP5119/Na1IZa1atcrTr81S8cGDB2PatGk47LDD8Ndff6Fnz55mfg5DK58XZGgokpOTzWkizek1Q++++y5OPfVUMyOHrwXOwfnoo4/Qo0cPc7peM9KcDBs2DK+++qqZgcPWuzvvvBMHH3yweQ/hayE8PNx8seGNAZTz/sG9dyDlnO6cJtKcXjNxcXE+592xYwfuvvtuMzLBodeMNCe7e72wRZxfFh533HEVXl6vF6lNCqVEamD9+vW46qqrzCyoyMjIcqezyoMuueQSMyeKOBNn1qxZePnll3H//ffreZdmZXevGbrtttvMTCnON+BMKQ7U5EypH3/80VR8iDQnHCzr4Pw1/gHRuXNnE95yULOI+P+a4UIyDlYLsmKXs6X45aFIc1TV66Vly5b49ttvsXjx4ga9j9J8qH1PpAbYOsEWPa4OxooObj/88AOefPJJ87PzbTQ/8Hjr27evpzSWpbC8Dm9cFYmtSxWVyYo05dfMypUr8fTTT5vQlhWFe+21F6ZMmWLaW1k6TnrNSHPGqqhevXphxYoV5rVQUFBgQlxvXH3Pef/gvuxqfM5hvcdIc3vNODIzM80iNKwEYSUuB/879JqR5sz79cJAip/LeJzzmY24yqszUkGvF6lNCqVEaoB/NP/555/47bffPBv/eGY/Nn9mbzZ7tJctW+ZzueXLl5tvIeiAAw4wf1Dwj3UH3wRYZcVvK0Sa02uGswvIe3VKCgkJ8VQe6jUjzVlWVpb5I6Ft27bYe++9zR/TrL518P2GX3rwdULc8zXn/eUHKxU5Q6fsFyYiTf0141RIjRkzxrS+cpXXslW7es1Ic+b9ernpppvwxx9/+Hxmo8ceewyvvPKK+VmvF6lVtTo2XaQZK7uS2GOPPWZWOeLqSP/++69ZiS8yMtK1YsUKz3mOPPJI15AhQ1w///yza86cOWZVstNPP72BHoFIw71mCgoKXD169HAdfPDB5vXA18kjjzxiVqP84osvPJfRa0aai2uvvdb1/fffu1avXu2aO3eua/To0a4WLVq4tm3bZk6/9NJLXZ06dXJ9++23rkWLFrkOOOAAszmKiopcAwYMcI0ZM8b122+/ub7++mtXy5YtXZMnT27ARyXSMK+Z9PR0syrywIEDzfsLVxNzNr5WSK8ZaU529x5TVtnV9/R6kdqkmVIidWTSpElm5TAOCmRLHtuR+C119+7dPed58803MXHiRFNFwgoRlsWynUmkuWHVx5dffmm+nRs3bpz5xo4Dzl977TUcddRRnvPpNSPNxYYNG3D66adj586dZr7HQQcdhJ9++sn87Hxj7bxv5Ofnm5X1nn32WZ8qw88//xyXXXaZ+UY7JiYGEyZMwF133dWAj0qkYV4z33//vWdlY2fxDMfq1avRpUsXvWakWdnde8zu6D1GalMQk6lavUYREREREREREZHd0EwpERERERERERGpdwqlRERERERERESk3imUEhERERERERGReqdQSkRERERERERE6p1CKRERERERERERqXcKpUREREREREREpN4plBIRERERERERkXqnUEpEREREREREROqdQikRERGRRuTcc8/F8ccf39B3Q0RERKTOhdb9TYiIiIgIBQUFVflETJkyBU888QRcLpeeMBEREWnyFEqJiIiI1JPNmzd7fn7nnXdw++23Y9myZZ7jYmNjzSYiIiLSHKh9T0RERKSetGnTxrMlJCSYyinv4xhIlW3fGzlyJK644gpMmjQJSUlJaN26NV588UVkZ2fjvPPOQ1xcHHr06IGvvvrK57b++usvjB071lwnL3P22Wdjx44d+rcWERGRRkOhlIiIiEgj99prr6FFixZYsGCBCaguu+wynHzyyRg+fDh+/fVXjBkzxoROOTk55vxpaWkYNWoUhgwZgkWLFuHrr7/G1q1bccoppzT0QxERERHxUCglIiIi0sjttddeuPXWW9GzZ09MnjwZkZGRJqS66KKLzHFsA9y5cyf++OMPc/6nn37aBFL33Xcf+vTpY35++eWX8d1332H58uUN/XBEREREDM2UEhEREWnkBg0a5Pk5JCQEKSkpGDhwoOc4tufRtm3bzP733383AVRF86lWrlyJXr161cv9FhEREamKQikRERGRRi4sLMznMGdReR/nrOpXUlJi9llZWRg3bhwefPDBctfVtm3bOr+/IiIiIv5QKCUiIiLSxAwdOhQffPABunTpgtBQfdwTERGRxkkzpURERESamMsvvxypqak4/fTTsXDhQtOyN336dLNaX3FxcUPfPRERERFDoZSIiIhIE9OuXTvMnTvXBFBcmY/zpyZNmoTExEQEB+vjn4iIiDQOQS6Xy9XQd0JERERERERERJoXfVUmIiIiIiIiIiL1TqGUiIiIiIiIiIjUO4VSIiIiIiIiIiJS7xRKiYiIiIiIiIhIvVMoJSIiIiIiIiIi9U6hlIiIiIiIiIiI1DuFUiIiIiIiIiIiUu8USomIiIiIiIiISL1TKCUiIiIiIiIiIvVOoZSIiIiIiIiIiNQ7hVIiIiIiIiIiIlLvFEqJiIiIiIiIiEi9UyglIiIiIiIiIiL1TqGUiIiIiIiIiIjUO4VSIiIiIiIiIiJS7xRKiYiIiIiIiIhIvVMoJSIiIiIiIiIi9U6hlIiIiNS6c889F126dNEzWw9effVVBAUFYc2aNZ7jRo4caTYRERGRxkyhlIiIiPiFwYc/2/fff+/X5ePj43HIIYfgiy++aLB/gezsbNx9990YNGgQoqOjkZCQgIMPPhivv/46XC4XGpP77rsPH3/8cYOFjJX9e3/99ddo6hryuRcREWnKglyN7ROXiIiINEpvvPGGz+Fp06ZhxowZJsDxdvjhhyM5ORklJSWIiIjwHM8Ag6edc845JvBZu3YtnnvuOWzevBlfffUVjjjiCNSnrVu34rDDDsM///yD0047zQRkeXl5+OCDDzB79mycccYZ5rEFBzeO7/BiY2Nx0kknmcoob8XFxSgsLDTPNZ9jcqqkKgsIaxJKvf3223jppZfKncbnsG3btmjKKnvuRUREZM+E7uHlRUREpJk466yzfA7/9NNPJpQqe3xVevXq5XP+8ePHo1+/fnjiiSfqPZSaMGGCCaQ++ugjHHvssZ7jr7zySlx//fV45JFHMHjwYPNzYxYSEmK2uhYaGlqtf+vqyMnJMZVqIiIi0rw0jq/+REREpFnOlOrbty9atGiBlStX+hyfn5+PKVOmoEePHqYCqGPHjrjhhhvM8d6hUmRkpAmWvDHcSkpKwqZNmyq9XQZq06dPN/fTO5By3H///ejZsyceeOAB5ObmeqqOKmpP5CwnHu9dRfPHH3+Y6+7WrZu5j23atMH555+PnTt3+lz2jjvuMJddsWKFOX9iYqJpITzvvPNMUOPgedhq+Nprr3na5nj+ymZKVcSf53RPPfvss+jfv7+5/nbt2uHyyy9HWlqaz3lYxTVgwAD88ssvGDFihAmjbr755mrfR1bu7bfffuby/PfmdX3zzTee0z/55BMcffTR5n7wurp3725aNVlZ5u3ff/814Sj/jfhv1aFDB1M5l56evtvnXkRERPaMKqVERESkwfAP/127dpnAwMG2PwZFc+bMwcUXX2yCqz///BOPPfYYli9f7pntw+qqb7/91oRT8+fPN9VCU6dONcEE2+4YRlTms88+M3u2ElZWFcT2vTvvvBPz5s0zLWrVwQqyVatWmXCJYceSJUvwwgsvmD0DMafNznHKKaega9euJgz79ddfTZtcq1at8OCDD5rT+XguvPBCE8LwOSHv52x3/H1Od2fHjh0+h8PCwkyI5gRsfL5Gjx6Nyy67DMuWLTPtmQsXLsTcuXPNeR0M58aOHWvCH1ZftW7dulr3kbfD2xs+fDjuuusuhIeH4+effza/D2PGjPGEdWy7u+aaa8yep91+++3IyMjAww8/bM5TUFBgQkyGXldccYX5t9q4cSM+//xzE6bxse3pcy8iIiJV4EwpERERkeq6/PLLOZeywtMmTJjg6ty5s89xPO8FF1zg2r59u2vbtm2uRYsWuY488khz/MMPP+w53+uvv+4KDg52/fjjjz6Xf/755815586d6zlu+vTp5rh77rnHtWrVKldsbKzr+OOP3+1953l4uV27dlV6ng8//NCc58knnzSHv/vuO3OYe2+rV682x7/yyiue43Jycspd3//93/+Z882ePdtz3JQpU8xx559/vs95TzjhBFdKSorPcTExMeZ5LYu3y+vg/XAccsghZqvJc1oR3i7PV3ZzboP/nuHh4a4xY8a4iouLPZd7+umnzflefvlln/vG43jb3vy9j//++685H58j79uikpKSKv8NLrnkEld0dLQrLy/PHF68eLG57vfee6/Kx1/Zcy8iIiJ7Ru17IiIiUm/+97//oWXLlqYKaJ999sGsWbNMexarWRzvvfeeqZLp06ePqcxxtlGjRpnTv/vuO895WRVzySWXmGqZE0880bRfsVpqdzIzM80+Li6u0vM4pznnrY6oqCjPzxyezvu///77m8OshCrr0ksv9TnMFQBZTcSqntpQnee0MnxuWQHmvf33v/81p82cOdNUHU2aNMlnMPxFF11kVlksu8Ii2+lYRVaT+8iKKVZVseqp7BB67wo0738D/hvyuvi8si1y6dKl5ninyoutnN7tkiIiIlI/1L4nIiIi9ea4447DxIkTTYDBtq777rvPhAHe4QJn/HBOFMOrimzbts3nMAeSc37Qb7/9hrfeessEXrvjHThxjlNFnDDKn+srKzU11bSYccW6svfXmVXkrVOnTj6HOSOJ2NrIUGdPVfc5rQjbI9maVxGupEi9e/f2OZ5tdZyr5ZzuaN++vTmtJveR88f4+8IB+VVhq+Stt95q2vbKhnvOvwFbJhmIPvroo3jzzTdNaMUWQrYUOoGViIiI1B2FUiIiIlJvOETaCTaOOuooM+ScIdWhhx5qKp2IVTADBw40QUFFOPza2+LFiz2BBWcQnX766bu9Hww0WHHDgeQckF0RnkYMVajsHChH2cHZzowozqLiyn1cwY8zjfi4jjzySLMvq7LV82zX456r7nNa17yrmOriPnIe1CGHHGICPVbRcQYUK71YpXbjjTf6/Buw2ouDyxlsch4ZV1/kbC/O/uLvq4iIiNQdhVIiIiLSYNh6x0HWrGg54YQTTPDDAOH33383w8UrC4IcXBWNbWAMmTj0+qGHHjLXs++++1Z5uXHjxpkqrWnTplUYSjFoYtUVB3A7pzvVS2VXkytbBcTqJrYlslKKLWbelUB7YnfPRVWq85zWROfOnc2ew82dEI9YEbd69epKK6xqch95PoZKf//9twn8KsIVEtn++OGHH/r8+/K+VIRhGDf+HjJMPPDAA/H888/jnnvuMafXxXMmIiIigGZKiYiISIPhKnfXXnutadtipYpTZcQV0F588cVy58/NzTVBlINVL+vWrcNrr71mKmy6dOliVuPjampV4XwnzqN65ZVXzEprZd1yyy1mxTfOu+J9dIIXVjTNnj3b57zPPvtshVVPZaucHn/8ceyJmJiYcoGYv6rznNYEQye24z355JM+j5szxNgqd/TRR9fafTz++ONN+x4roMpWnTm3XdG/AQOysv9WbOsrKiryOY7hFK/f+3doT557ERERqZwqpURERKRBsXWKFUUPPvigCRzOPvtsvPvuu2b4N4dbs2qFlUscTs3jOZSaQ9I5K4ghw5QpUzB06FBzXQyZRo4cidtuu81UTVWFVVIcos05V2eccYaZJ8QggtU1rLThXKGrr77ac37OGDr55JPx1FNPeSq6GGiVncfEljFW5/D2CwsLzfwktoVVVqXjr7333tsMFGf41q5dOzMPadiwYX5d1t/ntKY4B2ry5MmmOowtipzLxKop/vuwao3PZW3dxx49epjQ8O677zb/Zmz75OB0zijj88LWO1bNsbKNASXb8fjv9frrr5cLCvk7xPZR/rv26tXLBFQ8H0Ot8ePH18pzLyIiIlXYw9X7REREpJm6/PLL+Rd+hadNmDDB1blzZ5/jeF5epiJ33HGHOf27774zhwsKClwPPvigq3///q6IiAhXUlKSa++993bdeeedrvT0dFdGRoa5/qFDh7oKCwt9ruvqq692BQcHu+bPn7/bx5CZmWmuk7cTGRlp7gO32267rcLzb9++3TV+/HhXdHS0uU+XXHKJ66+//jKXeeWVVzzn27Bhg+uEE05wJSYmuhISElwnn3yya9OmTeZ8U6ZM8ZyPP/M4Xq83XhePX716tee4pUuXukaMGOGKiooyp/E5ruy8hxxyiNm87e45rQpvKyYmZrfP59NPP+3q06ePKywszNW6dWvXZZdd5tq1a5fPeXi/eB8qUp37+PLLL7uGDBniOR+vd8aMGZ7T586d69p///3N89WuXTvXDTfc4Jo+fbrP79mqVatc559/vqt79+7m3z85Odl16KGHumbOnOlzW5U99yIiIrJngvifqkIrERERkeaC7WOssmHFzPz588utiiciIiIitUczpURERETc2Gr39ddfIy8vD2PHjjVDy0VERESkbqhSSkRERERERERE6p0qpUREREREREREpN4plBIRERERERERkXqnUEpEREREREREROqdQikREREREREREal3ofV/k41PSUkJNm3ahLi4OAQFBTX03RERERERERERCVgulwuZmZlo164dgoMrr4dSKAWYQKpjx471+e8jIiIiIiIiItKkrV+/Hh06dKj0dIVSgKmQcp6s+Pj4+vvXkWZVjbd9+3a0bNmyypRYRPR6Eamu9PR0zJ07FwceeCASEhL0BIroc5lIrdHfMVJTGRkZpvjHyVsqo1AK8LTsMZBSKCV19T/zvLw88/ulUEpErxeR2paYmGgCKX2OEdHnMpHapL9jZE/tbkSSSjZEREREAlhsbCwGDx5s9iIiIiKBRKGUiIiISIAPEi0sLDR7ERERkUCiUEpEREQkgO3atQszZ840exEREZFAoplS1eilLSgoqNt/DWnSvz/8FptzpWo6Uyo8PFzzqEREpBy174mIiEigUijlB4ZRq1evNsGCSE2wpYK/P5mZmbsd9FYZhlldu3Y14ZSIiIiD7wtt27bV+4OIiIgEHIVSfoQJmzdvRkhIiFnOUCunSU1/j4qKihAaGlqjUIqB1qZNm8zvYqdOnWocbImISNOTn5+PDRs2mNX3oqKiGvruiIiIiPhNodRuMEjIyclBu3btEB0d7f8zK1KLoRS1bNnSBFO8nrCwMD2/IiJiZGdn488//0SXLl0USomIiEhA0aDz3SguLjZ7tUxJQ3N+B53fSREREUpKSsIRRxxh9iIiIiKBRKGUn9QuJQ1Nv4MiIlLZ+wPHC+h9QkRERAKNQikRERGRAMZFNH755RezFxEREQkkmiklfuOsikmTJpnNH99//z0OPfRQ7Nq1C4mJiXqmRUREREREpFl67LHHMHPmTM/K7N6by+u4O+64A4cddhiaC4VSTdDuyvenTJliftGra+HChYiJifH7/MOHDzerxXE1oLrkhF/OY4+Li0O3bt1w+OGH4+qrrzbLZFcHr+Ojjz7C8ccfX0f3WEREpPbwfW/vvfc2exEREWmc/vjjD3z55Ze7Pd+2bdvQnKh9rwliEORsjz/+OOLj432Ou+6668qtCufv6m/VWYGQg7nbtGlTbzMuli1bZlanY3h24403mhR6wIABZkUiERGRpsr5dpV7ERERaThclOrDDz/ESSedhMLCQp/T/P27uKSkBM2JQqkmiEGQs7FKib/8zuGlS5eab1K/+uor861qREQE5syZg5UrV+K4445D69atERsbi3333deEOmXb9xhyOXi9L730Ek444QQTVvXs2ROffvqpTwUTz5OWlmYOv/rqq6aNb/r06ejbt6+5nSOPPNIEZQ4GZFdeeaU5X0pKigmXJkyY4FfVUqtWrcxj7NWrF0477TTMnTvXBGmXXXaZ5zwMrFhB1aJFC/PcHHLIIfj11199HiPxMfG+O4f9eX5EREQaAtvk+d7KvYiIiNS/rKwsPPXUU+Zv0fHjx+ODDz4wm7cnnngCO3bsQGpqqvkbOSMjw1wuOzsbubm5yM/PN0HW6aef3qz+CRVKNVM33XQTHnjgAfzzzz8YNGiQeTEcddRRmDVrFhYvXmzConHjxmHdunVVXs+dd96JU045xZQi8vJnnnmmeZFVJicnB4888ghef/11zJ4921y/d+XWgw8+iDfffBOvvPKKCZX4Qv34449r9BijoqJw6aWXmutxSiA5BJYhF4O4n376yQRpvN/OcFiGVsTbZ1jmHK7p8yMiIlLX2Fo/cODAarXYi4iISM2xOplh0r///msKKTp27GiKK1atWuU5z2effeZzGRaHsPAiKSnJFEjwcExMjCnwiIyMNJ1GoaGhZkXd5kQzpWpgn32ALVtQ79q0ARYtqp3ruuuuu0zFkCM5ORl77bWX5/Ddd99t5iqx8mnixImVXs+5557rSXLvu+8+PPnkk1iwYIEJbSrC5Pf5559H9+7dzWFeN++Lg+ny5MmTTaUSPf3003713VamT58+Zr9mzRpTSTVq1Cif01944QVTlfXDDz/gmGOOMZVVxONYdeXgc1OT50dERKSuseq5Q4cOZi8iIiJ7Zvv27aZQYuPGjaai6Z577jEdM44XX3wR//nPfyodgzNmzBhcc801Zi+7p1CqBhhIbdyIgLYPkzUvrATi8PMvvvjCVAjxBcYSwt1VArHKysGUl/OrqhrMxhTYCaSIQ8id86enp2Pr1q3Yb7/9PKeHhISYNsOa9tU68zWc/l1e/6233mpaC3m77Pll9dbuHmdNnx8REZG6VlBQYN6b+IUKv2kVERGRmnn//ffN+Be22Tkuv/xyn1CK77VlAylWObFriAttsXpZ/KdQqga8CmgC9nbLlvizhW7GjBmmta5Hjx6m9Y3D2fhBtyphYWE+hxn+VBUgVXT+uhzMyvZEcmZDsXVv586dpp+3c+fO5lvlAw44YLePs6bPj4iISF3jFye//fabaR1QKCUiIlJ9/BuR4dM777xT7jRnRrKjffv2GDJkiPkyiG14/Pniiy/26bQR/ymUqoHaaqFrTDh3ia14TtscP+Cy5a0+8QXNBJpznEaMGGGOYyUTB5EPHjy42tfHSia25/G6nLY8Ps5nn33WzIei9evX+6TgTnDG221sz4+IiEhFOJti9OjRZi8iIiLV88knn+CSSy4xXTUO/t131VVXmTE33p0+xJEw3otlyZ5RKCUGB35z6UoO72b10m233dYgS1FeccUVuP/++001EudBccYUVxPyZ/lMtuPl5eWZoeW//PILHnroIRM48XF5P04OWWf7IoeoX3/99abqyRurqjjQ/MADDzSVVPyQ31ieHxERkbL4vsQvVPxdalpERETs6rUMnvj3oYN/+z3zzDNmNXe9r9aP5jXWXSr16KOPmhfg8OHDTfByxBFHYOjQofX+jHHlAg5OP+ecc0xbXWxsrLkv/rQj9O7dG+3atTMzqLiyIL81/uuvv9CvXz/Pef73v/+Z//nwsZ199tlmhQQOQPf23//+17TqsQ2CpZiN6fkRERGprH2PexEREfEP/1b0DqS48NWSJUvM36MKpOpPkKsuB/oECFbMsHWMg7Y5qNsbK29Wr16Nrl27ak5DA2A1Ut++fXHKKaeYFe8CFV9mHIbHJT5r+j84/S5Kc3rds/KRgXFzWxJXpCb4+YWryB5yyCHm84yIVE3vMyL+a+qvl0mTJuHVV181M4dZGKEwqn5yFm9N77dKAtratWvNEpvLly/Hn3/+aVY+YCh4xhlnNPRdExERaZTi4uLMyrXci4iINDVcXKo2amkWLFhQbgTLfffdZyqmuCCWAqmGoVBKGhWm70yq9913XzPTicHUzJkzTbWUiIiIiIiINE0bNmzAW2+95XMcF6AaP368KVYoLCys0fXyOu644w7sv//+Zl6Ut+joaHTo0GGP7rfsGQ06l0aFc5y40p2IiIj4h7MSp0+fbmZhpKSk6GkTEZGAkpaWhgcffBCPP/64GXnCAgUuNEW33HILPv/8c/Pz0qVL8f7776NFixZ+XzdbD88880xT6ODMMD722GPRuXPnOno0Ul2qlBIREREJYFxFlivWll1NVkREpDHLz8/HY489hu7du5uFqjhDl6GU9yzh/v37Izw83PzM+YlsV+cwcn/8+OOPGDx4sCeQYlcOV1FnIYQ0HgqlRERERAIYV6jlN77+rFQrIiLS0DjX6Y033jCrp19zzTVITU01xzN8uvrqq01Q5eCK6QyjWrdubQ5z3jDb8Jzqqcqu/6GHHsKhhx6KzZs3m+PatGmDWbNmYfLkyY1vYHtxAVCQDuRuBrJWAam/Afn2OWkOGtm/hoiIiIhUdwAs2xO4FxERacx++eUX7L333iZs4iJXDrbYLVu2DI8++mi5VnSGUAsXLsTQoUPN4aysLNOCx+Cp7AB0BlzHHXecadPjLCkaNWoUfvvtN4wcObJuHpSrxGtz+W4+53MBRbk2cMrZAKQvBXb8BGybDWyfA2z/Cdj1B5C1EijOQXOhmVIiIiIiAYwfzvkhv127dqqWEhGRRmvGjBlm/qH3lyhjxowxrXtDhgyp8rJsuWM73nnnnYd3333XhFEMnrhy3gsvvGDe/9jWd9RRR2HdunXmMlxN79Zbb8WUKVMQEhJSOw+ipBAoyrGhUWE2ULALKM6q4IxBFRx2AcX5QAm3YvYTAsGRQEgEEBYLBIfZs2ZvQHOiUEpEREQkgCUmJpoWBe5FREQaqwMOOADdunUzA8v32msvPPLIIxg9erTfl+dKeW+//TYGDBiA22+/3Rz3+uuvo0uXLrjrrrvQtm1bE0QRh6GzRfCII47Ys7Y6hk8MoYoYQKUChVlASZ4Npxg0hYQDweFeIVSZ6qiyQqOAkCQgqJZCsiZAoZSIiIhIAONsDH5D3OhmZIiIiHiJjY3Fe++9h9deew333nuvZ4B5dTB04rDyfv364ZxzzjFzqVgxRcnJyaaK6qabbsK0adPQoUOHiq+kpMiGSq5Cuzdbgd0X59oWu5JcG0qZAKrIHUBFACGRQFhKaVVTdbmK7cbrNj8XubdiWz3Ffc5GIKFPs/ndadBQ6o477sCdd97pcxx/qZicemNpHsvwvv76a3z00Uc4/vjjPaexNO+yyy7Dd999Z37JJ0yYgPvvvx+hocrbREREpOnLzs7Gn3/+aWZuxMXFNfTdERERMX/D/+9//8Nhhx2Grl27ep4RVjk9/PDDe/wMjR8/3lRdsSIqJibGczxX5+NAc1MxxRlODJlM0MR2u0ygMM0eLnGHQSZw8qpuYgVTcKgNnbiFxdnD/uL1FefZrcS9d267KNMdhpWwDIsT2QFwDhXDKPfPDL8K0oCEvkB872bxm9TgyQ2XeHSWaKSKwqTHH3/cU4bnjYPLjj76aDNJf968eWayPtPSsLAw3HfffWiuKnquvLGnloFgTa+7bDC4u/vAMkvOuTjwwANxxRVXmMF21cGBdFzKk78HIiIiUv7zEOdKOQNdRUREakNmZqapSpo/f775m4ytcGwX393fm3xPuuSSS/DWW29h3333xZw5c2pUFbU7PnOoTBhkA6ggEwKl23DHCYcYUPF+s9KJ7XahMTZsCuJW9eMpX2XFsCnffd3uvQm8MtyBl7vqimGTEVQacjmhVxDvAyucg+1xQdy7K555v5uRBg+lGEIxVKoMp+T/97//xaJFi0yPqLdvvvkGf//9twm1uEQkg4u7777blO8xdKmLX/xA4Cx7Se+8847pt+VKBg5WlNWHV155BUceeSTy8vKwfPlyM4Bu2LBhePnll014KCIiInsuPj7ezOngXkREpDbMnj0b5557LlavXm0OL1iwAJ9//rkZJl4VVu6efPLJnr8/uWreZ599Ziqbqs2sYFdcQaud+zDb7BhAmRa7AndAxCHqLhsAMYBi+BSSXBr4VHpbJRW39JlKJ26sdMpyB1FsvSt0V1mZC9twi2GXCbzi3CFUdSqsCoDcHUDeViDtTyC6PdBmFJqDBg+l/v33X89qMfxAxda7Tp06mdNycnJwxhln4JlnnqkwuGJiO3DgQBNIOZjesp2PL5bdTfBvqryfq4SEBJNkex/30ksvmaCP/4PhULgrr7wS//nPf8xpXAnhmmuuwQcffIBdu3aZ5/bSSy/F5MmTzXnphBNOMPvOnTtjzZo1ld4PDlx1bpeX5coKbK+cOHEixo0bh6SkJOzcudMc5v/0eHvdu3fHzTffjNNPP91cjv8j/OGHH8z2xBNPmON4v7n6wsUXX4xvv/0WW7ZsMb8zfAxXXXVVnTynIiIiIiIiTR0LCm655RY89thjpgXPG/+eK4t/f3N2E09LS0vDpEmTzHUQW8rZwmcCKSf0caqInEoiz1wl95wlJ1wyp7MqyWvuUmWtdiYQCgXCEoCIiPKVT3wcDLCKs90hFq+/wIZNTnufsyKe57aK3e10buZ23NVOpsoqrPpVVsSB6XnbbPhk9tvszxyi7v3YeBvNRIOGUqyaefXVV80cKVb3cL7UwQcfbJZ15C/w1VdfjeHDh+O4446r8PIMI7wDKXIO87TK5Ofnm82RkZFh9iUlJWbzxsN8MTpboHHus7N/8803TeXUU089ZUK7xYsXm3CHLXYMjBj8fPrpp6bCikHP+vXrzcbLMx3n88tKJ1ZAcVnNqp6Tip4z/k+KQ+dY5XbKKacgNzcXQ4cOxQ033GC+4f3iiy9w9tlnm/5g9gOzZY9VVmzz5IoK1LJlS9Oi0L59ezPILiUlxbRvskSUIRivNxD+LWpyeW4V/Z6KNCXO/3f1ey7in9TUVFM1zvdmDnkVEb3PiNTEL7/8YooC2I3kOOigg3Drrbdi27Zt5m8y789nGzZsMH/XEf9G9DZ4UD+888pj6NG5FUq2zXVXMXHFOne4VPZvIhPuBLnb2EK89gyeov1rtfMJn9xVVGyFM3OkcmzLnZnd5HWb5jq9wy229/F2Q0urq3i9JsTKds+GyvZsQdzzsTmhmXeAZvZOuFZkqq2CWG3lB1fOOrgC/G8+fz/LN2goNXbsWM/PgwYNMiEVq28YNDB4YBUMQ5PaxmqssgPWafv27Z5U11FYWGiezKKiIrM5GJY4lTtVYUshZzB5Y6UR2xJ3h1U/DHFq4xfBue9sa3zwwQdx7LHHmsOsOGIIOHXqVJx55plYu3YtevToYYalssKKwQ9/5uVZ2UQMDDlQzvt6K8LgqOzpvG5atWqVOY0hl/djZJXb9OnTTSjGsIpD6zgjLCoqynOb/GPVWXXBceqpp5pgipc78cQT0djwPjuzPnbXg10ZPl/892R1GZ8TkaaKv+fp6enmdaPVxER2j1/w8P2Usz+qel8WEb3PiFSGf9+ym8Z5H+EoHK5id+GFF5oZUexQ4ucyhlP2A1sx5vwwE5EREcjzKvigc04+AnfecD4iw3Oxbcv60nDJbOE1qzDiYHCzeWF1FYMnhlAFGba9zlNl5Q5ETODEtroYe9sMnDyX9ypOKipCaMEWhOavRlj+BoTmb0JwcQaCi7PMFsRgqY6UBEWgOLwNipytJBhFbY5CsfNcByh+LgmI9r2y7V69evXCihUrTC/qypUrzXHeWPrHaqrvv//eVMWwesfb1q1bzb6qOVVsRWOLmnelFMMZBmFl5zEwpOKTydlX3kPY+cLcuHHjbh8Tr7fs8HaGCv5clrexp6sIOn/Q8Xq4Og+fU1YUMfxx8H88bPPjec477zxTeslVEViKecwxx5Qr02SFlD/3q6Lz8Tjv0xjUcCg9lwblc8L2QVaxMYxyLssQh1vZ62JbJ+dWcQVGfiDnZRkCNuaVF/ckTOLj4r8nK8PY7irSlEMpvub5/2SFUiL+vWb4vqDXjIjeZ0Tok08+MX9H9+vXz7w3+IOfuZxAisUB7GhyKqNYvNEyOQHBJaw+ygIKdgEFO3Haoa1w/B+vYc6iZZgx5y/8tXw9zj39WJx8/OF18w/BoImVSqx+yt8J5G2xFUusgGLYFBEFBEcAIRG2vc73wuyZsj/yMrmbzBbk3vO6gjyDyWv5bpsKsBAgJBqIbGU2V2RrIII/tzZthyFBQeBfyhG8wK4/gTZdgVatEMj8/Zu1Uf31zhCGoQnbt9iCxVTWG9NZ9rZyHhFxBtW9995r0tpW7n+wGTNmmGCJL8DKREREmK2iF2LZP4B42AlFvCtcGOKwimh3+D+BspUxPM6fyzrzoPaEc3nuGUrRiy++aKrSvDEk4nm4Mh5nNn311VemFYAVSKNHj8b777/vc53+3K+Kzrd06VKzZ3seT3vkkUfw5JNPmmSe/74Mo1g5xYDJ+7Jlr+vtt9/G9ddfb9J8/h6weotLi/788897/JzVBae6i2p6/5znoKLfU5GmRr/rIv5jVTdb+Ni615i/mBFpTPQ+I00ZCxCcYg3+7cm/jbkxZHL25u9Uhjzugd133DwJM6Z/haOOOBS33jARYaFBQOZyM3cpKDMdwa5CBJfk2OokM0Q8CohMQXR0W4w5sgfGHHl01XeKt8XwyFm5ju1wpj3OveqcZ/W5ModNEJUB5KcCuZttKMXrYNDDuUsRSbbqiiFVUbq7cirHvXe38BV7/czrYjufPxgk8TbMFguEOD9ziy792bT8ec228tmHIcg8Jt+/Aav8izDIvVJggP/N5+/frA36yeW6664zARNb9jZt2oQpU6aYcIRDrvkiqajaiXOOunbtan5mBQ9fVAyxHnroITNHiv2ul19+eYWhU21ipZV3tVV1cGZTQ2BpP4fKs3WOrXqVYajHMIrbSSedZGZUOB92WemzJ0tOM3zi9TPoorlz55qZYWeddZY5zCSeM6S8Q0WWjpa9TV6O88acAe3EQFNERKS5YUW3M/exrj//iIhI48auHCeQIlY5OQtHeTvz5KPw2mOTEMIABMUILynCvPduQVhYKJD5hz2TCVJCgKJgIDgKCG9d9YpyZu4SA6A89yp1eUChew5TcZbvkPNy3MGNuU0nnHIXOJkQineF94Er27W0YVr6UiDtNyD9b3vdNRYMRLYEotoDUe3synfcM4hqhAUPTU2DhlIcjMYAii8chlAcovbTTz/5XWLIAIvLUjIJZrUMq2w4rNsZiC3lcZYWV9tjFRbDJrbKLVq0yKx8x5Dt0UcfRdu2bc0QdCabbKtjOOi0UXIVvVmzZuHAAw80H3ydOVMV4eoLDAp5GwyaOLfq448/NoPOnevr2bOnqcLiPCheF2+f/xP1DqV4m6yA4kp/sbGxJhzj5Xg9nD/FkPL11183y406gaWIiEhzwff0ESNGmL2IiDQf/BuKXSf8W8gZE8L9888/b1aj58By7itaBOzdj7/BDZcej0EDenuGfYdFVxAPcMh3bh4QFlnBqnbuKia28zmryJkwqsCdJrkHl5uZTqyuigTC4n2HiDu3wfObOVDee/fAp5AW9vwMszKWArsYRC2pQRAVZIOtqDY2dDIbAyiGbeHVvC5pEqEUW7Cqo6JVy1hl9eWXX9bivWra2BLJlfbY6sb2NwZ5bJtzho2zDY5VZ//++68J/fbdd1/z/Dqld2yXY3jFFkC2IDIoqgznUzm9pDwvQ0d+k8seZQcr21i5xflVvF9cCfD44483Q469K+oYNjKo4uwothdyLhaH4LOai+XXDDdZNcW2QxERkeaE79d8P3fmNoqISNPGucfsMuIoFHaasB3PLALlKkF8TCQuOf90oCDdtrTl70Tqjs34e/k6/L1yK/5euRlLlq3FP8vX4JlpX2Hqo6V/m/mF85gYQpl2uk02lOJwcdPqFguEJ9kAygmdWDnF2U+5W+yewVXedhsC8bzhie691xaWUFqRxSCKlVCeIMp3qLrBWU3xve3lGDqxtY7Hmb1zOMpu3mFYbXBW5vOEaGyJdCaolw3YygZvXuf1XhXQ++dmIMhV0/XpmxAOOue3iwxCKhp0zhCEFTgaLi01xZcZBwdy1kdNZ0rpd1GaC364cmYFan6aiH8zOfmlz3777WcqikVE7zPSBHEOU1EWfln0C8656Ar8/c9yz0kjDhiCbz94DCFBxXbmE0OS4gIgJKx07hFDo91hNMDLc6W5kiKzLykpxLZdhWgVnYngvM1AQaoNmsjMVYq1w8W5Ah7DJk8AxfBpiw2tqi3IVlQxZGIFltO+540BU+IgIGkwENfDv8dXG8xsLGdWVa49zlRZebcfulsQnZ/N8e7qMM8qhLY6DU6AFxTmXhkw2D6P7cYACZXPyQ70nMWbpmGKiIiINIFB59yLiEgTw1AndwsK01bj3sdfwT1PvofiYltJEx4eiruvOwvXXjoeIWZluVAgJNyGUFyBriIMnZwV7BgwmflPBYCL8564cZYvgylW8ZTYw7mJQM4O91D0PLsCHyulCnYA+e6N1+Mv3j8zW6qy9jsXUJhut3JB1EAgcS8gvlfNgijnMZYbrh5U+fPFAIqbU6XFKiyGZnE93ZVdce6gyT2Dy4RQ3tdbxfVXhEEfr7+ZUCglIiIiEsD4LSRb5DVTSkSkhpwWqtpu7aophkGmPW4jXDmbMHvuIlx99zQs/muF5yxDBvXGtGfvxIC+PXZzXS6gyCuEytlsD5uAhfOe3BU7ZuNhBj0htvUvez2CctYhJXsrgoq2V3+GE8OnyDZ24xynyNZ2z9CF94ur4rEV0LOl+R7m/eQcqoSBQNJeQFyvqgetV/b4eTtm2Hq+rR5jlZLTPlfCPYM4JzRylfk52FaEcRB6RCsgPMFuXIlPQ9BrhUIpERERERERaZ5YNZOxDChMA2K6AJGtqh981Np9KbTtajnr7R4uHHfBQ/jsm3mes4SGhuDWay/AzVefb1fKq6iyh21lDHjyOYCcLXec+5RbGrBwjhPDHgernLLXAdmrgaw1QPZaT8sc4xk7Qr0yQUB4MhCRAkS0KA2eGESxgqjSiwWVthZGd6jk+SjyqmaqBqcajBVdDJ9YYeWsrheRDARH2hZF06roVIV5Hy4uraZy2ghDo6p3H8RvCqVEREREAhhXu/3uu+/MoiFcoVZERPzE0IOBVMZy2/bGIIihlAmnuCJbPc0p4vDw3K1AzjobJnHOEEOU4HAcPHwfTyjVv3cXvPb41dh7QGcgfwOQ6265My14Oe59vg23eJiVPqbVLBYIaVla2cPz7PodyFphQygOLDdVQRVzsXIqIhlBDJ3KbmaweR3FCv5erxk2bmdumTY7Ps6QWCC2u/13ZGDG6ixVNjVKCqVEREREAlhERAQ6dOhg9iIi4iezqts/NpiJam0rhxhSFewEdi60oVBdhFMl7komEyLZiqaizE34bPr3eGbaDDzz8GT07tXRntdVjPPHD8fX02fgwuP6Y/yhnREeshbYutr3Op3B2U4rHqt6WBHkXWHEICrjHxtGcTU7zoeqTGgcENvVPP6SmK7Y5uqJVrEFe57peAaps13O5R7yXcO5UAzginJLh6Bz2DqrmmJ7ApEMy5Irn6sljYpCKREREZEAFhUVhZ49e5q9iIj4gYO9M/4GMlfZVjMnvGCowxDKJ5xi5VTnaoVTzgL3QaZiyQZQu7ZvxpaNq5CfnYr8vGzk5+WgoKAIP/+2AlPf+gbrN7JdD3j2lQ/wxB0X2Kqt7LVIKUjFrKeOsJU+bHVzVmvz63H6E0QFAVFtbQDHjWEUAx0ngeJDyWZsUFBF0MTHyaqtfPfKfc6w9Aqqr5z5VbxdPj+c6+TMcXJWozOPMbT0sfJxmOcxz14nq9rYgmfmPLVwt9jF2X19rcIntUahlIiIiEgAKyoqMssts3UvPJzLUouISKUYcKQtAbLXANFtTYtcOd7hFFeWc9r6YrsAES1tiMLTzGp07s1VhLycLLz6+tv479Mv49sPnkDH1nE2qCkpxKv/+xTX3PXKbv9h5s6dC9fmTgji5cygcNvG5zfvIIr7ioaT83oTBwEJA2wI5T1fqtL2uILym+f5YpDkDopYpcUZTgz6WL1kqrfC3HunmivUHUrlu6ue8kvb7wpZQZZln1O24jHc4vWyTZDPvSeAiqve89JYlRSVrkRo9gz2GOo1HwqlRERERAJYRkYG5s2bh5SUFLRo0aKh746ISOPFSpu0P+0g8eh2NkypCgMUVlI54dSObUB4vF2xzQzGtlt2di6mvjkdj0z9BJu37TIXzc/hbKhkO88pOAwRsa0qvZmgoCAcfXB3TDypPw4f3gtBERxEHuUbCnHlvMIM99wkhjfcZ3r97GzZFc+HcoKoRK5i173qiiIO/mZlEq+rKB/IZytchl25jkGTU53E6+T9dIIonlYbc5t4+05YxefY3M5ugrP6xt8J5zmvsCIsuHRFQw6Ydwa2mxCKj6uktHIsmIFemF3VLzTePYw+Bc2FQikRERGRAJaQkICDDjrI7EVEpBKcP5T2B5CzCYhuX73h3N7hFEMItvEFRSA9Kw9P/+9zPD71bezYmeZzkeyiSBtIufXt1RXnnj4OERFhiAgNRnhwHiJcmUiKKcGJo3qha5fONnzxDnUK0oHURbaNMN+291WLCaIGAomDqw6iWJnDqiSGUAxMWMUU4l6lL7Y1kJsIpETbsIThUF0PDGd4w9tpdEFUoXtVPwZ/QfbfN7aHfZ7Ie/W+YlbPOVV07kooBlHhbMOMcz+XEfYxmooybs2z9VChlNTY999/j0MPPRS7du1CYmIiXn31VUyaNMmsAiQiIiL1IyQkBHFxcWYvIiIVYIiw6w8gb4u7QqqGfwbzcuGJJoB6/PnX8fRL7yI9I8vnLCccfShuueZ87DWgl8/xhx68Dw7dvxeQvQ7IWg0U7HJXxCT73h8zgH0JsHOBXRmwilXxfLAlji1tnD3F0K2qIIrhiKmCyrSzoHhZ3he2KEa2sVVQrAgLiXGfPw+IqIcwqrFW17ESjYPpWc3EQCmhk/13Yxi1u2o7b6yoao7P4W4olGqizj33XLz22mu45JJL8Pzzz/ucdvnll+PZZ5/FhAkTTJBUW0499VQcddRRqK/HVta///6LHj16IBAp0BMRkZrKycnBsmXLEBsbazYREfHCQIHzlfK327BmDwdhT331A1xz22PIyckrzaqCg3HaiWMwedK5GNC3zN8jpvVuJ5C1FshZayttwhKAmE6lA8t5HrYUsiJq16+2da6s2G5AVPvS4IlbmFN1wxbB8KoDD1bvOC1//JlVVLw+zs5i2xjvU0WVSRW1pjUlZlC7e66Tz56tmcW2miksEYhjRVSSfZ5qWtGkQKpCCqWasI4dO+Ltt9/GY4895lmRJy8vD2+99RY6depU67fH26ivlX+OPPJIvPKK76DAli05dLD6CgoKNBhWREQCVmFhIbZs2WL2IiLi/T/IDHcgtdMdSPm5al2F85U4gDsHnVNKPIFUWFgozjnpMNx0xeno0a2LrXhimME9L5e31VZF5WywbXEMNbjCnRNOMKBKXWjDKJ63LJ4/eV8gZR87x6m6TLthpg2jWHHFACu2u21FjEixYVaTC5icFrqS0p+5wp9nRUDnZydsC/Idws62RTMnK8ZdyZZonzcFSnWmBq9KCRRDhw41wdSHH37oOY4/M5AaMmSIz3lLSkpw//33o2vXriZY2muvvfD+++/7nOfLL79Er169zOls21uzZk25ah+28TlWrlyJ4447Dq1btzbf3O67776YOXOmz2W6dOmC++67D+eff75pPeB9e+GFF3b72CIiItCmTRufzWlb+OGHH7DffvuZ87Rt2xY33XSTWZnIMXLkSEycONG0GnIg7BFHHGGO/+uvvzB27FhzX3mfzz77bOzYscPnOXrooYdMNRavm/f13nvv9Zx+4403mucnOjoa3bp1w2233ebzB8Lvv/+OUaNGmccZHx+PvffeG4sWLTJtkOedd55ZOYlDDrndcccdu30OREREiLOkDjnkEM2UEhHxxrY0rrKXn+pfIMUAhyGRO0gqSf0DX773An787Hlg03Rgy0xg62wc0T8PBw1uhytOHYyVH03AS9f1R4/IJcCmr4FNX9pt4xfA5m+Ard8BWWtsO1xMZ7unzH+BVdOAP+8ENn7uG0hxpbrkfYCelwH9bwHaHVl1IGVCliI7FJzBGR8DQ7jstbZdkX/yx/cBWo8E2h0BtBhm70ugB1Kef69tQPZ6u+VutBVxhWnu+Vjuv8VYRcZqMLYmMhRM6AckD7XPRauDgFYHA61GAK1G2sMpewMJfWw1G//NFEjVKVVKNXEMe1hRdOaZZ5rDL7/8sglAGIR4YyD1xhtvmFa/nj17Yvbs2TjrrLNM9RE/6K5fvx4nnniiaf27+OKLTZhy7bXXVnnbWVlZpp2PwQ1DnGnTpmHcuHGmxcC7Uuu///0v7r77btx8880mCLvsssvMbfbu3bvaj3fjxo3mNtnix9tbunQpLrroIkRGRvoEPWz/4+1wyVXiHCwGRhdeeKGpLMvNzTUh0ymnnIJvv/3WnGfy5Ml48cUXzekcKLt582Zz/Q6GTQzm2rVrhz///NPcLo+74YYbzOlsl2RQ+Nxzz5kA7bfffkNYWBiGDx+Oxx9/HLfffrt5bkjtFyIiIiIieyB7NZC7GYjpUHUgxVAnY7kNiorzkZOThWmf/43H/28xlq3dhYOGdMSP0y4Ggjk/KJR1NfjhzWtMy1654dbcWIVjwpACIKKlbf8ihiQ7FwE75tngpKL2PFZFJe1Vvo2O95Gr7zF0Kj3SVvlw86z05t5Y6cMB3JEtgQjOrApvuF8lM/Q7372aXp77ueF9Dy6tVuL9d1agM1VL3Id5tTfyOvJsxRr3rIji+YKj3LOdUjyrHJqKJ+/nwlyfanEaM4VSNfH1PkAuU+d6xjLLIxdV6yIMlhimrF271hxmCMOWPu9QKj8/31QrsYrpgAMOMMex0mfOnDmYOnWqCYgYpHTv3t0ESMTAiMHLgw8+WOlts9qKm4PB00cffYRPP/3UVCo5GCL95z//MT8zCGLo891331UZSn3++ec+wQ0rnN577z0zK4vVYU8//bSpOOrTpw82bdpkrpehj/PmweCNVU+Oe+65x1SP8XlwMMDjdS1fvtxUXD3xxBPmehkuEZ8PhlOOW2+91acC7LrrrjPPtRNKMdi7/vrrzX1y7oP3t9y8v6z4EhERqQ5W2vLLpMMPPxxJSUl68kREWCmUtdK2qFU1Q4phR9rfQPof2LSzGE+/+zumvrcQqeml4c+cxevx67JdGNq/g+c4TyBFTvhR4fW7gOw1wPb5wK7FdlaRN1YrpewHpAyzAVK5yzthVDYQlgwk9nCHN17tZp59mNdhr0CnPjF4YnDGVkWuPsfQyQROXGUuAohqZyuWgrniXJg9v7kM2yOz7TBxVri53FVOzjwrVioFu1vqollxFudur4up3qBxaZQUStUEAymWBgYAVjodffTRpoLH5XKZn9my5m3FihVmSCo/zJadteS0+f3zzz8YNmyYz+lOgFVVpRSrk7744gtTVcQWOlYgrVu3zud8gwYN8vzsBDPbtlW95CnbBxmUOWJiYjz3k/eL1+M48MADzX3ZsGGDp0KLrXPe2FrHIKyiCiW2IbKSiuHdYYcdVul9euedd/Dkk0+a8/P2+HjZpue46qqrTPUUK9JGjx6Nk08+2QRbIiIie4JVt61atTJ7EZFmr6QQ6Rt+xaTJj+LDr38yfxfEREdh8MBe+OLtJ0qfnpIi3P/Ag1i5YjmYQX3y/VIUFnLWUKlD9u2Oa849BHv1aVe9p5XVPKm/2qqo3E3lT+dcpxbDgcSBFa8EaMKoXbY9jVVAKQNsK1lFg8gbGoOjoiygIN0GUKxYimhlB4JzJhOrtswWsfugjNfFMMqEVe7qKjNsnJfndTXTFQCbOIVSNa1YCqDbZQufU5n0zDPPlDudAQoxPGrfvr3PaWy7qylWCs2YMQOPPPKImcPEWVQnnXSSCbu8lf0QzTcOzm+qCkOoPVlpzwmxvJ8DthZWVPnFKqlVq1ZVeX3z5883LZJ33nmnmVHFyidWSTmVZcRKLVaucTbXV199hSlTppjznHDCCTV+HCIiIpxlyCpc7kVEmrsFP3yCU8+5HGs2lH7JnZ6RhQ7tWpWeiWFH6m/4fMZPmPfHZp/Lh4WF4LSxQzDpnBE+1VF+4Xyj7XPs4HKGKt4YrHBWVMvhdsW7iviEUclAi/0bbxjF8KggzbbUseKLq9Px71WuVLcnq9OFhNsNAT7zSvymUKomqtlC19C4Uh2DIIY9zlBvb/369TPhEyuY2KpXkb59+5q2O28//fRTlbfLVkHOdnJCFwY/ZYej1zbezw8++MBUhTnVUrwfnO3UoUPlbyqc9cTLse0uNLT8y4KtdgzVZs2aZeZOlTVv3jx07twZt9xyi+c4p2XSGwehsy3x6quvxumnn27mffH5CQ8PR3Gx7zczIiIi/uD7R2ZmJlJSUnxbSkREmhF+qf3oQ3dj8m13o6jIfq6Oi41BuzYtkJ2Th7atW/hWMWWuQI7Xd+XJCdG49LThuPyMA9GuVYL/N2xmUi21YRT3ZUV3skFU0uDKZzuVDaPY0hfbpfGFUaYqKtuGUfxbiwPYOTScs7NC62cVdml6FEo1AxyqzbY25+eyGNiwqolBCf9nzjlJnE/BMIftZ5yhdOmll5qqH85EYijzyy+/mJbAqjDI4Wp/rEBiQMTV6HZXAbWnOJuKQ8OvuOIKUx3GweGsSLrmGq9hhBXgAHcOMWdQxBlQycnJpq2RlUwvvfSSGZTOuVQ8jQESWwK3b9+OJUuW4IILLjCPlaEez89VBll1xvlZDrYt8jlmyx7ndbGVcOHChRg/frw5nWEYQzuGXpzDxW+79Y23iIj4g+/ZnAPJeVJlW/RFRJoDjv6YcM45+Hr6dM9xB+w7CP/34r3o3LFt6Rk574jDxjkEPaodPnnmQqRn5aKwsAR9u7dCVGQ1BoKzQmjnAmD7XCC/dMXu0hX0hgItDwSiq6i2MmFUGlCYAYQn2TDKrIxXxwEPB48zBGPFmBmW7txvZ2A651K59xxIzpXu8rLcVVExdih7VFs7RF1DxGUPKZRqJrxnG1WEQ8g5f4qr8LFVLTEx0VQPcUU84iwmVhIxuHrqqaew3377maHgbA2szKOPPmpO5+py/JDMUCcjIwN1ie2HbI9jeMZwh+ESQyPvIeQV4Yp5DOF4H8eMGWPmR7HyiVVmTpjFUI1VVGzD4/B0tvUxrKNjjz3WPDcMwnhZzu7i+Z0V/xgG7ty50wR8W7duNc8HVzNkux/xOeJ1nXrqqeZ8DNK8VwsUERGp6j1+//333+17vYhIoOCsV/69UXbkRmX4xbKzYja/DL/pqnNx502XICzM68/dwiwgdQGQvcEGRcFh6NSOo0qquUBE7lZbFZXKFj3fsSSmyolVURxczvCmqoqjwjQ7h6k+wyjOfspPs4ETq5tMYBZkB7BzK8pzz3LioPJ8exz3xUVAaDyQ2NddFaV2cak9QS72OTVzDEo4A4jfNJb9QJeXl4fVq1eja9euplpGpCb4MuPgc4Za3kPYq0O/i9JcsKKS33hycLNakUT0mhHR+0zTxS/D2VHQv39/z3HsRuAXxhwvwnm0/FKXI0aq+kzwx6Ifsd9BhyEhLhZvPH83Dj90f98zsBqJVU15W20QU9FqefyzmJVADG64McQyP2cDRZnutrVddjW9suJ6Ai0Ptq1sVVUOmTAq3d4fDgLn5dimV5chD6uxWInFAIxBGVfAi+YqeKxyCqr6vrqKUVJcgG1bt6JVmw4IDtWCGlI7OYs3VUqJiIiIBDD+QceWc7bj+1tVICLS0N58801cdtllptNh0aJFnv9//d///Z/5Mpfba6+9ZraOHTvi7LPPxjnnnGPms/ooKcSgzqF4//mbsM+wA9HGmR3lyN8J7FgAFOysOJBK+wPY8KkNilCNUSOcD2UGlx/k34JUDIbyU4GwONvaZ8KoOhzmzZa7glQ7QyuMVU6D3IPI/bxNBlZO+x4ruGo6vFxkNzQNU0RERCSAsW2ccw25FxEJhOoJhktclZqLNCxdutSMBXEcfPDBuPjii02FhWP9+vXmPFxplJXUgwYNKl3RO2stkLcZxxxzdPlAKncLsH2erXCqKJDiLKg1b9nwxt9Aiu1rHY4DBkwBOp20+0CKw8t5H4sLgKRBQJvRQOKA2gmkWM3E8InBk6nkSrfBV84m+9hZjZWyrw3O4nv4H0iJ1CNVSomIiIgEMM6BHDVqlNmLiDRmCxYsMPOf2LbnYEB10003eQ4PGTIEU6dONYsXffbZZ6ZSavr06Z6Vqtnex42rXj98z2Qga4WdyxRcZn5UxjIga6UNbqLbl29VcxUDa94snQsVkQKEt7Atbqxm4p7BkbOFuffBEVW3vfnMb9oJhETZtr647kB4Df8/zeCJM6gYPpn77kzgCXIPJGfYFmKfg5AI97wotuilqMJJGj2FUiIiIiIiIlJnGCg99NBDZsEgtuURW46ff/55nHHGGRVeJioqCqeccorZtmzZYtr6GFD9/vvv5vRVK1egOO0fhDBUimxpL8SfM1cDGUvt7KZIhkyVVAdtmQlkry0NpPpcZwOd2pjhlLvZBkXxfd1hVFINrsflnm2VbsMnXkd0Z3sfzep4Ye6918/OqnkiAUShlIiIiEgA4wBRriDLaqmkpBr84SMiUk2sVFq4cCHCwsIQGxvrs3H1a6487di4caOZB8UV9RzDhg3DW2+9hW7duvl1e23atDErXXNbsmQJ0tLSMHxAKwRl/AlEtbdBUM5GIOMfd9tavF3NrrKKJg4r3zzDfSAY6HJm7QRSRblA3hYgso1t1YtqW/3r4Gp3DKJYFRUSA8R0sy2CHEyuwEmaIIVSIiIiIgGMK7uydY97EZG6wiDoo48+wttvv41Zs2Z52unK+uWXXzB06FDPCtTTpk3zBFJchfrmm2/GlClTTKBVE2alPs6I2vGzrR5iWxtb9Vj1xOqkmI4Vr67nHfqwbc+ZIdX2cCCmC/YIq5o4n6okD4jv554ZFVX9FfI4f4qVT2y7S+hgK7jqcmU+kUZAn15EREREAhhXrOIfaVp5T0Tqyj///IPBgweXDhevAqulHAyhWDlFXGXvjTfewMiRI2t+RzhbKX87kLXGrpZXnA1krLBhUGQrICRy99ex4WM764miO9nB43uCLYOszgqNA1ocCMR0AoKCq/F4GGYV2jlW8X3s4+DsKX+vQyTAKZQSERERCWCsVsjNzTX74GD9ESMieyYvL8/McOrSpbR6qHfv3mjdurVZBY942gknnIDo6GhkZ2cjKyvLs1XURsxh5o8++ihSUlJqdqfYypa3FcheB+RutT9zY5sbq4nCWvl3PWl/Ajt/tj8Hh9u2vaqqqnaHq93xPnDWU9LA6g0yZ6jG6ii2+rHVkI+jNloIRQKMQikRERGRAJ8p9f3332PcuHFo0aLMcugiIn5iuM0V7f73v/+ZqqgffvjBcxoD78svv9yEVaeddhr2228/UwXlj0suucRsNcLQhkPDszfY6qYi9+GCVNvWVp2qJF7X2ndLD3c4oXRAenVx5T5WRwWFAUlDgfhevqv/7TZg22Yrq5KG2JUBOahcpJlSKFVTxQWAy64cUS+4kkJIeP3dnvjgh/1DDz0Uu3bt0pLbIiLSqHAFq3333dfsRURqYsWKFTj55JPx22+/mcM//vgjNmzYgA4dOnjOc+ONN9bPk8v5SvmpQO4GG/xwBbqibCBnA7DjJzvMnO1urUfa4d9+XacLWPu2bfejhIFAyn41u3+8L2whNMPM9wIiW1evVY+PL7Y7ENsNCKtkZUCRZkShVE0DqZ0L7P8g6wuXMuX/OP0MpljCf8cdd5i+bX6j0a5dO5x77rm49dZbPd9qcPAghwy++OKLZnDhgQceiOeeew49e/Y0p+fn5+PCCy/EJ598Yla8ePbZZzF6dGnP9cMPP4x169bhqaeeqvK+8H58/PHHnjc5f7AkeNKkSWYTERGRynFYMCukajo0WESatw8++ADnnXceMjMzzeHIyEiceuqpfs2P8vtvpyJ73Z6AqBxX6XymnPVA3nZbAMCh5Gm/A1u+BTKW2EDIsXoaEN0RaHe0rVSqyvY5QMZS+zMrlDqfXPnKfFVhtRYrneL7A4n9/ZthVbZVL647ENGyZrcv0gQplKoJ/g+SgRT7kOuj75f/M+btmcos/0KpBx980ARMr732mhl+umjRIvNmk5CQgCuvvNKc56GHHsKTTz5pztO1a1fcdtttOOKII/D333+bN6MXXnjBrJ4xf/58fPXVVzjjjDOwdetWE2qtXr3ahFm83saMb6bh4aowExGRpj3/he/L8fHxZr6LiIi/n5NvuOEGPPHEEz6zo95//30MGDCgdv6GydsCZK22c5fKZVFljwiyVURsgyvOBTZ9BWz7zq6qVxkGWCueB+J6A+2PBqJLK7s8WG218bPSw11Ot1/4VweDNM6w4vypFsOAmK7+hUqeVr1YIHEwENNBrXoiZWga5p5gIMV0vM636gdf8+bNw3HHHYejjz7aVB2ddNJJGDNmDBYsWOCpknr88cdN5RTPN2jQILNc66ZNm0xVk7PKxrHHHmtCLfaQb9++HTt27DCnXXbZZSb44gfg6mLF1vHHH49HHnkEbdu2NQMPef2FhYXmdK7IsXbtWlx99dUmAPPuV58zZw4OPvhgREVFoWPHjiZg43BFBx/r3XffbYYp8r5dfPHFGD58eLlyYz4WfqM8e/Zsc/j111/HPvvsY1ofWBXGAG7btm3VfmwiIiINMQeGrTfci4j4g5+1+ZnaO5A6/fTTsXDhwj0PpBhGcXW8HfOB1F9s9VNUWzs7ydkYzsR09N2iWgGFu4BlTwE/nQ+sfrVMIBUMJA4EelwMdL/IXqcjcxmw9FFg9eulK+s5LXNr3iwdu9LyILvCXXUwKMvZCIREAS0OsG13uwukGGIxDGMbIlv1eLm4rgqkRCqgUKqJYhAza9YsLF++3Bz+/fffTaAzduxYc5jfqLKtz7sdj1VUw4YNM5VRtNdee5nL8EPu9OnTTYDE9oA333zTVFJxxY2a+u6777By5UqzZ6XWq6++ajb68MMPTf/6XXfdhc2bN5uNeP4jjzwS48ePxx9//IF33nnH3L+JEyf6XDfDLt73xYsXm+qvM888E2+//bYJ4hy8LFsa+WZMDMQYZvF5Yii3Zs0aE56JiIg0dlzp6vDDD69wxSsRkbL4mXrIkCGeL6vZVcAOC37G36PZdE4YtX0ekPqrDaPYXsdV5Vhh5AQ5Jfk2rMn4F9j4BbD0cWDRlcCc04CfLwC2ziid/WTuYDLQ7ihg4O1A1wl2hlNoDNDjMqDzGb5zpXYtBv5+AFj/IVCYCWz+GsjdaE/j5dofU73HxFAre719DC2HA9Ht/Lscq6p4H1lVxSBNs6NEKqX2vSbqpptuQkZGBvr06YOQkBAzY+ree+81AQ0xkCIu7eqNh53Tzj//fBP+9OvXz4RR7777rhn0ffvtt5vB36yyYtjTvXt3vPzyy2jfvr3f948fnJ9++mlz33gfWdHFEO2iiy5CcnKyOd6pWnLcf//95v47c6Y4+4rth4cccoh5I2VQRqNGjcK1117rudwpp5xiLuNUWdFbb71lvg1yqrD4WB3dunUz18uhsVzWNjZWAwhFREREpGngZ90RI0aYubEc4cF2vaFDh9b8CtmixhXx2KbH2UlhcbbyiavicQYU29cylgOZy+15cjcB+dvsjKVKsSpqgLvCqKcdbF6wC8jfBYTFAzFdgKxVQPIQIGkwsGMesNkdZnFlPM6Q2rnQBmPEUKzLWXb8SrXaDzfbFf6S9/E/WGLgxkWqEgYAkVoRVWR3FEo1UQyQ+G0Hwxe233HIOIMZVgdNmDDBr+tge9szzzzjcxznUrFljlVIrChiZRFnU/E4Dkn0F+8TgycHq7D+/PPPKi/D22JIxsflYPVTSUmJqfzq27evOY5teN5atmxpWhd5OYZSPC+rwaZOneo5D2dncSA7b4PBG6+TOMidoZyIiEhjxS+hfvrpJ9P+npiY2NB3R0QaOX4p+8orr5gvmPmldY3+v8EOhOIcIHcrkL2mNIyKbAUUZQDpfwPbfrBVU5n/suTIv+tlRVLK/kDKvnYgOQekc24UQx5WOsV2ASLb2qorVlzlMDTqALQaYReF2vqdvV2GUTzd0W6sbRv0lwnTdtgB6gy9/B1ozjnADOkYlimQEvGLQqkm6vrrrzfVUqeddpo5PHDgQNM7zmojhlJOBRIHlzMQcvDw4MGDK7xOttotWbIEL730krn+o446CjExMaYSiVVP1VF2hSC+OTpBUGVYtXTJJZd4BrV769Spk+dn3qeyWGHFy3GlQAZ1fD64EWdSccA7NwZXDLEYRvFwra06IiIiUkf4JQ8HnHt/2SMiwvEU/PzOL6vjYmPx2ENTbLgTHIGkxMRyXz5XiZVKDGoYuhRkAAU7gaIcd7WTy85d4up2aX/ZOVIZ/9jQqjLBEXYmFFeji2pT+jODLU9VVKo9HN/PBk9mxTqv6TNJewGFs+35IpJtcMTwqeWBwOZvgB0/2TCMlVatRvr/WBmwMQxLGmirnTh43e/KqlQgsR8QVY0ATKSZUyjVROXk5CA42HdkGD+sOsEPS3UZTLFlzgmh+E3rzz//bIaYV7SyD4eRM7Rx2gGdGU18w+Ph2sTe9rLXybJirgzYo0ePal8fh7lz6PnXX39tQikOQncsXboUO3fuxAMPPGCGp1NjX1VQRETE+8sYLlhS0ZcyItJ8g6iPPvoIqamp5viE+Fg8cOUhiIiMAILCbBsbV4Rj6MMwhyERF1fi8dxYZWRCqGw7OLwgHSjJBQqzbYscZy1xhTwGOPk7gLQ/gcyldpZSWax4YsURK5ycACos0VY78e8JV6ENdFjdlL3BLMKH8BQbOvG8Fa2Ux/NGtAASB9nwKTS6tJqJ7X2dTgJaH2rnSTHU8g6zqpK33Q5FT9rb3md/L8eWQT52DjOP7eHfynwiYiiUaqLGjRtnynFZQcRWObbbPfroo57ZSaxMYjvfPffcY2YzMaTiUHC293FlvLI4BJyVURyKSAceeKCplmI7H6ukeLg2cRU9rozHSq+IiAgz04or6O2///5msPmFF15oPnwzpJoxY8ZuK7V4Xj4uPkauKsh5Ug4+RwzBWEV16aWX4q+//jKPV0REJBDwC6f8/HyzL/uFlIg0DkVFRXjhhRfwww8/mHa5O++802d2KhcW4udzZ0ZqTYKo9957zywY5ARRvrdfiCV/L8PQQV5f7uZvt1VOcA8hN1VUDKVCbejEQeGsjGJoxBCIFVIMpBhGMURi4MPqKLbnMZTxxhlOrDJiG158bzsjymmpcy7L6ioKDnOHYtF2MHpUO9sGWLZCydyndBuMMSzijKfYrjYU48wqzn7yDpHYCsjNH7wvXC0vJNy2D8Z09v8fgMEa2wgZoMX3BYJVtSpSHQql9gT/h9pIb4cBCwOY//znP9i2bZsJm9j6xiHljhtuuMG0rrGCKC0tDQcddJCpJCr7ZsiQht+2cC6V46STTjLDzjmjqXfv3qb6qDZx5T3eXw5R5wdtVmXxW2C+kd9yyy3mdnkcTz/11FP9uk628DFY42BH73Y/tutx5b+bb77ZDDhnRRZX8Dv22GNr9TGJiIjUBb6Hf/vtt+YLKX6JIyKNCyvw+XmbXxI7pkyZ4nMeBlb8wpiBFcMqLj7EL2bZocCwmXtu/LLZ+8tTjpzgZ1dW/ZcVEx2JcYcNxlXjErBf4iIEZ00Bfmlp2+Q4X4ktZqxICrEtfXZjQBQCFLI1L9NWRzFM4s8Mf1gNxECJw8rLBlEU3QFI3hdIHmqvi5fL2cCUyh14RdhKpvAkuzcVTtF2z9PKVhgx8GG1VmGazc/CE4Gk7nZuE8MwHubqdqzYYqjk7+p4ZcMuPqawZCBlb1vNVR18TsITgIT+ttpMRKolyOX0YDVjbFtLSEhAeno64uPjy7WtcTA2K4k8YU1xAbBzgf3moL6wbJXD+5jeS8Dhy4zfkIWGhnpW/KuuCn8XRZogVnswTG/VqpWqPkT8fH9YtmyZ+ZJI7w8ijed9hvNQ+YXwE0884TM7lZ8FObeUnwsdnAX74IMP7vY6+cUsuwm8P2NyNb01a9aYw9HRURg3ehhOPmIQxg5rhejNb9hqpsowEDKVSW3sIPFIzm0KBQpSbSUVV9XjoHFWKFX1dwpXp0vZx4ZcnDPFeVOsdApLsAEYK5Z4vpAo/4IbU5nF2U659nJRrW0lUniyvV62FG6fa+8zD/N+bvvRhlsMu6q7ciBXC0waakOu6uDsq5JiG8LxuWuC9LlM6iJn8aZKqZowZZ372X7j+sI3BwVSIiIiUgZb0FlVwb2INA5ffvml6VjgQkMOVv0zoEpKSvIJpIhzTdm1sGXLFmzevNl0M1Sk7IIGDLgmnHM2/lmyGKeM3Rdj92+P6NA8YPN04N+pvivQMdwp+6U6h5FnrbCbR/DuV8uLaGVb3DjTiXu29TFAYpjFeVHxfWxI44RIu8M6CQZRbA1kdRUvw4CL1UecHcWwyRtvg4EXAzAOOWdgldAPSF3snpHlx/8PeVmGSryvnF/l7wp7DjNzKwdIGtJkAymR+qBQqqZMQKQPfyIiItLwlVJs4eG3kFyFT0QaDleyZhve22+/7TmOFYx33HEHrrnmmnIrUDu4oBA37xlTzmJC3ptPmMURH/k7cMfEsUBWH1vZlLkY2PiprW7yDqM6nggk7mVXlcteD+Sss+fhzwyUfJQJpNhWx3lNMV1sABXNMRhsq8sEirkqX44NhhK5Ql6Kbc3jTKnKmPCJ86Xy7GMws6WCgBC2DkYCCX3tSnusWqps0DhbDNl+mP6nvW1iuJS/C8hZY+9jZd0JDMD4XLH9kNVRCX2qvr+VPYa8HUBif9uyKCI1plBKREREJMBX3OXCH2zhUSgl0rA4cNw7kDrssMMwdepUMwe1OqKiosxWDgOc/FQgbxuQs9FuBZz1tA3YMd9uHEzuYFtdh+PsfCfOhGIFUlw3G/ww8GFAw+qmbHdIxbCKFU9suTMhVBc7Y6mE4VOWrQ7i+UNjbCjECiVWMrFqqaIQiPOazOVy3F0mQaWDzbkqX1RHICzG3dbn3vyprCKGUbwuBkTOgPakQXb+FEMnDksv9/wV26HkvP/sfGHYVl3OdfB51Ep7IntMoZSIiIhIAEtOTsaRRx5p9iJSOxj0chj5+vXrzUwUbqxGdH723rgKNedTERfgee2117Bw4UKz8vXZZ59d43miPhgUMVTiQG4GUNzYesaAimHSth+AXA4U92pv63QyEN/LVvSwjY/VR2ZWEweYOyvvBdsZT3Hdbfsbwx3eX4Zfpj0ty14/jw+NBxK72hCKbXllW+q85zQ5QRQrkFipxXArLM6GTqEMniL3fDQJK6n4OE0Ln3uRBw4cZzC1fZ69/wyfPPeLq/5xlbw2QPLe/q/MV+lKe3200p5ILVAoJSIiIiIi4uWnn37C+++/79dzMn36dIwZM8b8zADqpZdeMjPeuMLzHvFURXHFu01AwU6gIN0ex58Ls4DM5cD22b4r4bU8EGg71oZDbM9jxVD8vqVtZpwjxcDIhE5cVc99XUUc2l1gb5dVVAydItsB0W3dq+UlVFzFxKCGLYC8DgY/oZE2wIrpDkRUcbk9xfvIiq7U3wDv2els3YvfCaT9BURzRcFQe98Y6jF84wyoygK13eF1cJA62/aqO4NKRBpfKMXe6jvvvNPnOK4cs3TpUqSmpppvJ7755hszJ4H/Uz/++OPNEqj8RsLB0y677DJTKhsbG4sJEybg/vvvLzc8UERERKQpyszMNFUZI0aM8PmMJCI1d/7555u/M8r+rVKRsq+79u3b1/yGGfCYoCjV3ZrHIIqr2WXZcCp7NZC91r1xxT2vhdRZCdX5VFs1xEoqhkFsUYvt6rviXXB8+RXqGEaZoIrBUq6taKqqGoohmAmysmyIxfOb1fta2QomVkdVNg+qNjEsY8UVAzgnJGKlFweks5Isd4utzOLprKBKGFDzgIwhHlsQEwZXb4U/EalSgyc3/fv3x8yZMz2HnTBp06ZNZnvkkUfQr18/s3LFpZdeao5zvrXgsL+jjz4abdq0wbx588xKFeecc44ZIHjfffc12GMSERERqS+szODnp1ppERIRD35BfsMNN5iB41zSvLKta9eue/asOUEUQ5ScTUDhLtuux5CI85u4olzGEhtCsVKnnGCg9Uig1QigIK00gInrYcMhYoDE0zhMPCTGBjXew73ZnscVPBkoVcaZD8XrojC25XUFIt0zpWpafbQneLsMzwrTfSuXGMJxRb3C2Ta4azHM3tea/n+Sj90ZbM72PxFpOqEUP0QxVCprwIAB+OCDDzyHORzw3nvvxVlnnYWioiJzOVZRsd+boRaXQh48eLCppLrxxhtNFZaWRhYREZGmjpXiQ4YMMXsRqZn//ve/6NixI0455RTPcQx6ncUDar0K0TuI4pwjhk8Mk4LCbHi07Xtg50Iga6Vtt6sIK6NY+cPwhQFTYaYNouJ6la5IxwHlrLBi6MTTWO3DACcnzYY1DG8YJoVEV1zZxMvzenk5BjqsEOL1R6bYeU57OhdqT/E+cb5T3ubyp7FiLGV/Oww9cg9bKVlxxVbB2G57dj0i0vhCqX///Rft2rUzS6UecMABpvWuU6eKV0HgNxEcMOhUU82fPx8DBw40gZTjiCOOMO18S5YsMR/QKpKfn282R0ZGhtmXlJSYzRsPu1wuzyZSU87vT01/j5zfwYp+T0WaEuf/u/o9F/EPK8edpeNFmiN+Yf3uu++aNtajjjrKrHgXHBzs1/sM9zfddJPpzmC3RWJiIkaPHl13d5ZDuRk65TlBVL6t8AkKBbI3IWj9+0DqQgRVEES5uHJdTGe4GETF97dDvBkwsX3ODN5mWNTGBjX8rMjWv6I8ILqdXSXOqYLibZrWO7YJcmB6OpDnHVK52914WQZVJojqA4Sn2EHi3u1vjeEzKcMxDk5ndVnZOU98XmhP/o7jzC2GdnG9WYLVOB5zPdLnMqkpfz/LN2goNWzYMLz66qtmjhRb79izffDBB+Ovv/5CXFycz3l37NhhqqAuvvhiz3FbtmzxCaTIOczTKsPgq6L+8O3btyMvL8/nOH7I45PJNztuHuy1Zu91feG3G+zVlgYxbdo0XHvtteZ3pCb4gcf5Y6Gm7RX8/ePv4s6dO82HJpGmir/n/BKCr5uq/qgQESstLQ2zZ882M6X4B7VIc5GTk4N33nkHzz33nFklj5588kl06dIFZ555Jk477TS0aOFela2C95mCggLTnsdAy/ncP2fOHAwaNKh276hTbcQ5UUXp7iAqwn62Lw5C+M4fEL3zC0Tk/I0g7xlR/AwZFIb86L7Ij90L+dEDUBIcYdv6sovsQPGwNrYiKDQZyA0BcvNtoMTwi6170T2AgmQgjX+3bCtzx1gF1gUI4mm5tiIrj/OrctztfK1ti15JDJAXDOTxs2wqGh0GTtkxQFGaDahqUzFnbeXZKrNd/DvR92/F5kCfy2RPZl42+lBq7Nixnp/5P3+GVJ07dzZvDBdccIFPJRNnR3G2FNvy9tTkyZNxzTXX+Fw/y3U5TJ2VWN4YUvHJZHWWZ3g6U/gtX9hvOeoLv9lof5z95sIPfJ7uuusun+MY/v3zzz8+j41BC9/MWTnGKrNnnnnGE+xx2Py5555rhsj37NkT//vf/3yqzy6//HJ069bNXEdVzjvvPPOB+aOPPvL74fIP0Q8//NAMt28MnD+M93SA/p6ESbxt3o+UlBRTWSjSlD/8MLzl/5MVSonsHr/I22effcxnmagofYElTR/DJFY2MYCq6AvDNWvWmLEfDz30kAmZ+Poo+z6Tm5uL//znP/jyyy/NcXy/4edg7y/A9zgoYRUTB47nbgCCsoDoEHfLWwSQuQJY/z8Ebf0OQYW+f1O4OCMqcSBcSXub6qdwVzHCC9IRV7zJ/i0Q1xKI6WHb9xga+cw92marm2J6AzFd/P7bwQdDLYZS9TGovLbEFgCpvwKxtfgZmcPcc7bZdsX4PjWfRxXg9LlMasrfv1kbvH3PG7/d69WrF1asWOE5joHQkUceaT5wMdTw/qOes6gWLFjgcx1bt271nFaZiIgIs5XFN6OyfwDxMP84cjbDxW87OCgwqn6WAjXfdqTZ2w3yb4Ag72tFQ+S9q3QYzH3xxRd47733TJ/8xIkTMX78eMydO9eczmHxfP5//fVX8w0U36QXLVrkWSaXz/1TTz3ld+VPdSuEfJ7zGuI3XrVRVeTcj5reH1Z87Ol1OM9HRb+nIk2NftdF/McgiqMQuNf7gzQH/BzPhY+8Ayl+2c0vM/m51vn826pVKwwdOtTndcHPZKySOv300027H3EO7f/93//hxBNPtGcqKQZK8t1bkZ1JxC3I2VfxWY5fXnMYee5G2/bFKilWLEUk2QqkHXOA9R8Cu36zK7mVHdrdYn8EcQ5SSCSCGGrlbrJ/c0S1AKI7uYOoeN/7YAKwNKAgE4hua1v1OHy8poIbYGD5njIzrqJtN0ttDVzP3epui+wJhHgNhW+G9LlMasLfzySNKpTKysrCypUrcfbZZ3sqmFi9wzeeTz/9tFzSxhlU/BZk27Zt5k2HZsyYYaqdWFVV5xhIsZe7PpTk1toQeeKbMSuf3nrrLYwaNcoc98orr6Bv374mcNp///1NVRXLnhkUMpB64YUXPEEPV0J86aWXEFKD/0GPHDnSVMbx35PXwQ8CvD6nCo4l13TCCSeYPavn+I0XffLJJ6b1kgPu+QF8woQJuOWWWzwVTPwf5rPPPouvvvoKs2bNMlVcL7/8sjkPZ405Fi9ejL333hurV6821//oo4+ax79q1SokJydj3Lhx5ts1DY0VEZHGjtXOGzduNF8wqVJKmqJ169b5zJzl5z3OgWKL3qmnnmoWOdprr73MafzMyi+4X3zxRfM5uGyVO7+A5RerfM1QXFwsPnnnfzj04MHArj/sQG8zpqPQjupgtQyHiJswKtTOUzJfTEfZ8IMVRTyN1U0Mo7hCHquVwFkqwUDOemDX70DWCiB7ra2eKouVOC2H22ocznpiwFTM9rkkUzGFyFa2wqpsGOZZDY+tevFAylAgqr3vzKfmghVjESl2qHtthFLsiGGrZEIfW9kmInWmQf+Pdd1115k//hkKbNq0ySy7ypCD31wwkBozZozpFX/jjTfMYWcgOVs6eD6ezvCJIRYDBM6RuvXWW01bWUWVUM1NVUPkf/nlFxMueQ9y7NOnjzmdA+QZSvHN/dtvv8WFF16I6dOne/rr+VwzWCpbCl0dr732mqnU+vnnn83tsU3wwAMPxOGHH26+tWLIyJCIVXJO8PXjjz/inHPOMaXanD3GANMpsebvjoPh1gMPPIDHH3/cfBBheTbDN+9Q6s033zS3x989J8Xl9XJJXwZTLOfmjAEGXCIiIo1ZdnY2/vjjD/OeplBKmhJ+KcnwiaM95s2bZz6fOk466STst99+ZpREWT169MCDDz5Y/vpWr8bHH3/sWXSmdctEfPXKDRjSOw/Y8p07SHLZyiOGUZz9xGomc/4S956nlbgPB4Gzx034xOPNEPOdQM4GIHudbdtjaFQRhlop+wEpB9gWO4YgXOGN4VPiXrZChyGLdwsdb59zn0xwlm9PYxUWB3DHdq6/L8sbq6g2NgTk87Qn3RbOIPjkwTYYFJGmG0pt2LDBBFAc3Myg6aCDDjJVOvz5+++/N4GF88bijdUtrKZhWPH555+bsIGhS0xMjKmcKTtLqTna3RB5BnisUCo7EJXzpJwh8fwQwOe2e/fu5vlmZRWDLgZKDJJY3fTNN9+YcIrfRlVnqVwGXE6QxHlVTz/9tKlsYijFf3/iffOu9OJj4H3ivzHxQwiH3zM88g6lzjjjDDPHysFv0bjMr/MtG/ui3377bRNgOiZNmuT5mY/1nnvuMY9PoZSIiDR2SUlJ5os67kWaAn6hyC9B+SWjswgRQybv+aT84rGiQKpCDCkKduGfhV8gKSEGqWlZ6NwuGTOePxU922cB6Uts1ZETSjFpYqjBdj0nFGLlFAdel+TZSiqz8bB7sHj+diBnow2NKsNKq5jOQMq+tiqK7XzshigJtoO0o9vbqihWX3kHJAyheF6zOl4UEJ4MRHIIeTwQFueu1BLzvHCVvOJsG9bVBANHtu3FdQOiO+pJFWnqoRSDgcqwEsf5FqMq/FbQGVAo1R8iXxWGTKww8sZWv4cffthUGrGiaNmyZbjoootMEMjgx19lVzVp27atacOsyu+//27mXbFl08EV7fhhhRV10dG2VLdsBdfgwYNNWyIfC0OtH374wdzWySef7DkPZw+wkmzp0qWmIo8r3ZW9XhERkcaIrUz8om5P5zCKNDR+9mfwxGr6tWvXeo7nF5bDhw/3mdFZnTAKOeuA9H8wtvsabJ3WHSUZyxASnIvgnFeBZcHuAIrhk/tnU/7kroLi6msMoMrOf/IHwyUOG4/tDsR2sfOgTLjlDpm4ah5DKhMwxZap1EkDirhKX7gNWOI72oWPGETV1sykpobPS0QrW6FW01CKrZecx8WWykAa9C4SwJphw3HzVHaIPCuQuHIJV8XzrpbioPjK5lCxnY7nPe6448wgSA6T5BBxhju33357te5P2eHj/IDBCqbdzRxjtZRnCKUX73ljrJgri9VSTijFPdsCuYqdUxp+zDHHmKowBl6cKcWVWhje8TlSKCUiIo0Z3x+5KAkrzsuuIiwSKDjL9Morryy3SM8VV1xhKuKrU5HvE0btWgJs/wHY+p2Z62T++GHYxO++i+tg3mxMNyC2q62yYesX51KZYenBdm8Cpt621YyVPU7wwftclAkUpNuZUAysEtqXVkMpIPFPVGsgZ23NWvjYfsnnOb5vzVYtFJEaUSjVTJQdIs8h3wyG2DLHgY/Eqie2uLEVsiyubsJqKIY1ToUSZ1IR9zxcm3jfyl4nV0/hfSzbzukPtvSxXY+ztLhay/PPP+85jccxEGOll7NCACvKREREAgGrR/g+5k+FuUhd4mc3jtlggNSiRQu/qprYqnfbbbfhiSeeMJXqDs495XHVWrzIJ4z6Hdj4JbB9NpC3xfdsQWEoDk1CSFAxgkw65SozL8o5XOJeeS/SBk7O5hxmcOH87IRHXLmPj9s5ProDEJEMhMbZaqiQGN+whJVTnCfFyilenhU6JrBK2rO5SM2Vea5j7CwvPp/+4r9DfhqQNGjPVi4UkWpTKNVEVTVEnvhhgZVALI9mZRC/WeU3UQykvIdIes9c4kp27du3N4c5JPz11183Myy4Kh8P1ybOdWJgxuvl0HrOyWA1FiuaOBeKwy0ZILGlj3OyOANqd9fHsm8+Zn5gOvbYYz2nMeRisPbUU0+Z54wtgt6hlYiISGPGWZFsXedepCENHDjQVDw5v5ec+cTZpNy8f+ZnOWdVPM445Wc+J5ByVkXmKsx+teoxRCrMtKvacRbQrsXA+g+BHfOBIrtIkgeDoxYHwZUwCDvyEtEqYgeC4ARhziypEDtLKti9Z/ucOdkdWjm36fzs2fPBJHsFUHG2KqqyCieGJgyjeJu8XEI/296nCp09wyCQc7m40qG/oRRngvF3J6arbbcUkXqlUGpP8H9gjfR2qhoi73jsscdMsMNKKS4nfcQRR1Q42Jsr77HtjyGUY+LEiVi0aJGZVcWVT7wHjdcGVi0xMOMAdQZhbLHj/eNge1Zscdglq6m4YiBXB/QHW/i4qh5X8PNenYirDPLDD69z8uTJGDFihJkvxfOJiIiICLBr1y6zQvKCBQvMYkT8kq/sXNf+/ft7QqnMzEzz5SG3srjqMsdCEL805ReD/KKTi9dwq3J0Amc8sRqKs3/ytwFZ6+0MoezVdmA5Qym2zHnjSnYtD7aBAweVM+wKjQdiGRzF2OAp2L15/8zNn7Y5p0qxqhDNrOaXBxRxQHq2rZji/YlqZ0MphmBSOzijK2u1DQ939+/HcDB/lx00z+Hz+ncQqXdBLtV6m8HWrBxKT08vN4uBw65Zhty1a9fSuUV8M9nwCVC4q/7+pcKSgA7H6duTAMWXGb8B5LeCNR1EW+HvokgTxDYkLkbQqlUrT0utiFRux44d+Oyzz0y1L1umRGoT542ymv69997zOZ5fDvIztPdnEq7U/Omnn5rPLBwbwWHl3i15Dn7ByJY9b/wi1Zn36bsS2hZb9ZK+FMj4C8hcBeRuAvJ32OooVkOx9aoiDBlS9gPCUoBgd0VSbDeURLbGtsxwtEqORHBdtMjxfnNYubNCn8tp6YuyIRhDMlbzeA83l9rD537bHPuch1cxi4zhJtsmOUMqtpsCqUroc5nURc7iTZVSNcGyWgZEZb+FqUv8pkblvCIiIlIGF/gYMGBAhQt9iOzJF2pcHIbDx1NTU8udHhsbayrZWbXu4JgE71WeGUhxXilXbGZI5WxlV0omE0ix4oghTsFOYOevwPr3gO3zbAjFCid/sP0uaQiQuJcNgBj8RLUHYjrZ9jgOETeVTTXseOBlGTJx3hTDJ/7s7HnfTUAWVDp/igGUWTEvxm7BEZoVVddCIuxcrqwVFYdS/DfM2woEhdrfFc790vwukQajUKrGzxzbv7Qqg4iIiDQszl7s2LGj2YvUhs2bN+PSSy81VU8OVuFx4RiObeDGmZy7q/5mhThnSXHj4HIfXImOq82ZdrZcO19p1x/A5q+AnT8DOet95zVViJUwSTZsikgBwhJswMAQiIe5Cl5km9LZQgwjCt0r3OW5gGz3SnzmqoLcYZWzNJ/7+svdB86dCnZX1XDuVLB7CwWiOtgQxAmgQqIUdjSUyJZA5gp3lZpXayQP52y2vyOJA+z5RKRBKZQSERERCWAFBQXYsmULEhMT1d4ttVIhxVZQrk7sOPXUU83cJ+/ZpDXCeVCFaUB+KpC3GSjMAnI3A1t/AHbOt216rEAqi4PDOSeIq6JFtAIiuG9hQ58Sd5scg6GQWCC6vXvFuxa2KooYfLHVj10OHD7OgdbFQUBSgm3rs4+8zN57VlSIvS4zBL2qTavlNRoMKxlGMoQMT7THsYotZ5OtXkvsb4MpEWlwCqVEREREAlhWVhYWL16MDh06KJSSPcbqp0ceeQSHHnqome333HPP4cQTT6z5FZp2PA4m32GHkxdm2H3qz8COn4CMpRVXRDFUYAte0l5AdCcb+DBUYpBVlG1/ZhDFwCGSK9cl25/ZMkc8nbdphopH2xlOnqHiEUDBNiCmFaDZhU1TcJj9985YZn8vGExyMD4DycS+pb8nItLgFEr5SfPgpaHpd1BERCrCCqnDDjvM7EVq8vmCK+V5D6EdOXIkXnvtNRx99NHlh4/v/gqB4hzbjpe3Hcjb4l4pbweQuhhIXWDbqiqqiKooiOIgas7/YbjFlfFC4uwAc1ZN8fysonIqlNgSyACMwRUrm7hQUHxv28rHCinP+Sq4bWl6WC0XtMxW5jHIjOsDxPcqraATkUZBr8jd4DK1Tml8VJRmSEnD4e+g9++kiIgIcZXK8PBwrVYp1cbV8S655BLk5+dj1qxZPr9D55xzTtUXdoaScwB5sXtjFZRpzdtqg6iCVCDtDyB9CZC10j0g3I8giqunsaqFbXnB7iontuUxZGLVC0MFBlAl7qHo5n6UuIOoOCChvw2ieF5WU0nzxH//MFZJZQGJg4DYLvp9EGmEFErt7gkKDUV0dDS2b99ulr7V8uRS028huQINf592NxS0sqVY+TvI30Veh4iIiHf73u+//44DDjigyiWXRYgB1Oeff45XXnkFX3/9NYqLbVA0depUXHbZZZU/SQycOJ/HCZ+4mTCowFYzcVYU5zaxOipzGZCxHMhe5V6NrgwGBQyhkgZ7teYV2hCLVU6siGKbHcMqBlKscnLCL1ZemQAqxM6UYqVUdGe7yh7b9BhKsXVLhCElK6MQDES11vMh0kjpr9vdYIDQtm1brF692nybJFLTUIrBEkPNmoRSxMt26tSpxpcXEZGmie8veXl5Zi9S2ecQzh179dVX8eabbyI1NdXn9Pbt26Nr164VP3lse8peb4eQsy3PrD4XCriKbDCV+S+Q/jeQs85WR7FKisPHy2KwZIKoIUCMu2KFlVMmzMq0g8K5el5yT/eKefH29ngaK12Co2zg5B1AhUZrNpBUjUPNRaRRUyjlB5bE9+zZ09M+JVJd/ENh586dZi5DTavt1JohIiIVYXXUsGHDVCUlFWJF1OOPP44//vij3GkdO3bEueeei2uvvRYJCQm+J7IqKXsDkL3aBkOh8bYKKu03IO0vIHuNO4Cq4vMxK5nYNsUgKrabDbJMtZNzuSAbPiX0cw8hT7Ite6yW4vnC4+38KM4GMkGUhlOLiDQ1CqX8xCAhMlJvhFLzUIrtn/wdUguoiIiI1HYlVHp6OrZs2WIq/L0DpiVLlvgEUvwswtX0GEaNGjWq/KzKYq5atxnIXGnnQ3H1sk2fAam/Aq4KWvHKYjtdXE8gcQAQ1dFehpVTuRvtqncMqqLalwZN4SnuFsBMG3rxOF4+sqV7fpRa8UREmjKFUiIiIiIBbNeuXfjmm29qtlKaBMyXWwyXfv75Z2zYsMGET2U3zoqi9957DyeddJLnsgyf/vvf/5pquvPOOw+nnnpqxSs1cnA45zUxjOJQ8i3fAlu+AfK3V37HWNnEgIktUiZkSrLzoOCyARRn+oS3cJ8WZ1v4uLFtjxVRbA3M32mPi+1hzxfuXIeIiDQHCqVEREREAhhXB+7Vq5dWCW5ilU/eMyQ5QmKfffbxa5QEAypvAwYMwIoVK9C9e/dKbqzEzoJiGMUQatPXwK5fyq+U5wRHTgBlVrYLsavwMUQKjrTHmQAq3lY8sWqK52GlFIehczYU51AFh7uvr5tXEBVRw2dLREQCmUIpERERkQDGdqwuXbpozEAA27hxI+bOnYt58+aZPWeZvvXWWz7/xgyleHpZLVu2RJs2bTxbjx49yp3HJ5AqYZVStq1S4uymzOXAmv+rvCoqrheQvA8QydXLSuyQc7PKXbw7UIq3AZNZ9S7chlScB8XbyGVAxtCKbXvRtqqKwZWZDxVjV9ATEZFmTaGUiIiISAArLCzE9u3bkZSUhIgIVZs09gqoNWvW4NdffzWr4XHjz2WrmxhSla2Wuuyyy8wsqL59+3oCKAZSnFlZJQZEZnA4W+W40h3nRP0LbJ9rh5anL6m4KiplPyBhkJlFbuY6RbYDYjrY6qeyQ8fNTCgGXdvclVNRQGiMXWWP4RUvw5XyuOKeiIiIF4VSIiIiIgEsMzMTixYtMgOuFUo1rjlQ3EJDSz9uT5s2zcx42p3k5GQzK4x7x1lnneXfDRdx9boMoDDNtuXlbgPytwG7/gAylgAZ/wD5Oyq+LAeMp+wPRHcCirNs8MSfY7vYqignVGKIxRX5GEQxkPK04/UCIpJs1RQro7xCNRERkYoolBIREREJYBxaPXLkyIqHV0uDmDFjBq688kozYPyoo47yHL/XXnuVOy8r3IYMGYL9998fBx54IA444ABznN9KCm1AxCAqdxOQvQ7I2wpkrgDS/wGyVwM56ytfOY9hUvK+QMq+djA5q6oYPiXuBcR0su12noqrTDugnKeHxLpX0UtxV0PFqh1PRESqTaGUiIiISAALDg42Q865l4a1du1aXHPNNfjwww/NYbbmeYdS/fr1w7HHHmvCKQZRQ4cORadOnXza9HaLg8mdgeFcuY4hVPpS24aXtQrI32IrpArTK7mCICCmMxDfG4jrA0S2suflMHK23LXoD0SzTS/GtuIVpNvTWQ0VnmyrqcISbBClVfJERGQPKZQSERERCWDZ2dn466+/MGzYMMTFxTX03WmW8vLy8Mgjj+C+++5Dbm6u5/itW7f6nC88PByffPJJ9W+gpAgoSLNtdzsXADsXAhl/A1lrgLzNtnqpKma+Uzc74ymmvV0pz8E2P1Y7OSvrcSg5by9vu71ezoOK7wtEtbFhlFryRESkFimUEhEREQlgxcXFyMjIMHupf1988QWuuuoqrFy50nNcq1at8NBDD+Hss8+u+RUX57uDqJ1AxlJg1avAlhlASd7uL8sV8iJaAnHdgNieQBQrnyJtOGXmPUXaYIrVTwyhGDaxda8oB8jZaCukGFQl9LOVVN5DzUVERGqRQikRERGRABYfH4/hw4ebvdSfVatWYdKkSfjss888x4WEhGDixIm48847kZCQUP0rZShkgqjttlKJAdG6d4GtM+1A8YowaHJmO4XG29Y7hkmxXe1pDJ2CuYVV3g5oBqNn2PApqqOtpgpP0YwoERGpcwqlRERERESqobCwECNGjMDGjRs9x/Hw008/jYEDB/p/RaxIKsq0QRTnQLEqisEUj1v/AbB5up315F0BxcCJwVNUOyCytW21Y5sdq51iO9vTGChV1mbHweg8Pzf+zPvA6qmEAUBUazsrSkREpJ4olBIREREJYGlpaZg1axbGjh2L5OTkhr47AWnZsmV49tlnTcjEmVDcOCfK+2fOjDrppJPM+cPCwnD77bfjkksuQdu2bc1pp59+un8DyxkicXA4g6jcLUBROlCUb4eGMyha8xaw6csyYVQI0OIAoPUouxpeUTZQsAsozgHCWwDJQ2xIFRrte1uuYnudRXl29Ty4bMUUK6LCWwKRKUBINBCeZCuqRERE6plCKREREZEAFhERgS5dupi9VE9WVhauv/56vPjii7udyZWamupz+IILLjCXv/DCC3ffOslAyLTlpQL5W4HCTNs2FxJlQyFWR614oYLKqBAgZX+gzWG2golhVtZaGypxBT1ukW3sPChii5+ptMqxgVRQsL0NVkLFdrFDy9nSx/CqsnY+ERGReqRQSkRERCSARUVFoXv37mYv1X/u5syZU2kgxdXyIiMjzflYHeWN86Ouueaayq+8KBco2AnkbrN7VjeZSqoQoDAbyFgCpP0FZK4AslZUEEYNs2EUQ6WCVBtIsUUvaS/boheWCLgK7CwoVkwx5OLgcgZOMZ1s9VNorD2sQeUiItJIKZQSERERCWBFRUXYtWuXad1jiCKVKykpQXBwsE+w9MADD+C0007DDTfcgAkTJiAmJsYEUdx4erWUFNsAKW8rkLvZBkmsispaA2QtBzKWAdlr7XkqFAy02M+26TGYMoFTnq2GiukCRCR7VUNl25Y7Vlpx0Hl4gjuEitWAchERCRgKpUREREQCWEZGBn766Se0bNkSLVq0aOi70yi5XC68//77uPXWW/Hmm29in3328Zx21FFHYe3atXs2j4vhEYeU52ywgVPaP8C2b4G0P+wAc85yqgornJKGAK1G2MMMndhqlzjQBk48neEWgyhWSDGgYjufCaFibJueiIhIAFIoJSIiIhLAEhISzMpv3Ev5MOqHH34wVVALFy40x914442YOXOmZyg59zUKpIrzbRDFiqj8bUDOZhtEbfvBhlOVYQUUh5JHdwKi2wMRLW3AxBY8imwJxHS1A8xd+bbVLzQYiOsBRLWxbXkKoUREpIlQKCUiIiISwNhixpazareaNUE7duww4ZP3tnXr1nItfBxQHhcXV70rd7lscMSKJbNy3ka73zEf2Po9kPabHS7uI9gGSdEdbRAV2coGUFyBz1RPBbmHnUcBcd1tVRR/ZuUVW//YrhffxwZXZVfWExERaQIUSomIiIgEsJycHPzzzz+IjY01W3PFiqiRI0dWevqAAQPw4IMPYuzYsZ4qKb9DKIZEbMMryrIznrJWA1tmANvnAEWZ5S/LECpxLyCmGxDM2wqyK+QFcyW8GCCihW3PC3O33wVH2OsuyLBhVVQHILodEJFSurKeiIhIE6R3OREREZEAVlhYaCqEuG/K0tLSMHv2bHz33XdmmzhxIi688ELP6YMGDSp3mcTERDM/6qyzzjJbldVknhAqy4ZQbMvLWgVkrwFyN9nKKB6XswnI962+MpwZUHE97Sp5rGwKT3FXR7kHkDsBFFfaK861K/Tlp9p2PHP5QUCUu5pKRESkGVAoJSIiIhLAOEvq4IMPbnIzpTIzM/Hjjz96QqjFixeb1jvHzz//7BNKJSUl4dRTT0Xbtm2x7777mq1Hjx4VV0UVF9hQyNnS/ga2zgKyVtp5UM6cqHLteBXMh4rrZbeYTjZMYgjFVr3wZHvYVWjDJ95O3nZ7uZBI26YX09q9al6MDaVCtHqiiIg0LwqlRERERKTReOWVVzB16lQsWrQIxcUVh0IMmjgXqqy3337b94iS4tJAiJupgkoDCjLtDKidPwOpi4Cc9f7fwaBQGzwxiOK8JyeEimxt2+1YIcXb5Ewoblw5jwFUZFsgIskdQMXY4zSwXEREmrkahVJFRUX4/vvvsXLlSpxxxhlmUOSmTZsQHx/frGcZiIiIiDREWxs/l40ZM6Zmq8g1IIZOZVvqNm7caKqgyho4cCAOPfRQs3G1QZ/HyvCpJM83gOIQcs5pMq1yBTaMYgCV+iuQ9jtQlF35HQsKswGSU+0UGm8rmtiOZ4KnGHcQ1dKeJyTCrsbHtr/8HbYSyoRVbe3lQ6I1G0pERKQ2Qqm1a9fiyCOPxLp165Cfn4/DDz/chFIcHMnDzz//fHWvUkRERERqKCIiAu3atTP7QMDZV99++y3ef/99fPTRR/jpp59Mm53hKsGhB+1tfuzbpxcOHTEchx5yIA45aH+0bJHsXrHOBbiygWz30PGCdDtsnD9zKDlDqBJ3e172BiB7JbDrNzsfyly+AhwsHtsFiGwDhLOaKQ4IjbSDycMT7cYKqJAY9z7SVjlxFT1WQ+VttRVRvGxCXxtUcYaUPwPVRUREmrFqh1JXXXWVGRj5+++/IyUlxXP8CSecgIsuuqi275+IiIiIVCEqKgq9evUy+/q0YsUKvPjii8jOzjYDxW+66SafivktW7YgPT3dnBYTE2PmQ7333nv4+OOPsWvXLs/5eNzkm26085ay12C/dluxed6jaNMyzg4fRwmQNwfY4ARS7i2oBCgutDObCnbZFrzcLUDeZiB3K1BYehvlcNh4POdAdQEiGESxEioZiO4AhHG2U7Q7fIoqHyxxzhQrohiAMZjiUPPE7raCilVRaskTERGpu1CKHyjmzZuH8HDfQYxdunQx5dYiIiIiUn84VoHhD9vZyn4+qyvffPMNTjnlFHO7DoZS3p577jncddddVV5PdHQ0stO2AdvnA+lLgKzVCMvfjjYMmrYW2cCJw81dRe6NbXrun83g8G1A/nbbprc7DI3i+wLRnYGIZCA4DAhLtAPKzTyoZDu4vCIMwXgbDKP4M4MrM0+qpb2O4CpW9RMREZHaC6W46klFQyc3bNhg2vhEREREpP5kZGSYLwxZwd6iRYs6v71nn30WV155pc/nQc6FYjWUN+/AyhurqcYdcwxOOnY0jty/A6LzlgP/PgfsWgxkrbCtd3uKw8g5zymqPRDVxs5/4pyo4GAglEFUe9uqF9Gi6llPzsBy3ie248V0dl/OHWqJiIhI/YZSHKL5+OOP44UXXvBZ/WTKlCk46qij9uzeiIiIiEi1cKGZ4cOHm31F85s475MtdGefffYeV2RdffXVePrppz3HHXvssZg8eTJyc3PNZ0JvHPfA2+QgdgZUnTt3xvgTTsARIwcjMm8lsHU28O8rtkKKQ8hrygwVb2urnUzlUrJtxzNtdEE2dGI7ngmoeD4GUVVUlDGAKsgAinN8B5ZzyHlo/bZIioiINHVBLpdp1vcbK6KOOOII8GL//vuv+cDBPb+Zmz17Nlq1aoVA/IYxISHBfGCq6AOdyJ5iheG2bdvM6yOY39KKiF4vInX4HsPPaZ9//jmuu+46LF++HC1btjQzoJzPOQyYLrzwQkyaNAmDBw/e7W3wM9Kpp56K6dOne467/vrrcf/995dbPa/iO1loZ0btXACsfRfYMdfOgCo7eJzVTKxGMrOcQnw3tsixAspsPBxuK504hJwzoli5xNCIK+WFxdrrYKjEjVVOPD/b/zyb0xbo/MzWwEJ73RxYzvlSrIji0HMNLG9S9LlMRK8XaTw5S7UrpTp06GCGnL/99tv4448/TJXUBRdcgDPPPLPeB2yKiIiINHesUmLwxDEKbKH77bffcO2115oV7hzbt2/HV199ZYIleuSRR/Daa6/hzTffxI033ojbbrut0tX7eNmRI0fi77//NofDwsIwdepUnHfeeVXfMX7vyQqo3O3Ahg+A9R8CaX/a1fHKYgCUOBhoczgQ39OGTBxwbgIjDjZnq6Cr/GEGVE7wZFbEC7WVTmb1Pa7Clw8U5djNVE0x2GJw5w64GOKZQCsCCAm3q+sxiGLQpYHlIiIidS60RhcKDcVZZ51V+/dGRERERKolPz8fmzZtMpVSDz/8MF555RVTKeU4+OCD8eijj5rqduIsqA8//NBTMXXvvffio48+wssvv4xhw4aVu37OqurZs6cJpThMnecdMWJE5XeIAVD+TiBrDbDuXWDDx0DuhvLn46p1HBaevC+QvDcQ09EGS0XZdsA5QyRTJcW2wHD3Pti9d29m4Hm+HUBe4G4BZLgUFAGEJ5RWTTF0MtVV3pVWzs9lVtcTERGRxhtKTZs2rcrTzznnnD25PyIiIiJSDVxx79dffzXteNnZ2Z7ju3XrZkKqE044wWfeE9vt5syZY1rv7rnnHhNMMXDiXCq28919991mVTwHWwLfeOMNc/0MsLp3717+TnBFvIJUIHcLkLkSWPcOsHl6+VlRbLGL6w3Ecxtgq6I4s4mVTwXpQEieDasYGPE6TbWU9+ZUTJXY62OoFMbgKQEIi3G37Lnb9jSIXEREpOnNlEpKSio3QDMnJ8d8IOIHmNTUVL+v64477sCdd97pc1zv3r2xdOlS83NeXp4pP2erIL8F5CwrrvjSunVrz/nXrVuHyy67DN99951ZzWXChAnmQxarufylmVJS1zS7QESvF5G6ctNNN+HBBx/0HOb8httvvx2XX355pS15Do5iOP/88/HLL7/4hFm8PD9TVYofH4tz7cYKpZwNQMYyYP0HwLYfyrfoccW6xIFAXE/bqhfd0VYxodjOeuIMJ66Qxz1DJu/qJfNR1QmiyuwZPCl8kmrS5zIRvV4kgGdK7dq1q9xxHHTOYIgDL6urf//+mDlzZukd8gqTuMLLF198gffee888mIkTJ+LEE0/E3LlzPeXnRx99NNq0aWOWQt68ebOp1OKsg/vuu6/a90VEREQk0Fx88cVYtmwZfvjhBzNegYESF6Dxx6BBg/DTTz+Z9j5ejl8Crlq1Cueee65p0evatStQUmxXomNbngmh0m0FVHEeUJIHpP9jW/Q4xLzs4HKGUAkDgZgudmW8iFZAWJytagpLcq9qV0EQ5c1p19OMJxERkSan2pVSlVm0aJH5IORUOflbKfXxxx+bgZxlMU3jSjFvvfUWTjrpJHMcr7tv376YP38+9t9/fzOw85hjjjFzFJzqKS57zIGdHMrJ6i1/qFJK6pq+kRPR60WkrnDRGc6ROuiggzBkyJAaXw+DLS5e43z5N2Rgbyz84jGEuLJtAMXZTZz3lL8VyNtmW/UylgJZK3yviC11rIqK72/nRHGFPIZOka3tz/4EUSJ1SJ/LRPR6kQCulKr0ikJDTThUXayyateuHSIjI3HAAQeY1rtOnTqZMnK2Bo4ePdpz3j59+pjTnFCK+4EDB/q087HFj1VbS5YsqfSDGb8F5Ob9ZDlvUNxEaht/r5j/6vdLRK8XkdrGz1D8Ao9f5tXofcYMCs9CzzYh+P7du/HiSy/hp/k/4YrjUhC09EG42J5XuMvMjAoqyqr0alyhsXAlDQHi+gJRbWzLXmiMrZCKam9b9ryDKLOKXq18NypSLfpcJqLXi9Q9fz+TVDuU+vTTT30O8w9tts09/fTTOPDAA6t1XVzh5dVXXzVzpHgdnC/FFWL++usvbNmyxVQ6JSYm+lyGARRPI+69AynndOe0yjD4KjvLilhdxTlWInXxgmRCzNcLB8aKiF4vIrWFX+Jt27bNDCznCAM/3pRsO55pxcsAijJN6BSevgARGYtwUZ+luKzHDgCrgO1+3H54O2TH7Y+8mEFAWDIQzs9uEUBxLBDSAnC1AAqigQJ+IejHFYrUMX0uE9HrRepeZmZm3YRSxx9/vM9hrubCb+ZGjRqF//73v9W6rrFjx/rMNGBI1blzZ7z77ruIiopCXZk8eTKuueYan0qpjh07msdRVVmZyJ58+HFeKwqlRPR6EalNO3fuNAPLOdIgJSWl4jOxIokVT3lbgPztQHEmkLsSSPsDQamLgIx/EOTianeVcwVHAhEpQHgyXOEMn+zPIeFJiI9uh3iexvOwGiqmsx1cHharf2xpdPS5TESvF6mfSu46CaXqsv2IVVG9evXCihUrcPjhh6OgoABpaWk+1VJbt241g82J+wULOFQTPqc7p1WGK9FUtBoNwwIFBlJXGErpd0xErxeR2sZ5DRxrwH25zzElRTaE4up4mauA1IVA+l9A6q/2+IrfsYDIVu4ZUNxza4MgMwcqBgiJRlBotF01j/OjzHDzICAswYZR0e1s255II6bPZSJ6vUjd8jdbqbWZUrU1qHPlypU4++yzsffee5sS9FmzZmH8+PGeAZzr1q0zs6eI+3vvvdeUrLdq1cocN2PGDFPt1K9fvwZ9LCIiIiL1gXM9k5KSfFYwNivlcRh55gpg67fAth+AnQsBV2HFVxKWCMT1sEFUbE8gsb8Nl4IjgOAwIIiLx5QAJfl2BhX3rL7ifKjQWLu6HgeYM6wSERER8ZNfoZR3q9vucElhf1133XUYN26cadnjkPQpU6YgJCQEp59+uvm2jyvA8LaTk5NN0HTFFVeYIIrfBtKYMWNM+MQQ66GHHjJzpG699VZcfvnlFVZCiYiIiDQ1ubm55ku9uNhYxIQXAtmbgG3fAZu+ALbPtTOjymKFE4Mkhk+xPUoDJlY6xfcy1VBm7hRX2ysptqeFhNuQihVT3BhAhUTZUCpEn7tERESkjkKpxYsX+10GWx0bNmwwARRnIXDWDpcy/umnn8zP9Nhjj5mSL1ZKcbU8rqz37LPPei7PAOvzzz83q+0xrIqJicGECRNw1113Vet+iIiIiDQWqanAihV248LG111X9fnzc3OxZsUS9I36HTEZXwE7f664NY9BU1wvG0QlDASCQ4H8nTZ84vwnnsagqTDLhlScDRXFFfMYOkXaAIobLyciIiJSC4JcXA6smeOgc1ZmcXU0DTqXusBZbE6bqeaWiej1Is0bP3lxBCZDp5UrSwMo5/CuXb7nz8oCYiob0VSYiZJ/p6Lwn+cQnr+Kk53KV0Ql9AOS9wMSegNBIfZ4Dj3nxmHlcd2A0Dg7G4pBVHQnIKqV/VmkCdLnMhG9XqTx5Cz6qktERESkFjA82rLFBk7bttl9RdvmzUB2tv/Xu2oVMHBgJSfOn4DgDR+hXPNcdEcgcRAQ39dWPwUFA0W5NngqSAVCYoD43jaU4vDyiBb2MhEtbZueiIiISD2oUSi1aNEivPvuu2boOFfI8/bhhx/W1n0TERERafRVT19/Ddx+Oz8f7dl1cQpCp05Ajx6+W8eOVVyo82nIWD0L89MOwP6tlyGhTT8gaYhdCa+kEHAVAS4OKC9mWZXdR7YBItvaweTR7YGoNnZGFIMrERERkcYcSr399ts455xzzHynb775xgwbX758ObZu3YoTTjihbu6liIiISCPz44/AzTcDc+b4f5mEBKBNG6Br1/LhU5cuQLXXaelwLIK7fYfwLR0RvN+NQJy7PL6kyK6QV1JgV+IrLgBc7oHlEa2A2C5AZCutliciIiKBFUrdd999ZgA5V7iLi4vDE088ga5du+KSSy5B27Zt6+ZeioiIiDQSv/4K3HKLrZDy1r8/MGgQ0KoV0Lp1+Y3ruERG1vKdCYlE9H4PoO+K2YgJzgCy0+3xHEYeFG5XxWNbHudDOcPK+bOGlYuIiEgghlJccvjoo482P4eHhyM7O9usunf11Vdj1KhRuPPOO+vifoqIiIhUqaQEmD8fSEuzbXXceJzzc9mN36X14wzwZP+e2H/+sW1677/ve3yfPsA99wAnnmgLkepbCUKRWxKLkqgkBEcmusMn9xYc0TB3SkRERKQuQqmkpCRkZmaan9u3b4+//voLAwcORFpaGnJycqp7dSIiIiJ7jEHUMccAc+dW/7KsYmI4xa1v39KfWfHEPGfNGoDfuU2bZkMuR+fO9vizzgJC3IvaNYS0zFx8v2gNxo0biBaxLRrujoiIiIjUVSjF8GnAgAEYMWIEZsyYYYKok08+GVdddRW+/fZbc9xhhx1W3dsXERER2SM7dgBHHGHb6mrCWRXvu+98j2cFVc+e9noLC31DrNtuAy68sAYzoOoAxynss88+Zi8iIiLSJEOpQYMGYd9998Xxxx9vwii65ZZbEBYWhnnz5mH8+PG49dZb6/K+ioiIiPjYsgU4/HB+eWYPt2gBTJxoK5dY5VR2Cw62e1Y8rV0L/P233bZtK//EpqYCP/9cejgxEbjxRuCKK4CYmMbzD8HPYi1btjR7ERERkSYZSv3www945ZVXcP/99+Pee+81IdSFF16Im266qW7voYiIiEgFNmwAWKS9fLk9zBlRs2bZFryaVFtxZhQ3J6jitnGjDaAmTQKuu84GU41NXl4e1qxZg/j4eERHRzf03RERERGp/VDq4IMPNttTTz2Fd999F6+++ioOOeQQ9OjRAxdccAEmTJiANlzjWERERKSOrV4NjBpl5z1Rp042kOrRo2bXxwqrgw+2mzeO0YyKAkKrPYWz/uTm5mL58uXo2bOnQikREREJKMHVvUBMTAzOO+88UznFD0Bs5XvmmWfQqVMnHHvssXVzL0VERETcli2z4ZETSHXvDvz4Y80DqapwTFNjDqScRWjGjBlj9iIiIiJNOpTyxiqpm2++2cyS4nDNL774ovbumYiIiEgZf/4JjBhh2+qIrXqzZ9tKKRERERFpJqHU7Nmzce6555qWveuvvx4nnngi5tZkHWYRERERP/zyCzByZOlQ8sGDOfMSaNeueT99GRkZ+Pnnn81eREREJJBUqyB906ZNZpYUtxUrVmD48OF48sknccopp5i2PhEREWneCgsBFk7v3Al07Fi6xcbu2fXOmweMHcsAxh4eNgz46iu2rtXK3Q5owcHBiIyMNHsRERGRJhlKjR07FjNnzkSLFi1wzjnn4Pzzz0fv3r3r9t6JiIhIQM16OussYNGi8qdx1TqGU2yz8w6rGCoVFZVuDLXK/pyV9f/t3QeYVNX9//HPNljYCixdQBGkKF1BEFGqgGDB2GI0QWMLqNii/P5G4BdjiSQ2jBry04hCRCEYRYoUESlSpAioQMQoZeltd4EFduf/fM/NbKEusDuzd+f9ep77nJl7Z2bvDHuY2c+c8z3S009LWVneY9n0vYkTvXpPsMAvUS1atHAtAABAmQyl4uLiNG7cOPXp00cxMTEle1YAAMA3AgHpr3+VHnpI2rfv2LfZvdvbrCbUmejeXfrwQ6lixTN7nLIkNzdXBw8edC2jpQAAQJkMpT766KOSPRMAAOA7Vt/p17+WPv44f58NpP7Nb6TNm6WffpLWr/e2DRu80U+nyxb5HTtWio8vllMvM3bv3q0ZM2aob9++bkQ7AACAX5TyRY4BAEBpNWmS1L9/fuFxc++90vDhxx7JlJsrbdmSH1JZYGVT8+LipNiQ/zR/AAAs9UlEQVTY47e21a4ttW8vRUWF9Cn6gk3ba9WqFdP3AACA7xBKAQCAU2JT9H77W+nVV/P3Va0qvfmm1KfP8e9ndbhr1vS2tm150YtLuXLl3GrI1gIAAPgJoRQAACiypUulW26Rvv02f9+VV0r/939S9eq8kOGQnZ2t9evXKyUlRRUqVOAfAQAA+AahFAAAyJOTYyGHdODA0dunn0pPPplfF8ryjz/9SbrnHqbVhVNWVpZWrlypc845h1AKAAD4CqEUAABl0KZN0vTp0t69x9727Mm/nJGRHzwVtRB569bS6NFS48Yl/UxwMpUrV1avXr1cCwAA4CeEUgAAlDHTpkl9+3ojnoqbFRp/7DFp2DCrZVT8jw8AAIDIQSgFAEAZMm+edM01RQukbHW7lBQpKcmbihcff+ItMVHq109q1y4UzwRFlZGRocWLF+vSSy91daUAAAD8glAKAIAyYvlyr+i4rY5n7PJNN0nJyYU3yy2sLV8+3GeM4hAVFaXo6GjXAgAA+AmhFAAAZcDatVKPHtLu3d717t2l8eMJniJBYmKiWrdu7VoAAAA/iQ73CQAAgDOzfr3UrZu0dat3vX17acIEAqlIEQgElJOT41oAAAA/IZQCAMDHtm3zRkX99JN3vXlz6ZNPpISEcJ8ZQmXXrl369NNPXQsAAOAnhFIAAPjUnj3SFVdIq1d71xs0kKZOlSpVCveZIZQSEhLUvHlz1wIAAPgJoRQAAD5kxcz79pWWLvWu164tTZ8u1agR7jNDqJUvX161a9d2LQAAgJ8QSgEA4DMHD0o/+5n0xRfe9bQ0ado0qV69cJ8ZwiE7O1ubNm1yLQAAgJ8QSgEA4CM5OdJtt0mTJ3vXk5KkKVOkJk3CfWYIl6ysLC1fvty1AAAAfhIb7hMAAAAnZ3nDd99JI0ZIY8d6++LjpYkTpTZteAUjWaVKldS9e3fXAgAA+AmhFAAApcj27dK33x69BVfXC4qNlcaNkzp1CteZorSIiopSbGysawEAAPyEUAoAgDDKzZU++ED661+lFSukbdtOfh/LHt55R7ryylCcIUq7zMxMLV26VJdccomSk5PDfToAAABFRigFAECYwqjx46Vhw6RVq05825QUr2ZUcOvVS7rgglCdKUq7QCCgw4cPuxYAAMBPCKUAAAhxGDVhghdG2ciogmrUkJo2LRxA2Wb7mZmF40lKStJFF13kWgAAAD8hlAIAIARsEMuHH0pDh0pff1342MUXeyFV9+6ETwAAAIgc0eE+AQAAynoY9a9/Sa1bS/36FQ6k2raVJk+W5s2TevQgkMLp2blzp6ZMmeJaAAAAP2GkFAAAxRA8ZWRImzfnb+npXvvpp9KSJYVvf+GF3sgoqw3FtDycqYoVK6pp06auBQAA8BNCKQAAJOXkSO+959V5ssvH2qweVPDyvn35wZNtdv1k2rTxwqjevQmjUHzi4+NVt25d1wIAAPgJoRQAIOLZrKef/1yaOrVkXopWrbwwqk8fwigUv4MHD2rLli1KTU0lmAIAAL5CKAUAiGhW4+naa6V1607v/pUre6vjBbeaNQtfP+ssqVEjwiiUnMzMTC1ZskS1a9cmlAIAAL5CKAUAiFhjx0q3354/9S4tTRoxQqpVS4qJOfFmM6WqVZPKlw/3s0CksxFSXbp0cS0AAICfEEoBACLO4cPS4MHS8OGF6z39859S3brhPDPg1EVHR6t8+fKuBQAA8BM+vQAAIsqOHd6qdwUDqV/+UvriCwIp+FNWVpa+/vpr1wIAAPgJoRQA4LQFAtKsWdL8+d7oo9Ju6VLpwgul6dO967Gx3nS9t96SKlQI99kBpycnJ0f79u1zLQAAgJ+UmlDq2WefVVRUlAYNGpS3b/Pmzbr11ltVo0YNJSQkqHXr1ho/fnyh++3cuVO33HKLkpOTXS2FO+64wxX8BACUfCB1331S585Shw5SlSpSv37Sa69J339f+l790aO98/zPf7zrVg9q5kxpwACKkMPf7DPQxRdf7FoAAAA/KRU1pRYtWqQ33nhDzZs3L7T/tttu0+7du/XRRx8pLS1NY8aM0Q033KDFixerla2vLblAKj09XdOmTdOhQ4fUv39/3XXXXe62AICS88QT0quv5l/fu1eaMMHbTP36UvfuUo8eUpcuVow5tIFZRoaUni5t2uTVirIRUUFt20r2HYetjAcAAAAgQkMpG9VkwdLIkSP11FNPFTo2b948vfbaa2prfz24P4Ce0AsvvKCvvvrKhVLffvutpkyZ4kKtC20+hqRXXnlFvXv31vDhw1XLlk8CABS755+Xnn46/3rv3tKXX9ro1fx969ZJb7zhbVZ/2f4rb9/eW+GucuVjb0lJR/8smxZoA2Bts6CpYLtnj42q9YKnYAAVbIMr6h3pjju8MI1V81BW7Nq1y305Z59/qtiQRQAAAJ8Ieyg1YMAAXXnllerWrdtRoVSHDh00duxYd9ym5r3//vs6cOCALr/8cnd8/vz5bn8wkDL2OLb6zIIFC3Tttdce82dmZ2e7LWivfb0vKTc3121AcbPfq0AgwO8XyoSRI6Xf/jZ/9vcrr+TqN7+xujZezSar1zRtWpTmzpUOHYpyt7H/Wi20su1EYmICqlw5SuXLp+nAgShlZgZcWxzi4gJ66aWA7rrLm67Hf/coK2zlvQYNGriWzzHAyfG5DCg6+gtOV1E/k4Q1lHrvvfe0ZMkSN9LpWCyEuvHGG923frGxsapYsaImTJjgPngFa05Vs6IgBdjtKleu7I4dzzPPPKNhw4YdtX/btm0u9AJKokPu2bPHBVMs2Q0/+9e/4nXvvSl51x97LEM/+1mWtm71rtetK91+u7dlZUXpyy/jNGtWeX3+eXmtXXvyt5ycnCht23Zmb0/JybmqVi1X1avnqHp1a+16jrp1y1aDBjn/fXygbL3H2Jd09iUbdTWBovUZPpcBRX+Pob/gdGTY1IbSHEqtX79eDzzwgBtuHh8ff8zb/O53v3M1paZPn+5qSn344YeuptQXX3yhZs2anfbPHjx4sB566KG86/Yhrk6dOqpatSpFQlFi/5lbIX/7HSOUgl9NmiQNHBilQMAbufTQQwH94Q8JiopKOO59zjlHuvlm7/LGjbluSp9N8bNt1y5ro/Ku5++zqXm5Sk6OVmKiCm02vS+/DbjWvpuw2do1a3pbxYr206KPsZZHYgm+OkD42OjvHTt2qFKlSm60FIAT43MZUHT0F5yu4+U8pSaUsrpQW7dudSvqBdlSxrNnz9aIESO0evVq165cuVLnn3++O96iRQsXSL366qt6/fXX3ap89hgFHT582K3IZ8eOxz6wHetDm4UFBAYoKRZK8TsGv/riC+n66736TsG6TMOHR7nf66KqU8fbivLhZ+vWbW4k7In/Ty6eaX2A32VlZblFYGrWrKkKFSqE+3QAX+BzGUB/QckqarYStlCqa9euWrFiRaF9tnJe48aN9dhjj2nffyvUHvlEYmJi8uYmtm/f3o2ksoCrTZs2bt/MmTPd8Xbt2oXsuQBAWbZkidSnjxSc3WzhlBUvP4U8CkAJSklJcfU2rQUAAPCTsIVSSUlJuuCCCwrtS0hIcPWjbP+hQ4dc7ai7777braRn+236nk33mzhxort9kyZN1LNnT915551u5JTdZ+DAgbrppptYeQ8AisF330lXXGHTnL3rPXtK775rXxDw8gKlhX1hZyOkrAUAAPCToo2nCoO4uDhNmjTJ1eDp27evmjdvrlGjRuntt992Sx4HjR492o2uspFXtr9jx47661//GtZzB4Cy4Mcfpe7dpe3bvesdO0rjx0vlyoX7zAAcOX1v1apVrgUAAPCTsK6+d6RZs2YVut6wYUONt7+ATsBW2hszZkwJnxkARI79+63un02pljZs8Pa1bCl9/HGwiDiA0sTqaVo5A2sBAAD8pFSFUgCA0LK/YVetkhYtkhYu9For95eTk3+b886Tpk6VUlP51wFKI6sldckll1BTCgAA+A6hFABEkJ07vYApGEBZEXMbGXU8detK06ZJ1aqF8iwBAAAARAJCKQCIAHv2SC+8IP35z1JGxvFvZwuenn++dNFFUtu20k032SiMUJ4pgFNlU/ds9WFb/MXKGgAAAPgFoRQAlGFW9/iVV6Q//lHatevo4/Xr5wdQ1rZubSuhhuNMAZyu8uXLq27duq4FAADwE0IpACilVq6U/vUvW+5duuwy6cILbWXSot33wAHJFiJ9+mlpy5b8/bGx0u23S9de6z1eWlqJnT6AEKlQoYIaNGjgWgAAAD8hlAKAUiQ9XfrHP6R33pGWLSt8LDFR6thR6tzZ21q18kKmgg4dkt56S/r97/NXzgtOy7v1VunJJ73RUQDKDlt1b9euXW7qXrly5cJ9OgAAAEVGKAUApWCK3YQJXhA1fbqUm3vs22VmSlOmeJtJTpY6dcoPqWwVvaFDpe+/L3y/G27w9jdpUvLPBUDo7d27V19++aWqVq2qNIY/AgAAHyGUAoAwyMmRZs70gqh//tMLpo5kNZ5sdFN8vPTZZ962eXP+8b17pYkTve1Y+vTxRky1bFlyzwNA+KWkpKhjx46uBQAA8BNCKQAIscmTpTvvlDZuPPpYvXrSL37hbY0b5++32wcC0urV+QHVrFnStm1HP0bXrtJTT0kXX1yyzwNA6RATE6OkpCTXAgAA+AmhFACE0OzZXpHx7Oz8fTa4wabY2aioSy7x6j8dS1SUF1TZdu+9XkhlU/YsoPr8c6++1N13e1P5AESOffv26bvvvlNiYqLbAAAA/IJQCgBC5Ouvpauuyg+kbEW9gQO9aXY2Re9UWUh1wQXedt99xX66AHzi0KFD2rp1q2sBAAD8hFAKAELghx+knj2lPXu863b5o4+kuDhefgBnxmpJderUiZpSAADAd44zSQQAUFys7tMVV0jp6d71tm2lDz4gkAIAAAAQ2QilAKAEZWZKvXtLa9d61xs1kj75RKLsC4DismfPHn3++eeuBQAA8BNCKQAoIQcPSv36SYsXe9dr15amTpXS0njJARSfuLg41ahRw7UAAAB+QigFACUgN1f61a+kadO866mp0pQpUr16vNwAilfFihXVqFEj1wIAAPgJoRQAFLNAQHroIekf//Cu28p6H3/srZIHAMUtJydHGRkZrgUAAPATQikAKGbPPSe99JJ3OSZGev99qWNHXmYAJcNqSc2ZM4eaUgAAwHcIpQCgGL31ljR4cP71kSOlvn15iQGUnOTkZHXo0MG1AAAAfhIb7hMAgLIyZW/0aOnOO/P3PfOM1L9/OM8KQCSIjY1VSkqKawEAAPyEkVIAcIZh1CefSG3bSrfearVdvP2DBkmPPcZLC6Dk7d+/X2vXrnUtAACAnxBKAYhI2dnS1KnelpV1emGU3ffii6U+faTFi/OP3Xab9Kc/SVFRxXrKAHBM2dnZ2rBhg2sBAAD8hHHeACKGBUkLF0pvvy299560a5e3v3x5qXNnqXdv6corpfr1T/wYM2ZIQ4ZI8+YVPtaypTRsmFdDikAKQKikpqaqc+fOrgUAAPATQikAZd5PP0nvviuNGiWtXn30cRtcMGWKt91/v9SokRdOWUh16aVSuXLe7WbNkp58Uvrii8L3b95cGjpUuuYawigAAAAAKCpCKQBlUmamNH68NyrKwiQb4VRQhQpSv35SQoI0aZK0YUP+MQuubPvzn6XERKl7d29UlT1OQU2beiOj7HGimQwNIEz27NmjOXPmqGvXrqpUqRL/DgAAwDcIpQCUGdu2eVPrrPD4P/8p7dt39G0uv9yr+fSzn0lJSd4+C6xWrPDCKbuvTcvLzc0PtyZMKPwYNpLKRkZdf70UExOCJwYAJxAXF6fKlSu7FgAAwE8IpQD4lk27mztX+vRTado0acmSY9+uYUMviPrFL6Szzz76uNV/sil4tj3+uDcqyoqYW0g1ebK0fXv+41gtqZtuIowCUHpUrFhRTZs2dS0AAICfEEoBCAsbnbRsmTeiae1ayWacpKVJVasevdl+q+tk91m1Kj+E+vxzWwr92I9v9X4tPLIwylbIO5XC43Yudl/bcnKkr76SDh70HieW/zUBlDI5OTnKyspybTRziQEAgI/w5xWAkLEpcbb6ndV6sjBq3bqi3zclxQuEduw4/m1s9Tur/2SbFSiPjz/zc7bpeW3bnvnjAEBJ1pSaPXu2+vbtqzRL8QEAAHyCUApAibKRRnPm5AdRGzee3uPs2XP0vtq180Oobt2katXO+HQBwHeSkpLUtm1b1wIAAPgJoRSAYmfT7GbPlsaMkT78UNq69dgjkKzo+HXXSV26SFlZXqHyE21WdLx16/wgqkmTU5uWBwBlkRU4r1KlCoXOAQCA7xBKAShWNirq//0/L5Q6ki0MZWGSBVFXXeXVigIAnJkDBw5o3bp1Sk5Optg5AADwFUIpAMXCVr574glvtbqCrK5Tr15eENWnj1cbCgBQfPbv3+9CqUaNGhFKAQAAXyGUAnBGvvlGevJJr2ZUQQ0bSr/7ndSvn5SQwIsMACWlUqVK6tatm2sBAAD8hFAKwGmxlfOGDZPefddbVS+obl1pyBDpttu81fIAAAAAADiW6GPuBYDj2LRJ+s1vpEaNpFGj8gOp6tWll1+W1qyRbr+dQAoAQmXv3r2aP3++awEAAPyEcQwATujAAWn+fOmzz6RZs6Qvv5QOHco/brNFHntMGjiQaXoAEA4xMTFKTEx0LQAAgJ8QSgEoJDtbWrDAC6FssxDK9h0pMVF68EHp4YcpXg4A4ZSQkKBmzZq5FgAAwE8IpYAIt2WLtHSptGiRNxJq3jxvdNTxNGjgFS9/5BGpatVQnikA4Fhyc3N14MAB10ZHU5kBAAD4B6EUECECAemHH7wAquCWnn7i+51zjtS5s7ddfrl01lmhOmMAQFHs3r1bn332mfr27au0tDReNAAA4BuEUkAZNneuNG6cFz4tWybt2XPy+9jqeQVDqHr1QnGmAIDTZfWk2rRp41oAAAA/IZQCyqBVq6THH5cmTjzx7VJTpVatpJYtvfaSS7yRUVFRoTpTAMCZKleunKpVq+ZaAAAAPyGUAsqQDRukIUOkv//daowUPla7thc8FdxsFBQBFAD4m9WT+vHHH5WcnKyKFSuG+3QAAACKjFAKKAN275aee0568cXCRcqt/tPQodJVV1GUHADKqv379+u7775TgwYNCKUAAICvEEoBJWzyZOmJJ6JUtWqqevWSuneXmjQpnhFK2dnSX/4iPfWUtHNn/v6UFGnwYOn++6UKFc785wAASq9KlSrpiiuucC0AAICfEEoBJWjhQqlfPxu9ZAlUvKZO9fbXrCl17Zq/1alzao9rU/P+8Q8Lu6T//Cd/v5UTGThQ+p//kapUKd7nAgAAAABAcSKUAkrITz950+YKTqcLSk+X3n3X28x550ndunkBVfXq0o4dR2/bt+df3rLFux5ko65uuUX6/e+ls8/mnxQAIklGRoYWLlyoyy67TCk2VBYAAMAnolVKPPvss4qKitKgQYMK7Z8/f766dOmihIQEV8CzU6dOrnZC0M6dO3XLLbe4Y6mpqbrjjjuUmZkZhmcA5MvIkPr08cIjc9llAU2Zsl3PP5/rpvAlJBR+tdas8abhXXed1LGjdPXV0u23S48+an1DGjlSmjBBmj3bW1mvYCDVo4e0ZIn0zjsEUgAQiezzk628Zy0AAICflIqRUosWLdIbb7yh5s2bHxVI9ezZU4MHD9Yrr7yi2NhYLV++XNHR+VmaBVLp6emaNm2aDh06pP79++uuu+7SmDFjwvBMACknR7r5ZmnFCu/VaNBA+uCDgHJyDrt6Uo88Ih08KC1YIM2YIU2f7l0+fLhor57ViEpL80ZXPf64N8IKABC5EhMT1bJlS9cCAAD4SdhDKRvVZMHSyJEj9ZRVay7gwQcf1P3336/H7S/v/2rUqFHe5W+//VZTpkxxodaFF17o9ll41bt3bw0fPly1atUK4TMBPA8/LH3yiXc5NVWaONGr77R1a+HaT5de6m22Op6NrLJRULZZ8XILnew+wa3gdQqXAwAKCgQC7os5awEAAPwk7KHUgAEDdOWVV6pbt26FQqmtW7dqwYIFLrDq0KGDvv/+ezVu3Fh/+MMf1NHmN/13JJVN2QsGUsYex0ZS2X2vvfbaY/7M7OxstwXt3bvXtbm5uW4DTtdrr0kvveSN5IuNDWjcuIAaNvR+t+yPheP9ftl0PpvWZ9vJ8CuKsu5k/QVAYVbKYPr06erTp4+qsMoFwPsMwOcylAJF/Swf1lDqvffe05IlS9xIpyOtW7fOtUOHDnWjnmxY+qhRo9S1a1etXLlSDRs21ObNm1WtWrVC97MpfpUrV3bHjueZZ57RsGHDjtq/bds2HThWVWqgCGbNKqcHHshfjvu55/bq/PP3uxFS1iH37Nnj/tAuOP0UwNHoL8CpsS/azj33XO3bt085NoccwAnxPgMUHf0FZ7IQS6kOpdavX68HHnjA1YKKj48/bqp29913uzpRplWrVpoxY4befPNNFyydLqtR9dBDDxUaKVWnTh1VrVrVFUwHTtU339jvapRycrwis488EtCgQUmSkvJ+n60Arf2OEUoBJ0Z/AU69z1ihc95jgKL3GT6XAfQXlKxj5TylKpT66quv3BS91q1b5+2zb/dmz56tESNGaPXq1W5f06ZNC92vSZMm+umnn9zlGjVquMco6PDhw24Yux07nvLly7vtSBYWEBjgVG3bJl11lYWb3nVbOe/ZZ6MUHV14FST78MPvGFA09Bfg1EZKbdy40ZU0qEDhQYD3GaCY8bkMp6Oo2UrY5hHZNLwVK1Zo2bJleZvVhrIaUna5fv36rlB5MJwKWrNmjerVq+cut2/fXrt373YBV9DMmTPdtx/t2rUL+XNC5LHZntdcI/3wg3e9VStp9GgpJibcZwYAiBRZWVnuM5W1AAAAfhK2kVJJSUm64IILCu1LSEhwBTqD+x999FENGTJELVq0cDWl3n77bX333XcaN25c3qipnj176s4779Trr7/uVp4ZOHCgbrrpJlbeQ4mzRY5+/Wtp3jzvui32+PHHXtFyAABCpVKlSrriiitcCwAA4CdhX33vRAYNGuQKjz/44INuSp6FU1aDyop5Bo0ePdoFUTbyyoaHXXfddXr55ZfDet4oO6xerM0Q3bSp8JaebqP2pM8/925XsaIXSNWuHe4zBgBE6rQKawEAAPwkKmDLgUU4K3SekpLiVkej0HlkW7FCev11acECL3zassWKYZ74PvY3wPjx0rXXHv82NqXU6p/ZapHULQNOjP4CnBr7/DJnzhx17NjRfZ4BwPsMUFz4XIaSzllK9UgpIBQOHZImTJBefVWaPfvU7muf/Z9//sSBFAAAAAAAOBqhFCKWTcEbOVJ64w1vVFRBtlCALeBodaJsq1kz/3LBLS3Nuy0AAOGs09mmTRvXAgAA+AmhFCKKTVadO9cbFWX18g8fLny8cWNp4EDp1lulE4wwBACg1LBKDDa9gooMAADAbwil4GtW72nZMmnnTm8a3sGDXhvcCl7PzJTef19avrzwY9hIp6uvlgYMkLp08WpEAQDgF7t27dLUqVPVt29fpdkQXgAAAJ8glIIv2QinDz6QnnnGK05+Ouxz+113SXffLdWtW9xnCABAaCQkJKhZs2auBQAA8BNCKfhKdrb0zjvSs89K339/eo/Rrp03Kur666X4+OI+QwAAQqt8+fI666yzXAsAAOAnhFLwhaws6W9/81a627jx6JCpa1epXDkpLs7bCl4uuFnNqObNw/UsAAAofgcPHlR6erpSU1MVz7ctAADARwilUKrt3i395S/SCy9I27cXPmZB1P/8j9S5M3WgAACRKzMzU8uWLVOdOnUIpQAAgK8QSqFU1otatUoaO9ZbJW/v3sLHr7pKGjxYuvjicJ0hAAClR6VKldStWzfXAgAA+AmhFMIqEJDWrZMWLZIWLvS2JUuk/fuPXiHvppukxx+XmjUL19kCAFD6REVFKS4uzrUAAAB+QiiFYrFmjfTNN1JMjLdZiFSwLXh527b8EMranTuP/7hWB+pXv5J++1upQQP+sQAAON70vQ4dOig5OZkXCAAA+AahFM7IgQPe6KWXXiq+F/Kcc6SLLpLatpVuvFE666zie2wAAMqaQCDgip1bCwAA4CeEUjhtX38t3XKLtHLl6T9G1ape+BQMoS680NsHAACKJikpSW3btnUtAACAnxBK4ZTl5kovvugVGz940NtXvrx0331SaqqUk+Pd5nitrVbdurUXRNWrx8p5AAAAAABEIkIpnJKNG6Vf/lKaMSN/X/Pm0pgx0vnn82ICABBqu3bt0tSpU9WnTx9VqVKFfwAAAOAb0eE+AYTWoUPSyy9LvXpJd94pjR3rFR4vinHjvJXvCgZSjzziFSwnkAIAIDwqVKigxo0buxYAAMBPGCkVIaz26aRJ0sMPS6tX5+//29+8tlUrqVs3b7v0UvuAm3+bjAzp/vulv/89f1/t2tKoUVKXLiF8EgAA4Cjx8fGqV6+eawEAAPyEUCoCfPON9NBD0tSpx7/N0qXe9vzzXn2oSy7xAqqGDaXHHpPWrcu/7fXXS6+/LlWuHJLTBwAAJ2Ar723dulWpqakEUwAAwFcIpcqwHTukoUOl117ziowHWeD0xz9K+/ZJ06ZJ06d7gVRwJensbGnmTG8rKDFRGjFCuu02ipMDAFBaZGZm6quvvlKtWrUIpQAAgK8QSpXRulEWRFkgtWtX/v66db2RUDbSKSrK22ejocz27V4IZQGVBVX/+U/hx+zQQXrnHal+/RA+EQAAcFI2Qqpz586uBQAA8BNCqTJmyhRvqt633+bvq1hRGjzYqyd1vBqoaWnSDTd4m42Ysul6FlDNnSu1bOnVlIrltwUAgFInOjrajZCyFgAAwE+IGcqINWukQYOkyZML77epds88I9WqVfTHslFU557rbXffXeynCgAAilFWVpZWrFihiy++WElJSby2AADANwilyogNGwoHUjbd7sUXpYsuCudZAQCAkpaTk+PqSlkLAADgJ4zzLiO6dJGuvlqqU0caM0aaM4dACgCASJCcnKz27du7FgAAwE8YKVWGvPGGZKP2rYYUAAAAAABAacZIqTKkenUCKQAAIs2uXbs0ffp01wIAAPgJoRQAAICPVahQQfXr13ctAACAnxBKAQAA+Fh8fLwLpawFAADwE0IpAAAAHzt06JB27NjhWgAAAD8hlAIAAPCxjIwMLVy40LUAAAB+QigFAADgYykpKerUqZNrAQAA/IRQCgAAwMdiYmKUkJDgWgAAAD8hlAIAAPCxffv26ZtvvnEtAACAnxBKAQAA+JgVON+5cyeFzgEAgO8QSgEAAPiY1ZLq2LEjNaUAAIDvEEoBAAAAAAAg5GJD/yNLn0Ag4Nq9e/eG+1RQRuXm5rqluuPj4xUdTRYM0F+A4mNT92bMmKGuXbuqcuXKvLQAn8uAYsPfMThdwXwlmLccD6GU5MICU6dOndN+wQEAAAAAAFA4b7FSA8cTFThZbBUh6e+mTZuUlJSkqKiocJ8OymhKbKHn+vXrlZycHO7TAUo1+gtAnwF4nwFKBz6X4XRZ1GSBVK1atU44W4iRUlZYKzpaZ5111mm/2EBRWSBFKAXQX4CSwHsMQJ8BSgrvMTgdJxohFURxGwAAAAAAAIQcoRQAAAAAAABCjlAKCIHy5ctryJAhrgVAfwF4jwHCh89lAP0FpQeFzgEAAAAAABByjJQCAAAAAABAyBFKAQAAAAAAIOQIpQAAAAAAABByhFJAMXj22WcVFRWlQYMGFdo/f/58denSRQkJCUpOTlanTp20f//+vOM7d+7ULbfc4o6lpqbqjjvuUGZmJv8miMg+s3nzZt16662qUaOG6zOtW7fW+PHjC92PPoNIMXToUNdHCm6NGzfOO37gwAENGDBAVapUUWJioq677jpt2bKl0GP89NNPuvLKK1WxYkVVq1ZNjz76qA4fPhyGZwOEt8/Ye8d9992nRo0aqUKFCqpbt67uv/9+7dmzp9Bj0GcQKU72HhMUCATUq1cvd/zDDz8sdIz+guISW2yPBESoRYsW6Y033lDz5s2PCqR69uypwYMH65VXXlFsbKyWL1+u6Oj8LNgCqfT0dE2bNk2HDh1S//79ddddd2nMmDFheCZAePvMbbfdpt27d+ujjz5SWlqa6wc33HCDFi9erFatWrnb0GcQSc4//3xNnz4977q9jwQ9+OCD+uSTT/TBBx8oJSVFAwcOVL9+/TR37lx3PCcnxwVSFvLOmzfPvddYH4uLi9PTTz8dlucDhKvPbNq0yW3Dhw9X06ZN9eOPP+qee+5x+8aNG+duQ59BpDnRe0zQiy++6AKpI9FfUKwCAE5bRkZGoGHDhoFp06YFLrvsssADDzyQd6xdu3aBJ5544rj3/eabbwLWBRctWpS3b/LkyYGoqKjAxo0b+VdBxPWZhISEwKhRowrdvnLlyoGRI0e6y/QZRJIhQ4YEWrRoccxju3fvDsTFxQU++OCDvH3ffvute0+ZP3++uz5p0qRAdHR0YPPmzXm3ee211wLJycmB7OzsEDwDoPT0mWN5//33A+XKlQscOnTIXafPIJIUpb8sXbo0ULt27UB6erp7f5kwYULeMfoLihPT94AzYFMn7Jvobt26Fdq/detWLViwwE2X6NChg6pXr67LLrtMc+bMKTSSyqbsXXjhhXn77HFsJJXdFyiLjtdnjPWVsWPHumkWubm5eu+999wUpcsvv9wdp88g0qxdu1a1atVS/fr13ShBmyphvvrqKze6tmA/smkXNiXJ+omxtlmzZu79J+iKK67Q3r17tWrVqjA8GyB8feZYbOqelU8Ijg6hzyDSnKi/7Nu3Tz//+c/16quvuhG3R6K/oDgxfQ84TfYH85IlS9xUpCOtW7cub762DRVv2bKlRo0apa5du2rlypVq2LChq59joVWhDhkbq8qVK7tjQCT1GfP+++/rxhtvdDVyrC9YHZwJEyaoQYMG7jh9BpGkXbt2+vvf/+5q4NjUu2HDhunSSy917yHWF8qVK+e+2CjIAqjg+4e1BQOp4PHgMSCS+kxSUlKh227fvl2///3vXcmEIPoMIsnJ+otNEbcvC6+++upj3p/+guJEKAWchvXr1+uBBx5wtaDi4+OPOm6jPMzdd9/t6kQZq4kzY8YMvfnmm3rmmWd43RFRTtZnzO9+9ztXU8rqG1hNKSuoaTWlvvjiCzfiA4gkVlg2yOqv2R8Q9erVc+GtFWoGUPQ+YwvJBNloQRuxa7Wl7MtDIBKdqL9UrVpVM2fO1NKlS8N6jogcTN8DToNNnbAperY6mI3osO3zzz/Xyy+/7C4Hv422DzwFNWnSJG9orA2FtccoyFZFsqlLxxomC5TlPvP9999rxIgRLrS1EYUtWrTQkCFD3PRWGzpu6DOIZDYq6rzzztO///1v1xcOHjzoQtyCbPW94PuHtUeuxhe8znsMIq3PBGVkZLhFaGwkiI3EtcL/QfQZRLKC/cUCKftcZvuCn9mMrfIaLKlAf0FxIpQCToP90bxixQotW7Ysb7M/nm0+tl22udk2R3v16tWF7rdmzRr3LYRp3769+4PC/lgPsjcBG2Vl31YAkdRnrHaBKbg6pYmJickbeUifQSTLzMx0fyTUrFlTbdq0cX9M2+jbIHu/sS89rJ8Ya63PFfzyw0YqWg2dI78wAcp6nwmOkOrRo4eb+mqrvB45apc+g0hWsL88/vjj+vrrrwt9ZjMvvPCC3nrrLXeZ/oJiVaxl04EIduRKYi+88IJb5chWR1q7dq1biS8+Pj7w73//O+82PXv2DLRq1SqwYMGCwJw5c9yqZDfffHOYngEQvj5z8ODBQIMGDQKXXnqp6w/WT4YPH+5Wo/zkk0/y7kOfQaR4+OGHA7NmzQr88MMPgblz5wa6desWSEtLC2zdutUdv+eeewJ169YNzJw5M7B48eJA+/bt3RZ0+PDhwAUXXBDo0aNHYNmyZYEpU6YEqlatGhg8eHAYnxUQnj6zZ88etypys2bN3PuLrSYW3KyvGPoMIsnJ3mOOdOTqe/QXFCdqSgElZNCgQW7lMCsUaFPybDqSfUt97rnn5t1m9OjRGjhwoBtFYiNEbFisTWcCIo2N+pg0aZL7dq5v377uGzsrcP7222+rd+/eebejzyBSbNiwQTfffLN27Njh6nt07NhRX375pbsc/MY6+L6RnZ3tVtb7y1/+UmiU4cSJE3Xvvfe6b7QTEhL0y1/+Uv/7v/8bxmcFhKfPzJo1K29l4+DiGUE//PCDzj77bPoMIsrJ3mNOhvcYFKcoS6aK9REBAAAAAACAk6CmFAAAAAAAAEKOUAoAAAAAAAAhRygFAAAAAACAkCOUAgAAAAAAQMgRSgEAAAAAACDkCKUAAAAAAAAQcoRSAAAAAAAACDlCKQAAAAAAAIQcoRQAAEAp8qtf/UrXXHNNuE8DAACgxMWW/I8AAACAiYqKOuELMWTIEL300ksKBAK8YAAAoMwjlAIAAAiR9PT0vMtjx47Vk08+qdWrV+ftS0xMdBsAAEAkYPoeAABAiNSoUSNvS0lJcSOnCu6zQOrI6XuXX3657rvvPg0aNEiVKlVS9erVNXLkSGVlZal///5KSkpSgwYNNHny5EI/a+XKlerVq5d7TLvPrbfequ3bt/NvDQAASg1CKQAAgFLu7bffVlpamhYuXOgCqnvvvVfXX3+9OnTooCVLlqhHjx4udNq3b5+7/e7du9WlSxe1atVKixcv1pQpU7RlyxbdcMMN4X4qAAAAeQilAAAASrkWLVroiSeeUMOGDTV48GDFx8e7kOrOO+90+2wa4I4dO/T111+7248YMcIFUk8//bQaN27sLr/55pv67LPPtGbNmnA/HQAAAIeaUgAAAKVc8+bN8y7HxMSoSpUqatasWd4+m55ntm7d6trly5e7AOpY9am+//57nXfeeSE5bwAAgBMhlAIAACjl4uLiCl23WlQF9wVX9cvNzXVtZmam+vbtq+eee+6ox6pZs2aJny8AAEBREEoBAACUMa1bt9b48eN19tlnKzaWj3sAAKB0oqYUAABAGTNgwADt3LlTN998sxYtWuSm7E2dOtWt1peTkxPu0wMAAHAIpQAAAMqYWrVqae7cuS6AspX5rP7UoEGDlJqaquhoPv4BAIDSISoQCATCfRIAAAAAAACILHxVBgAAAAAAgJAjlAIAAAAAAEDIEUoBAAAAAAAg5AilAAAAAAAAEHKEUgAAAAAAAAg5QikAAAAAAACEHKEUAAAAAAAAQo5QCgAAAAAAACFHKAUAAAAAAICQI5QCAAAAAABAyBFKAQAAAAAAIOQIpQAAAAAAAKBQ+/8qTkSHTfx79AAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Plot quantile forecasts for all models\n", "fig, axes = plt.subplots(3, 1, figsize=(12, 12))\n", @@ -276,17 +312,19 @@ "\n", "for idx, (name, quantiles) in enumerate(quantile_models.items()):\n", " ax = axes[idx]\n", - " \n", + "\n", " # Plot training data (last horizon points)\n", - " ax.plot(train_context_indices, train_data[0, train_context_start:, 0], label=\"Training Data\", color=\"blue\", linewidth=2)\n", - " \n", + " ax.plot(\n", + " train_context_indices, train_data[0, train_context_start:, 0], label=\"Training Data\", color=\"blue\", linewidth=2\n", + " )\n", + "\n", " # Plot test data\n", " ax.plot(test_indices, test_data[0, :, 0], label=\"Test Data\", color=\"black\", linewidth=2, linestyle=\"--\")\n", - " \n", + "\n", " # Plot median (index 2 for 0.5 quantile)\n", " median_idx = 2\n", " ax.plot(test_indices, quantiles[0, :, median_idx, 0], label=\"Median Forecast\", color=colors[name], linewidth=2)\n", - " \n", + "\n", " # Plot prediction intervals\n", " # 80% interval (0.1 to 0.9)\n", " ax.fill_between(\n", @@ -295,9 +333,9 @@ " quantiles[0, :, 4, 0], # 0.9 quantile\n", " alpha=0.2,\n", " color=colors[name],\n", - " label=\"80% Interval\"\n", + " label=\"80% Interval\",\n", " )\n", - " \n", + "\n", " # 50% interval (0.25 to 0.75)\n", " ax.fill_between(\n", " test_indices,\n", @@ -305,9 +343,9 @@ " quantiles[0, :, 3, 0], # 0.75 quantile\n", " alpha=0.3,\n", " color=colors[name],\n", - " label=\"50% Interval\"\n", + " label=\"50% Interval\",\n", " )\n", - " \n", + "\n", " ax.axvline(x=train_size, color=\"gray\", linestyle=\":\", linewidth=1, alpha=0.7)\n", " ax.set_xlabel(\"Time\")\n", " ax.set_ylabel(\"Value\")\n", @@ -317,20 +355,7 @@ "\n", "plt.tight_layout()\n", "plt.show()" - ], - "outputs": [ - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "execution_count": 8 + ] }, { "cell_type": "markdown", diff --git a/faim_sdk/client.py b/faim_sdk/client.py index 9fda265..7562fd0 100644 --- a/faim_sdk/client.py +++ b/faim_sdk/client.py @@ -1,4 +1,4 @@ -""" FAIM SDK client for time-series forecasting. +"""FAIM SDK client for time-series forecasting. Provides high-level, type-safe API with automatic serialization, error handling, and observability. @@ -197,10 +197,7 @@ def _reshape_univariate_response( if response.samples is not None: modified_response.samples = response.samples - logger.debug( - f"Reshaped univariate response: " - f"original_batch={original_batch_size}, features={num_features}" - ) + logger.debug(f"Reshaped univariate response: original_batch={original_batch_size}, features={num_features}") return modified_response @@ -465,9 +462,7 @@ def forecast(self, request: ForecastRequest) -> ForecastResponse: # If univariate transformation was applied, reshape response back if transform_shape_info is not None: original_batch_size, num_features = transform_shape_info - forecast_response = _reshape_univariate_response( - forecast_response, original_batch_size, num_features - ) + forecast_response = _reshape_univariate_response(forecast_response, original_batch_size, num_features) logger.info(f"Forecast successful: {forecast_response}") return forecast_response @@ -651,9 +646,7 @@ async def forecast_async(self, request: ForecastRequest) -> ForecastResponse: # If univariate transformation was applied, reshape response back if transform_shape_info is not None: original_batch_size, num_features = transform_shape_info - forecast_response = _reshape_univariate_response( - forecast_response, original_batch_size, num_features - ) + forecast_response = _reshape_univariate_response(forecast_response, original_batch_size, num_features) logger.info(f"Async forecast successful: {forecast_response}") return forecast_response diff --git a/faim_sdk/eval/__init__.py b/faim_sdk/eval/__init__.py index fc1bde6..02db051 100644 --- a/faim_sdk/eval/__init__.py +++ b/faim_sdk/eval/__init__.py @@ -75,4 +75,4 @@ "crps_from_quantiles", # Visualization "plot_forecast", -] \ No newline at end of file +] diff --git a/faim_sdk/eval/metrics.py b/faim_sdk/eval/metrics.py index b1b7fdd..833f6a1 100644 --- a/faim_sdk/eval/metrics.py +++ b/faim_sdk/eval/metrics.py @@ -122,17 +122,11 @@ def mse( # Shape validation if y_true.ndim != 3: - raise ValueError( - f"y_true must be 3-dimensional (batch_size, horizon, features), got shape {y_true.shape}" - ) + raise ValueError(f"y_true must be 3-dimensional (batch_size, horizon, features), got shape {y_true.shape}") if y_pred.ndim != 3: - raise ValueError( - f"y_pred must be 3-dimensional (batch_size, horizon, features), got shape {y_pred.shape}" - ) + raise ValueError(f"y_pred must be 3-dimensional (batch_size, horizon, features), got shape {y_pred.shape}") if y_true.shape != y_pred.shape: - raise ValueError( - f"y_true and y_pred must have the same shape, got {y_true.shape} and {y_pred.shape}" - ) + raise ValueError(f"y_true and y_pred must have the same shape, got {y_true.shape} and {y_pred.shape}") # Empty validation if y_true.size == 0: @@ -215,17 +209,11 @@ def mae( # Shape validation if y_true.ndim != 3: - raise ValueError( - f"y_true must be 3-dimensional (batch_size, horizon, features), got shape {y_true.shape}" - ) + raise ValueError(f"y_true must be 3-dimensional (batch_size, horizon, features), got shape {y_true.shape}") if y_pred.ndim != 3: - raise ValueError( - f"y_pred must be 3-dimensional (batch_size, horizon, features), got shape {y_pred.shape}" - ) + raise ValueError(f"y_pred must be 3-dimensional (batch_size, horizon, features), got shape {y_pred.shape}") if y_true.shape != y_pred.shape: - raise ValueError( - f"y_true and y_pred must have the same shape, got {y_true.shape} and {y_pred.shape}" - ) + raise ValueError(f"y_true and y_pred must have the same shape, got {y_true.shape} and {y_pred.shape}") # Empty validation if y_true.size == 0: @@ -341,43 +329,33 @@ def mase( # Shape validation if y_true.ndim != 3: - raise ValueError( - f"y_true must be 3-dimensional (batch_size, horizon, features), got shape {y_true.shape}" - ) + raise ValueError(f"y_true must be 3-dimensional (batch_size, horizon, features), got shape {y_true.shape}") if y_pred.ndim != 3: - raise ValueError( - f"y_pred must be 3-dimensional (batch_size, horizon, features), got shape {y_pred.shape}" - ) + raise ValueError(f"y_pred must be 3-dimensional (batch_size, horizon, features), got shape {y_pred.shape}") if y_train.ndim != 3: raise ValueError( f"y_train must be 3-dimensional (batch_size, train_length, features), got shape {y_train.shape}" ) if y_true.shape != y_pred.shape: - raise ValueError( - f"y_true and y_pred must have the same shape, got {y_true.shape} and {y_pred.shape}" - ) + raise ValueError(f"y_true and y_pred must have the same shape, got {y_true.shape} and {y_pred.shape}") batch_size_true, _, features_true = y_true.shape batch_size_train, train_length, features_train = y_train.shape if batch_size_true != batch_size_train: raise ValueError( - f"Batch size mismatch: y_true has {batch_size_true} samples, " - f"y_train has {batch_size_train} samples" + f"Batch size mismatch: y_true has {batch_size_true} samples, y_train has {batch_size_train} samples" ) if features_true != features_train: raise ValueError( - f"Feature count mismatch: y_true has {features_true} features, " - f"y_train has {features_train} features" + f"Feature count mismatch: y_true has {features_true} features, y_train has {features_train} features" ) # Training data length validation if train_length < 2: - raise ValueError( - f"y_train must have at least 2 time steps for naive baseline, got {train_length}" - ) + raise ValueError(f"y_train must have at least 2 time steps for naive baseline, got {train_length}") # Empty validation if y_true.size == 0: @@ -551,9 +529,7 @@ def crps_from_quantiles( # Shape validation if y_true.ndim != 3: - raise ValueError( - f"y_true must be 3-dimensional (batch_size, horizon, features), got shape {y_true.shape}" - ) + raise ValueError(f"y_true must be 3-dimensional (batch_size, horizon, features), got shape {y_true.shape}") if quantile_preds.ndim != 3: raise ValueError( f"quantile_preds must be 3-dimensional (batch_size, horizon, num_quantiles), " @@ -565,29 +541,22 @@ def crps_from_quantiles( if batch_size_true != batch_size_pred: raise ValueError( - f"Batch size mismatch: y_true has {batch_size_true} samples, " - f"quantile_preds has {batch_size_pred} samples" + f"Batch size mismatch: y_true has {batch_size_true} samples, quantile_preds has {batch_size_pred} samples" ) if horizon_true != horizon_pred: - raise ValueError( - f"Horizon mismatch: y_true has {horizon_true} steps, " - f"quantile_preds has {horizon_pred} steps" - ) + raise ValueError(f"Horizon mismatch: y_true has {horizon_true} steps, quantile_preds has {horizon_pred} steps") # Quantile levels validation if len(quantile_levels) != num_quantiles: raise ValueError( - f"quantile_levels length ({len(quantile_levels)}) must match " - f"num_quantiles dimension ({num_quantiles})" + f"quantile_levels length ({len(quantile_levels)}) must match num_quantiles dimension ({num_quantiles})" ) if not all(0.0 <= q <= 1.0 for q in quantile_levels): raise ValueError(f"quantile_levels must be in [0.0, 1.0], got {quantile_levels}") if quantile_levels != sorted(quantile_levels): - raise ValueError( - f"quantile_levels must be sorted in ascending order, got {quantile_levels}" - ) + raise ValueError(f"quantile_levels must be sorted in ascending order, got {quantile_levels}") # Empty validation if y_true.size == 0: @@ -656,4 +625,4 @@ def crps_from_quantiles( # Average over horizon, keep batch dimension return np.mean(crps_values, axis=1) else: - raise ValueError(f"reduction must be 'mean' or 'none', got '{reduction}'") \ No newline at end of file + raise ValueError(f"reduction must be 'mean' or 'none', got '{reduction}'") diff --git a/faim_sdk/eval/visualization.py b/faim_sdk/eval/visualization.py index 867e07e..f5ac3f8 100644 --- a/faim_sdk/eval/visualization.py +++ b/faim_sdk/eval/visualization.py @@ -236,14 +236,10 @@ def plot_forecast( if test_data is not None: test_horizon, test_features = test_data.shape if test_horizon != horizon: - raise ValueError( - f"Horizon mismatch: forecast has {horizon} steps, " - f"test_data has {test_horizon} steps" - ) + raise ValueError(f"Horizon mismatch: forecast has {horizon} steps, test_data has {test_horizon} steps") if test_features != num_features: raise ValueError( - f"Feature count mismatch: forecast has {num_features} features, " - f"test_data has {test_features} features" + f"Feature count mismatch: forecast has {num_features} features, test_data has {test_features} features" ) # Validate feature count for single plot @@ -258,12 +254,11 @@ def plot_forecast( if num_features == 1: feature_names = ["Series"] else: - feature_names = [f"Feature {i+1}" for i in range(num_features)] + feature_names = [f"Feature {i + 1}" for i in range(num_features)] else: if len(feature_names) != num_features: raise ValueError( - f"feature_names length ({len(feature_names)}) must match " - f"number of features ({num_features})" + f"feature_names length ({len(feature_names)}) must match number of features ({num_features})" ) # Create time indices @@ -397,4 +392,4 @@ def plot_forecast( if save_path is not None: fig.savefig(save_path, dpi=300, bbox_inches="tight") - return fig, axes \ No newline at end of file + return fig, axes diff --git a/faim_sdk/models.py b/faim_sdk/models.py index 2773606..8ef2961 100644 --- a/faim_sdk/models.py +++ b/faim_sdk/models.py @@ -238,9 +238,7 @@ def __post_init__(self) -> None: f"got prediction_type='{self.prediction_type}'" ) if self.output_type == "point" and self.prediction_type == "quantile": - raise ValueError( - "output_type='point' conflicts with prediction_type='quantile'" - ) + raise ValueError("output_type='point' conflicts with prediction_type='quantile'") def to_arrays_and_metadata(self) -> tuple[dict[str, np.ndarray], dict[str, Any]]: """Convert FlowState request to Arrow format. @@ -330,8 +328,4 @@ def __repr__(self) -> str: outputs_str = ", ".join(outputs) if outputs else "None" - return ( - f"ForecastResponse(" - f"outputs=[{outputs_str}], " - f"metadata={self.metadata})" - ) + return f"ForecastResponse(outputs=[{outputs_str}], metadata={self.metadata})" diff --git a/tests/unit/test_client.py b/tests/unit/test_client.py index b245bac..58580a0 100644 --- a/tests/unit/test_client.py +++ b/tests/unit/test_client.py @@ -690,12 +690,7 @@ def test_flowstate_multivariate_quantile_forecast(self, mock_post): mock_post.return_value = mock_response client = ForecastClient(base_url="https://api.example.com") - request = FlowStateForecastRequest( - x=data, - horizon=8, - prediction_type="quantile", - output_type="quantiles" - ) + request = FlowStateForecastRequest(x=data, horizon=8, prediction_type="quantile", output_type="quantiles") # Execute with warning capture with pytest.warns(UserWarning, match="FlowState model only supports univariate forecasting"): diff --git a/tests/unit/test_eval_metrics.py b/tests/unit/test_eval_metrics.py index d015dc0..2761727 100644 --- a/tests/unit/test_eval_metrics.py +++ b/tests/unit/test_eval_metrics.py @@ -32,16 +32,14 @@ def test_mse_known_values(self): def test_mse_reduction_none(self): """Test MSE with reduction='none' returns per-sample metrics.""" - y_true = np.array([ - [[1.0], [2.0]], - [[3.0], [4.0]], - [[5.0], [6.0]] - ]) - y_pred = np.array([ - [[2.0], [3.0]], # Errors: 1, 1 -> MSE = 1.0 - [[3.0], [4.0]], # Errors: 0, 0 -> MSE = 0.0 - [[6.0], [8.0]] # Errors: 1, 2 -> MSE = (1+4)/2 = 2.5 - ]) + y_true = np.array([[[1.0], [2.0]], [[3.0], [4.0]], [[5.0], [6.0]]]) + y_pred = np.array( + [ + [[2.0], [3.0]], # Errors: 1, 1 -> MSE = 1.0 + [[3.0], [4.0]], # Errors: 0, 0 -> MSE = 0.0 + [[6.0], [8.0]], # Errors: 1, 2 -> MSE = (1+4)/2 = 2.5 + ] + ) result = mse(y_true, y_pred, reduction="none") @@ -153,21 +151,15 @@ def test_mase_worse_than_naive(self): def test_mase_reduction_none(self): """Test MASE with reduction='none' returns per-sample metrics.""" - y_train = np.array([ - [[1.0], [2.0], [3.0]], - [[2.0], [4.0], [6.0]], - [[5.0], [5.0], [5.0]] - ]) - y_true = np.array([ - [[4.0]], - [[8.0]], - [[5.0]] - ]) - y_pred = np.array([ - [[4.5]], # Error: 0.5, Naive MAE: 1.0 -> MASE: 0.5 - [[9.0]], # Error: 1.0, Naive MAE: 2.0 -> MASE: 0.5 - [[6.0]] # Error: 1.0, Naive MAE: 0.0 -> MASE: inf (constant) - ]) + y_train = np.array([[[1.0], [2.0], [3.0]], [[2.0], [4.0], [6.0]], [[5.0], [5.0], [5.0]]]) + y_true = np.array([[[4.0]], [[8.0]], [[5.0]]]) + y_pred = np.array( + [ + [[4.5]], # Error: 0.5, Naive MAE: 1.0 -> MASE: 0.5 + [[9.0]], # Error: 1.0, Naive MAE: 2.0 -> MASE: 0.5 + [[6.0]], # Error: 1.0, Naive MAE: 0.0 -> MASE: inf (constant) + ] + ) result = mase(y_true, y_pred, y_train, reduction="none") @@ -276,14 +268,13 @@ def test_crps_single_quantile_equals_mae(self): def test_crps_reduction_none(self): """Test CRPS with reduction='none' returns per-sample metrics.""" - y_true = np.array([ - [[5.0]], - [[6.0]] - ]) - quantile_preds = np.array([ - [[5.0]], # Perfect prediction - [[7.0]] # Error of 1 - ]) + y_true = np.array([[[5.0]], [[6.0]]]) + quantile_preds = np.array( + [ + [[5.0]], # Perfect prediction + [[7.0]], # Error of 1 + ] + ) quantile_levels = [0.5] result = crps_from_quantiles(y_true, quantile_preds, quantile_levels, reduction="none") @@ -329,7 +320,7 @@ def test_crps_shape_mismatch_error(self): crps_from_quantiles( y_true, np.array([[[4.0, 5.0]], [[4.0, 5.0]]]), # Wrong batch - quantile_levels + quantile_levels, ) def test_crps_quantile_length_mismatch_error(self): @@ -384,4 +375,4 @@ def test_crps_empty_array_error(self): quantile_levels = [0.1, 0.5, 0.9] with pytest.raises(ValueError, match="cannot be empty"): - crps_from_quantiles(y_true, quantile_preds, quantile_levels) \ No newline at end of file + crps_from_quantiles(y_true, quantile_preds, quantile_levels) diff --git a/tests/unit/test_eval_visualization.py b/tests/unit/test_eval_visualization.py index 4ab6374..5844207 100644 --- a/tests/unit/test_eval_visualization.py +++ b/tests/unit/test_eval_visualization.py @@ -16,7 +16,8 @@ def setup_matplotlib(self): """Ensure matplotlib is available for tests.""" try: import matplotlib - matplotlib.use('Agg') # Use non-interactive backend for testing + + matplotlib.use("Agg") # Use non-interactive backend for testing except ImportError: pytest.skip("matplotlib not available") @@ -70,7 +71,7 @@ def test_plot_forecast_multi_feature_same_plot(self): forecast, test_data, features_on_same_plot=True, - feature_names=["Feature A", "Feature B", "Feature C"] + feature_names=["Feature A", "Feature B", "Feature C"], ) assert fig is not None @@ -85,10 +86,7 @@ def test_plot_forecast_multi_feature_subplots(self): forecast = np.random.randn(24, 3) fig, axes = plot_forecast( - train_data, - forecast, - features_on_same_plot=False, - feature_names=["Temp", "Humidity", "Pressure"] + train_data, forecast, features_on_same_plot=False, feature_names=["Temp", "Humidity", "Pressure"] ) assert fig is not None @@ -129,11 +127,7 @@ def test_plot_forecast_default_feature_names(self): train_data = np.random.randn(100, 3) forecast = np.random.randn(24, 3) - fig, axes = plot_forecast( - train_data, - forecast, - features_on_same_plot=False - ) + fig, axes = plot_forecast(train_data, forecast, features_on_same_plot=False) # Should use default names: Feature 1, Feature 2, Feature 3 assert axes[0].get_title() == "Feature 1" @@ -147,11 +141,7 @@ def test_plot_forecast_single_feature_default_name(self): train_data = np.random.randn(100, 1) forecast = np.random.randn(24, 1) - fig, axes = plot_forecast( - train_data, - forecast, - features_on_same_plot=False - ) + fig, axes = plot_forecast(train_data, forecast, features_on_same_plot=False) # Should use 'Series' for single feature assert axes[0].get_title() == "Series" @@ -229,7 +219,7 @@ def test_plot_forecast_wrong_feature_names_length_error(self): plot_forecast( train_data, forecast, - feature_names=["A", "B"] # Only 2, but 3 features + feature_names=["A", "B"], # Only 2, but 3 features ) def test_plot_forecast_type_error_train(self): @@ -299,25 +289,27 @@ def test_plot_forecast_matplotlib_not_available_error(self, monkeypatch): import sys # Remove matplotlib from modules - matplotlib_modules = [key for key in sys.modules if key.startswith('matplotlib')] + matplotlib_modules = [key for key in sys.modules if key.startswith("matplotlib")] for mod in matplotlib_modules: monkeypatch.delitem(sys.modules, mod, raising=False) # Mock import to fail import builtins + original_import = builtins.__import__ def mock_import(name, *args, **kwargs): - if name.startswith('matplotlib'): + if name.startswith("matplotlib"): raise ImportError("No module named 'matplotlib'") return original_import(name, *args, **kwargs) - monkeypatch.setattr(builtins, '__import__', mock_import) + monkeypatch.setattr(builtins, "__import__", mock_import) # Force reload of visualization module import importlib import faim_sdk.eval + importlib.reload(faim_sdk.eval.visualization) from faim_sdk.eval.visualization import plot_forecast @@ -386,8 +378,8 @@ def test_plot_forecast_realistic_sdk_usage(self): train_data=train_batch[0], # (100, 1) forecast=forecast_batch[0], # (24, 1) test_data=test_batch[0], # (24, 1) - title="Sample 1 Forecast" + title="Sample 1 Forecast", ) assert fig is not None - assert ax.get_title() == "Sample 1 Forecast" \ No newline at end of file + assert ax.get_title() == "Sample 1 Forecast"