diff --git a/examples/tutorials/try_optuna.ipynb b/examples/tutorials/try_optuna.ipynb
new file mode 100644
index 000000000..ed1871ad7
--- /dev/null
+++ b/examples/tutorials/try_optuna.ipynb
@@ -0,0 +1,1199 @@
+{
+ "cells": [
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "c25b63fd",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# --- Setup: Logging and Display Configuration ---\n",
+ "# Configure logging to see training progress and plotly to render as PNG for VS Code compatibility\n",
+ "import logging\n",
+ "import pandas as pd\n",
+ "import plotly.io as pio\n",
+ "\n",
+ "pd.options.plotting.backend = \"plotly\"\n",
+ "pio.renderers.default = \"png\" # Use PNG for VS Code notebook compatibility\n",
+ "\n",
+ "logging.basicConfig(level=logging.INFO, format=\"[%(asctime)s][%(levelname)s] %(message)s\")\n",
+ "logger = logging.getLogger(__name__)\n",
+ "logging.getLogger(\"choreographer\").setLevel(logging.ERROR)\n",
+ "logging.getLogger(\"kaleido\").setLevel(logging.ERROR)\n",
+ "logging.getLogger(\"choreographer\").disabled = True\n",
+ "logging.getLogger(\"kaleido\").disabled = True"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "84299333",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Downloading load_measurements/mv_feeder/OS Gorredijk.parquet...\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "/Users/fleur.petit/projects/openstef/.venv/lib/python3.12/site-packages/huggingface_hub/utils/_validators.py:202: UserWarning:\n",
+ "\n",
+ "The `local_dir_use_symlinks` argument is deprecated and ignored in `hf_hub_download`. Downloading to a local directory does not use symlinks anymore.\n",
+ "\n",
+ "[2026-03-05 16:50:42,135][INFO] HTTP Request: HEAD https://huggingface.co/datasets/OpenSTEF/liander2024-energy-forecasting-benchmark/resolve/main/load_measurements/mv_feeder/OS%20Gorredijk.parquet \"HTTP/1.1 302 Found\"\n",
+ "Warning: You are sending unauthenticated requests to the HF Hub. Please set a HF_TOKEN to enable higher rate limits and faster downloads.\n",
+ "[2026-03-05 16:50:42,137][WARNING] Warning: You are sending unauthenticated requests to the HF Hub. Please set a HF_TOKEN to enable higher rate limits and faster downloads.\n",
+ "[2026-03-05 16:50:42,275][INFO] HTTP Request: HEAD https://huggingface.co/datasets/OpenSTEF/liander2024-energy-forecasting-benchmark/resolve/main/weather_forecasts_versioned/mv_feeder/OS%20Gorredijk.parquet \"HTTP/1.1 302 Found\"\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "✓ load_measurements/mv_feeder/OS Gorredijk.parquet downloaded\n",
+ "Downloading weather_forecasts_versioned/mv_feeder/OS Gorredijk.parquet...\n",
+ "✓ weather_forecasts_versioned/mv_feeder/OS Gorredijk.parquet downloaded\n",
+ "Downloading EPEX.parquet...\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "[2026-03-05 16:50:42,572][INFO] HTTP Request: HEAD https://huggingface.co/datasets/OpenSTEF/liander2024-energy-forecasting-benchmark/resolve/main/EPEX.parquet \"HTTP/1.1 302 Found\"\n",
+ "[2026-03-05 16:50:42,701][INFO] HTTP Request: HEAD https://huggingface.co/datasets/OpenSTEF/liander2024-energy-forecasting-benchmark/resolve/main/profiles.parquet \"HTTP/1.1 302 Found\"\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "✓ EPEX.parquet downloaded\n",
+ "Downloading profiles.parquet...\n",
+ "✓ profiles.parquet downloaded\n",
+ "\n",
+ "✅ All files downloaded successfully!\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Download dataset from HuggingFace Hub\n",
+ "# The dataset is stored as parquet files for efficient loading\n",
+ "from huggingface_hub import hf_hub_download # pyright: ignore[reportUnknownVariableType]\n",
+ "from openstef_core.base_model import Path\n",
+ "\n",
+ "repo_id = \"OpenSTEF/liander2024-energy-forecasting-benchmark\" # Public benchmark dataset\n",
+ "local_dir = Path(\"./liander_dataset\")\n",
+ "target = \"mv_feeder/OS Gorredijk\" # Specific installation to focus on\n",
+ "\n",
+ "# Download required files: load measurements, weather, prices, and profiles\n",
+ "files_to_download = [\n",
+ " f\"load_measurements/{target}.parquet\", # Energy consumption data\n",
+ " f\"weather_forecasts_versioned/{target}.parquet\", # Weather features\n",
+ " \"EPEX.parquet\", # Electricity prices (optional feature)\n",
+ " \"profiles.parquet\" # Standard load profiles (optional feature)\n",
+ "]\n",
+ "\n",
+ "for filename in files_to_download:\n",
+ " print(f\"Downloading {filename}...\")\n",
+ " hf_hub_download(repo_id=repo_id, filename=filename, repo_type=\"dataset\",\n",
+ " local_dir=local_dir, local_dir_use_symlinks=False) # pyright: ignore[reportCallIssue]\n",
+ " print(f\"✓ {filename} downloaded\")\n",
+ "\n",
+ "print(\"\\n✅ All files downloaded successfully!\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "524f65a1",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "[2026-03-05 16:50:45,304][WARNING] Parquet file does not contain 'sample_interval' attribute. Using default value of 15 minutes.\n",
+ "[2026-03-05 16:50:45,336][WARNING] Parquet file does not contain 'sample_interval' attribute. Using default value of 15 minutes.\n",
+ "[2026-03-05 16:50:45,365][WARNING] Parquet file does not contain 'sample_interval' attribute. Using default value of 15 minutes.\n",
+ "[2026-03-05 16:50:45,378][WARNING] Parquet file does not contain 'sample_interval' attribute. Using default value of 15 minutes.\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Dataset shape: (35136, 28)\n",
+ "Date range: 2024-01-01 00:00:00+00:00 to 2024-12-31 23:45:00+00:00\n"
+ ]
+ },
+ {
+ "data": {
+ "application/vnd.microsoft.datawrangler.viewer.v0+json": {
+ "columns": [
+ {
+ "name": "timestamp",
+ "rawType": "datetime64[ns, UTC]",
+ "type": "unknown"
+ },
+ {
+ "name": "load",
+ "rawType": "float64",
+ "type": "float"
+ },
+ {
+ "name": "temperature_2m",
+ "rawType": "float32",
+ "type": "float"
+ },
+ {
+ "name": "relative_humidity_2m",
+ "rawType": "float32",
+ "type": "float"
+ },
+ {
+ "name": "surface_pressure",
+ "rawType": "float32",
+ "type": "float"
+ },
+ {
+ "name": "cloud_cover",
+ "rawType": "float32",
+ "type": "float"
+ },
+ {
+ "name": "wind_speed_10m",
+ "rawType": "float32",
+ "type": "float"
+ },
+ {
+ "name": "wind_speed_80m",
+ "rawType": "float32",
+ "type": "float"
+ },
+ {
+ "name": "wind_direction_10m",
+ "rawType": "float32",
+ "type": "float"
+ },
+ {
+ "name": "shortwave_radiation",
+ "rawType": "float32",
+ "type": "float"
+ },
+ {
+ "name": "direct_radiation",
+ "rawType": "float32",
+ "type": "float"
+ },
+ {
+ "name": "diffuse_radiation",
+ "rawType": "float32",
+ "type": "float"
+ },
+ {
+ "name": "direct_normal_irradiance",
+ "rawType": "float32",
+ "type": "float"
+ },
+ {
+ "name": "EPEX_NL",
+ "rawType": "float64",
+ "type": "float"
+ },
+ {
+ "name": "E1A_AZI_A",
+ "rawType": "float64",
+ "type": "float"
+ },
+ {
+ "name": "E1A_AMI_A",
+ "rawType": "float64",
+ "type": "float"
+ },
+ {
+ "name": "E1B_AZI_A",
+ "rawType": "float64",
+ "type": "float"
+ },
+ {
+ "name": "E1B_AMI_A",
+ "rawType": "float64",
+ "type": "float"
+ },
+ {
+ "name": "E1C_AZI_A",
+ "rawType": "float64",
+ "type": "float"
+ },
+ {
+ "name": "E1C_AMI_A",
+ "rawType": "float64",
+ "type": "float"
+ },
+ {
+ "name": "E2A_AZI_A",
+ "rawType": "float64",
+ "type": "float"
+ },
+ {
+ "name": "E2A_AMI_A",
+ "rawType": "float64",
+ "type": "float"
+ },
+ {
+ "name": "E2B_AZI_A",
+ "rawType": "float64",
+ "type": "float"
+ },
+ {
+ "name": "E2B_AMI_A",
+ "rawType": "float64",
+ "type": "float"
+ },
+ {
+ "name": "E3A_A",
+ "rawType": "float64",
+ "type": "float"
+ },
+ {
+ "name": "E3B_A",
+ "rawType": "float64",
+ "type": "float"
+ },
+ {
+ "name": "E3C_A",
+ "rawType": "float64",
+ "type": "float"
+ },
+ {
+ "name": "E3D_A",
+ "rawType": "float64",
+ "type": "float"
+ },
+ {
+ "name": "E4A_A",
+ "rawType": "float64",
+ "type": "float"
+ }
+ ],
+ "ref": "aa9bfad1-6c3e-4ed7-8923-65e22d67bcbf",
+ "rows": [
+ [
+ "2024-01-01 00:00:00+00:00",
+ "423333.3333333333",
+ "7.2435",
+ "85.02532",
+ "994.23645",
+ "100.0",
+ "28.185953",
+ "43.832863",
+ "204.92845",
+ "0.0",
+ "0.0",
+ "0.0",
+ "0.0",
+ "0.01",
+ "2.97e-05",
+ "4.031e-05",
+ "6.206e-05",
+ "7.815e-05",
+ "5.683e-05",
+ "6.431e-05",
+ "2.42e-05",
+ "3.404e-05",
+ "5.292e-05",
+ "6.425e-05",
+ "5.839e-05",
+ "5.839e-05",
+ "5.839e-05",
+ "5.839e-05",
+ "7.931e-05"
+ ],
+ [
+ "2024-01-01 00:15:00+00:00",
+ "436666.6666666666",
+ "7.281",
+ "84.80853",
+ "994.1865",
+ "100.0",
+ "28.75338",
+ "44.97622",
+ "206.93102",
+ "0.0",
+ "0.0",
+ "0.0",
+ "0.0",
+ "0.01",
+ "2.91e-05",
+ "3.866e-05",
+ "6.079e-05",
+ "7.537e-05",
+ "5.572e-05",
+ "6.058e-05",
+ "2.395e-05",
+ "3.352e-05",
+ "5.236e-05",
+ "6.326e-05",
+ "5.826e-05",
+ "5.826e-05",
+ "5.826e-05",
+ "5.826e-05",
+ "7.931e-05"
+ ],
+ [
+ "2024-01-01 00:30:00+00:00",
+ "410000.0",
+ "7.3185005",
+ "84.59174",
+ "994.1366",
+ "100.0",
+ "29.320807",
+ "46.11957",
+ "208.93356",
+ "0.0",
+ "0.0",
+ "0.0",
+ "0.0",
+ "0.01",
+ "2.794e-05",
+ "3.771e-05",
+ "5.799e-05",
+ "7.33e-05",
+ "5.451e-05",
+ "5.967e-05",
+ "2.338e-05",
+ "3.312e-05",
+ "5.113e-05",
+ "6.252e-05",
+ "5.782e-05",
+ "5.782e-05",
+ "5.782e-05",
+ "5.782e-05",
+ "7.931e-05"
+ ],
+ [
+ "2024-01-01 00:45:00+00:00",
+ "403333.3333333333",
+ "7.3560004",
+ "84.374954",
+ "994.08673",
+ "100.0",
+ "29.888233",
+ "47.262924",
+ "210.93613",
+ "0.0",
+ "0.0",
+ "0.0",
+ "0.0",
+ "0.01",
+ "2.712e-05",
+ "3.649e-05",
+ "5.659e-05",
+ "7.12e-05",
+ "5.211e-05",
+ "5.708e-05",
+ "2.325e-05",
+ "3.219e-05",
+ "5.083e-05",
+ "6.076e-05",
+ "5.89e-05",
+ "5.89e-05",
+ "5.89e-05",
+ "5.89e-05",
+ "7.931e-05"
+ ],
+ [
+ "2024-01-01 01:00:00+00:00",
+ "420000.0",
+ "7.3935003",
+ "84.158165",
+ "994.0368",
+ "100.0",
+ "30.45566",
+ "48.40628",
+ "212.93869",
+ "0.0",
+ "0.0",
+ "0.0",
+ "0.0",
+ "0.0",
+ "2.714e-05",
+ "3.44e-05",
+ "5.728e-05",
+ "6.668e-05",
+ "5.045e-05",
+ "5.493e-05",
+ "2.359e-05",
+ "3.198e-05",
+ "5.158e-05",
+ "6.036e-05",
+ "5.726e-05",
+ "5.726e-05",
+ "5.726e-05",
+ "5.726e-05",
+ "7.931e-05"
+ ]
+ ],
+ "shape": {
+ "columns": 28,
+ "rows": 5
+ }
+ },
+ "text/html": [
+ "
\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " | \n",
+ " load | \n",
+ " temperature_2m | \n",
+ " relative_humidity_2m | \n",
+ " surface_pressure | \n",
+ " cloud_cover | \n",
+ " wind_speed_10m | \n",
+ " wind_speed_80m | \n",
+ " wind_direction_10m | \n",
+ " shortwave_radiation | \n",
+ " direct_radiation | \n",
+ " ... | \n",
+ " E1C_AMI_A | \n",
+ " E2A_AZI_A | \n",
+ " E2A_AMI_A | \n",
+ " E2B_AZI_A | \n",
+ " E2B_AMI_A | \n",
+ " E3A_A | \n",
+ " E3B_A | \n",
+ " E3C_A | \n",
+ " E3D_A | \n",
+ " E4A_A | \n",
+ "
\n",
+ " \n",
+ " | timestamp | \n",
+ " | \n",
+ " | \n",
+ " | \n",
+ " | \n",
+ " | \n",
+ " | \n",
+ " | \n",
+ " | \n",
+ " | \n",
+ " | \n",
+ " | \n",
+ " | \n",
+ " | \n",
+ " | \n",
+ " | \n",
+ " | \n",
+ " | \n",
+ " | \n",
+ " | \n",
+ " | \n",
+ " | \n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " | 2024-01-01 00:00:00+00:00 | \n",
+ " 423333.333333 | \n",
+ " 7.243500 | \n",
+ " 85.025322 | \n",
+ " 994.236450 | \n",
+ " 100.0 | \n",
+ " 28.185953 | \n",
+ " 43.832863 | \n",
+ " 204.928452 | \n",
+ " 0.0 | \n",
+ " 0.0 | \n",
+ " ... | \n",
+ " 0.000064 | \n",
+ " 0.000024 | \n",
+ " 0.000034 | \n",
+ " 0.000053 | \n",
+ " 0.000064 | \n",
+ " 0.000058 | \n",
+ " 0.000058 | \n",
+ " 0.000058 | \n",
+ " 0.000058 | \n",
+ " 0.000079 | \n",
+ "
\n",
+ " \n",
+ " | 2024-01-01 00:15:00+00:00 | \n",
+ " 436666.666667 | \n",
+ " 7.281000 | \n",
+ " 84.808533 | \n",
+ " 994.186523 | \n",
+ " 100.0 | \n",
+ " 28.753380 | \n",
+ " 44.976219 | \n",
+ " 206.931015 | \n",
+ " 0.0 | \n",
+ " 0.0 | \n",
+ " ... | \n",
+ " 0.000061 | \n",
+ " 0.000024 | \n",
+ " 0.000034 | \n",
+ " 0.000052 | \n",
+ " 0.000063 | \n",
+ " 0.000058 | \n",
+ " 0.000058 | \n",
+ " 0.000058 | \n",
+ " 0.000058 | \n",
+ " 0.000079 | \n",
+ "
\n",
+ " \n",
+ " | 2024-01-01 00:30:00+00:00 | \n",
+ " 410000.000000 | \n",
+ " 7.318501 | \n",
+ " 84.591743 | \n",
+ " 994.136597 | \n",
+ " 100.0 | \n",
+ " 29.320807 | \n",
+ " 46.119572 | \n",
+ " 208.933563 | \n",
+ " 0.0 | \n",
+ " 0.0 | \n",
+ " ... | \n",
+ " 0.000060 | \n",
+ " 0.000023 | \n",
+ " 0.000033 | \n",
+ " 0.000051 | \n",
+ " 0.000063 | \n",
+ " 0.000058 | \n",
+ " 0.000058 | \n",
+ " 0.000058 | \n",
+ " 0.000058 | \n",
+ " 0.000079 | \n",
+ "
\n",
+ " \n",
+ " | 2024-01-01 00:45:00+00:00 | \n",
+ " 403333.333333 | \n",
+ " 7.356000 | \n",
+ " 84.374954 | \n",
+ " 994.086731 | \n",
+ " 100.0 | \n",
+ " 29.888233 | \n",
+ " 47.262924 | \n",
+ " 210.936127 | \n",
+ " 0.0 | \n",
+ " 0.0 | \n",
+ " ... | \n",
+ " 0.000057 | \n",
+ " 0.000023 | \n",
+ " 0.000032 | \n",
+ " 0.000051 | \n",
+ " 0.000061 | \n",
+ " 0.000059 | \n",
+ " 0.000059 | \n",
+ " 0.000059 | \n",
+ " 0.000059 | \n",
+ " 0.000079 | \n",
+ "
\n",
+ " \n",
+ " | 2024-01-01 01:00:00+00:00 | \n",
+ " 420000.000000 | \n",
+ " 7.393500 | \n",
+ " 84.158165 | \n",
+ " 994.036804 | \n",
+ " 100.0 | \n",
+ " 30.455660 | \n",
+ " 48.406281 | \n",
+ " 212.938690 | \n",
+ " 0.0 | \n",
+ " 0.0 | \n",
+ " ... | \n",
+ " 0.000055 | \n",
+ " 0.000024 | \n",
+ " 0.000032 | \n",
+ " 0.000052 | \n",
+ " 0.000060 | \n",
+ " 0.000057 | \n",
+ " 0.000057 | \n",
+ " 0.000057 | \n",
+ " 0.000057 | \n",
+ " 0.000079 | \n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
5 rows × 28 columns
\n",
+ "
"
+ ],
+ "text/plain": [
+ " load temperature_2m \\\n",
+ "timestamp \n",
+ "2024-01-01 00:00:00+00:00 423333.333333 7.243500 \n",
+ "2024-01-01 00:15:00+00:00 436666.666667 7.281000 \n",
+ "2024-01-01 00:30:00+00:00 410000.000000 7.318501 \n",
+ "2024-01-01 00:45:00+00:00 403333.333333 7.356000 \n",
+ "2024-01-01 01:00:00+00:00 420000.000000 7.393500 \n",
+ "\n",
+ " relative_humidity_2m surface_pressure \\\n",
+ "timestamp \n",
+ "2024-01-01 00:00:00+00:00 85.025322 994.236450 \n",
+ "2024-01-01 00:15:00+00:00 84.808533 994.186523 \n",
+ "2024-01-01 00:30:00+00:00 84.591743 994.136597 \n",
+ "2024-01-01 00:45:00+00:00 84.374954 994.086731 \n",
+ "2024-01-01 01:00:00+00:00 84.158165 994.036804 \n",
+ "\n",
+ " cloud_cover wind_speed_10m wind_speed_80m \\\n",
+ "timestamp \n",
+ "2024-01-01 00:00:00+00:00 100.0 28.185953 43.832863 \n",
+ "2024-01-01 00:15:00+00:00 100.0 28.753380 44.976219 \n",
+ "2024-01-01 00:30:00+00:00 100.0 29.320807 46.119572 \n",
+ "2024-01-01 00:45:00+00:00 100.0 29.888233 47.262924 \n",
+ "2024-01-01 01:00:00+00:00 100.0 30.455660 48.406281 \n",
+ "\n",
+ " wind_direction_10m shortwave_radiation \\\n",
+ "timestamp \n",
+ "2024-01-01 00:00:00+00:00 204.928452 0.0 \n",
+ "2024-01-01 00:15:00+00:00 206.931015 0.0 \n",
+ "2024-01-01 00:30:00+00:00 208.933563 0.0 \n",
+ "2024-01-01 00:45:00+00:00 210.936127 0.0 \n",
+ "2024-01-01 01:00:00+00:00 212.938690 0.0 \n",
+ "\n",
+ " direct_radiation ... E1C_AMI_A E2A_AZI_A \\\n",
+ "timestamp ... \n",
+ "2024-01-01 00:00:00+00:00 0.0 ... 0.000064 0.000024 \n",
+ "2024-01-01 00:15:00+00:00 0.0 ... 0.000061 0.000024 \n",
+ "2024-01-01 00:30:00+00:00 0.0 ... 0.000060 0.000023 \n",
+ "2024-01-01 00:45:00+00:00 0.0 ... 0.000057 0.000023 \n",
+ "2024-01-01 01:00:00+00:00 0.0 ... 0.000055 0.000024 \n",
+ "\n",
+ " E2A_AMI_A E2B_AZI_A E2B_AMI_A E3A_A \\\n",
+ "timestamp \n",
+ "2024-01-01 00:00:00+00:00 0.000034 0.000053 0.000064 0.000058 \n",
+ "2024-01-01 00:15:00+00:00 0.000034 0.000052 0.000063 0.000058 \n",
+ "2024-01-01 00:30:00+00:00 0.000033 0.000051 0.000063 0.000058 \n",
+ "2024-01-01 00:45:00+00:00 0.000032 0.000051 0.000061 0.000059 \n",
+ "2024-01-01 01:00:00+00:00 0.000032 0.000052 0.000060 0.000057 \n",
+ "\n",
+ " E3B_A E3C_A E3D_A E4A_A \n",
+ "timestamp \n",
+ "2024-01-01 00:00:00+00:00 0.000058 0.000058 0.000058 0.000079 \n",
+ "2024-01-01 00:15:00+00:00 0.000058 0.000058 0.000058 0.000079 \n",
+ "2024-01-01 00:30:00+00:00 0.000058 0.000058 0.000058 0.000079 \n",
+ "2024-01-01 00:45:00+00:00 0.000059 0.000059 0.000059 0.000079 \n",
+ "2024-01-01 01:00:00+00:00 0.000057 0.000057 0.000057 0.000079 \n",
+ "\n",
+ "[5 rows x 28 columns]"
+ ]
+ },
+ "execution_count": 4,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "# Load datasets using OpenSTEF's VersionedTimeSeriesDataset\n",
+ "# This class handles versioned data where each value has an \"available_at\" timestamp\n",
+ "from openstef_core.datasets import VersionedTimeSeriesDataset\n",
+ "\n",
+ "# Load each data source from parquet files\n",
+ "load_dataset = VersionedTimeSeriesDataset.read_parquet(\n",
+ " local_dir / f\"load_measurements/{target}.parquet\"\n",
+ ")\n",
+ "weather_dataset = VersionedTimeSeriesDataset.read_parquet(\n",
+ " local_dir / f\"weather_forecasts_versioned/{target}.parquet\"\n",
+ ")\n",
+ "epex_dataset = VersionedTimeSeriesDataset.read_parquet(local_dir / \"EPEX.parquet\")\n",
+ "profiles_dataset = VersionedTimeSeriesDataset.read_parquet(local_dir / \"profiles.parquet\")\n",
+ "\n",
+ "# Combine all datasets using left join (keep all load timestamps, match features where available)\n",
+ "# select_version() materializes the lazy dataset into a concrete TimeSeriesDataset\n",
+ "dataset = VersionedTimeSeriesDataset.concat(\n",
+ " [load_dataset, weather_dataset, epex_dataset, profiles_dataset], \n",
+ " mode=\"left\" # Left join keeps all timestamps from the first dataset\n",
+ ").select_version()\n",
+ "\n",
+ "# Preview the combined dataset\n",
+ "print(f\"Dataset shape: {dataset.data.shape}\")\n",
+ "print(f\"Date range: {dataset.data.index.min()} to {dataset.data.index.max()}\")\n",
+ "dataset.data.head()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "2a64bbb5",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "📈 Training period: 2024-03-01 to 2024-05-30 (8640 samples)\n",
+ "🔮 Forecast period: 2024-05-30 to 2024-06-13 (1344 samples)\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Define training and forecast time periods\n",
+ "from datetime import datetime, timedelta\n",
+ "\n",
+ "# Training period: 90 days of historical data\n",
+ "train_start = datetime.fromisoformat(\"2024-03-01T00:00:00Z\")\n",
+ "train_end = train_start + timedelta(days=90)\n",
+ "\n",
+ "# Forecast period: 14 days after training (this is where we'll predict)\n",
+ "forecast_start = train_end\n",
+ "forecast_end = forecast_start + timedelta(days=14)\n",
+ "\n",
+ "# Split the dataset using time-based filtering\n",
+ "train_dataset = dataset.filter_by_range(start=train_start, end=train_end)\n",
+ "forecast_dataset = dataset.filter_by_range(start=forecast_start, end=forecast_end)\n",
+ "\n",
+ "print(f\"📈 Training period: {train_start.date()} to {train_end.date()} ({len(train_dataset.data)} samples)\")\n",
+ "print(f\"🔮 Forecast period: {forecast_start.date()} to {forecast_end.date()} ({len(forecast_dataset.data)} samples)\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "bfe2a41f",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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"
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# Visualize the training data\n",
+ "# The plot shows the 'load' column (energy consumption in MW) over time\n",
+ "fig = train_dataset.data[[\"load\"]].plot(title=\"Training Data: Energy Load over Time\")\n",
+ "fig.update_layout(yaxis_title=\"Load (MW)\", xaxis_title=\"Time\")\n",
+ "fig.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "12d8302c",
+ "metadata": {},
+ "source": [
+ "## Define a base config with inline search space\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "id": "a001a0f0",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from openstef_core.types import LeadTime, Q\n",
+ "from openstef_models.models.forecasting.xgboost_forecaster import XGBoostHyperParams\n",
+ "from openstef_models.presets import ForecastingWorkflowConfig, TuningResult, fit_with_tuning\n",
+ "from openstef_models.utils.tuning import CategoricalRange, FloatRange, IntRange\n",
+ "\n",
+ "config = ForecastingWorkflowConfig(\n",
+ " model_id=\"xgboost_optuna_demo\",\n",
+ " model=\"xgboost\",\n",
+ "\n",
+ " horizons=[LeadTime.from_string(\"PT36H\")],\n",
+ " quantiles=[Q(0.5), Q(0.1), Q(0.9)],\n",
+ "\n",
+ " target_column=\"load\",\n",
+ " temperature_column=\"temperature_2m\",\n",
+ " relative_humidity_column=\"relative_humidity_2m\",\n",
+ " wind_speed_column=\"wind_speed_10m\",\n",
+ " radiation_column=\"shortwave_radiation\",\n",
+ " pressure_column=\"surface_pressure\",\n",
+ "\n",
+ " # Pass TuningRange objects directly as field values — tune=True marks them for Optuna.\n",
+ " # None values for low/high fall back to the class-level defaults in XGBoostHyperParams.\n",
+ " xgboost_hyperparams=XGBoostHyperParams(\n",
+ " n_estimators=200,\n",
+ " learning_rate=FloatRange(None, None, log=True, tune=True), # class default: [0.01, 0.5]\n",
+ " max_depth=IntRange(5, 15, tune=True), \n",
+ " min_child_weight=FloatRange(None, None, tune=True), # class default: [1.0, 10.0]\n",
+ " reg_alpha=FloatRange(None, None, log=True, tune=True), # class default: [1e-8, 10.0]\n",
+ " reg_lambda=FloatRange(None, None, log=True, tune=True), # class default: [1e-8, 10.0]\n",
+ " ),\n",
+ " optuna_n_trials=20,\n",
+ " optuna_seed=42,\n",
+ "\n",
+ " mlflow_storage=None, # Disable MLflow during tuning\n",
+ " verbosity=0,\n",
+ ")\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9b47824a",
+ "metadata": {},
+ "source": [
+ "## Inspect the resolved search space\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "id": "65a76a06",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Resolved search space:\n",
+ " learning_rate : FloatRange [0.01 — 0.5] [log]\n",
+ " max_depth : IntRange [5 — 15]\n",
+ " min_child_weight : FloatRange [1.0 — 10.0]\n",
+ " reg_alpha : FloatRange [1e-08 — 10.0] [log]\n",
+ " reg_lambda : FloatRange [1e-08 — 10.0] [log]\n"
+ ]
+ }
+ ],
+ "source": [
+ "from openstef_models.utils.tuning import FloatRange, IntRange, CategoricalRange, get_search_space\n",
+ "\n",
+ "# Merge custom annotated hyperparams with class-level annotated defaults (filling in any None bounds).\n",
+ "resolved_space = get_search_space(config.xgboost_hyperparams)\n",
+ "\n",
+ "print(\"Resolved search space:\")\n",
+ "for name, param in resolved_space.items():\n",
+ " if isinstance(param, (FloatRange, IntRange)):\n",
+ " scale = \" [log]\" if param.log else \"\"\n",
+ " print(f\" {name:25s}: {type(param).__name__} [{param.low} — {param.high}]{scale}\")\n",
+ " elif isinstance(param, CategoricalRange):\n",
+ " print(f\" {name:25s}: CategoricalRange {param.choices}\")\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "08768e60",
+ "metadata": {},
+ "source": [
+ "## Run the Optuna study with `fit_with_tuning`"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "id": "8601c179",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ " 0%| | 0/20 [00:00, ?it/s][2026-03-05 17:18:48,242][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "[2026-03-05 17:18:48,326][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "[2026-03-05 17:18:58,082][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "Best trial: 0. Best value: 0.834273: 5%|▌ | 1/20 [00:10<03:13, 10.18s/it][2026-03-05 17:18:58,408][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "[2026-03-05 17:18:58,489][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "[2026-03-05 17:19:00,823][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "Best trial: 0. Best value: 0.834273: 10%|█ | 2/20 [00:12<01:43, 5.75s/it][2026-03-05 17:19:01,040][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "[2026-03-05 17:19:01,120][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "[2026-03-05 17:19:11,227][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "Best trial: 0. Best value: 0.834273: 15%|█▌ | 3/20 [00:23<02:14, 7.91s/it][2026-03-05 17:19:11,538][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "[2026-03-05 17:19:11,618][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "[2026-03-05 17:19:17,781][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "Best trial: 0. Best value: 0.834273: 20%|██ | 4/20 [00:29<01:57, 7.36s/it][2026-03-05 17:19:18,034][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "[2026-03-05 17:19:18,110][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "[2026-03-05 17:19:21,033][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "Best trial: 0. Best value: 0.834273: 25%|██▌ | 5/20 [00:33<01:28, 5.87s/it][2026-03-05 17:19:21,265][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "[2026-03-05 17:19:21,341][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "[2026-03-05 17:19:24,615][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "Best trial: 0. Best value: 0.834273: 30%|███ | 6/20 [00:36<01:11, 5.10s/it][2026-03-05 17:19:24,863][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "[2026-03-05 17:19:24,940][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "[2026-03-05 17:19:27,417][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "Best trial: 0. Best value: 0.834273: 35%|███▌ | 7/20 [00:39<00:56, 4.34s/it][2026-03-05 17:19:27,646][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "[2026-03-05 17:19:27,724][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "[2026-03-05 17:19:33,258][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "Best trial: 7. Best value: 0.834977: 40%|████ | 8/20 [00:45<00:57, 4.82s/it][2026-03-05 17:19:33,508][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "[2026-03-05 17:19:33,589][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "[2026-03-05 17:19:39,722][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "Best trial: 7. Best value: 0.834977: 45%|████▌ | 9/20 [00:51<00:58, 5.34s/it][2026-03-05 17:19:39,981][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "[2026-03-05 17:19:40,062][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "[2026-03-05 17:19:44,383][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "Best trial: 9. Best value: 0.83642: 50%|█████ | 10/20 [00:56<00:51, 5.13s/it][2026-03-05 17:19:44,635][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "[2026-03-05 17:19:44,711][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "[2026-03-05 17:19:51,643][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "Best trial: 9. Best value: 0.83642: 55%|█████▌ | 11/20 [01:03<00:52, 5.79s/it][2026-03-05 17:19:51,934][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "[2026-03-05 17:19:52,009][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "[2026-03-05 17:19:58,197][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "Best trial: 9. Best value: 0.83642: 60%|██████ | 12/20 [01:10<00:48, 6.01s/it][2026-03-05 17:19:58,458][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "[2026-03-05 17:19:58,534][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "[2026-03-05 17:20:05,573][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "Best trial: 12. Best value: 0.8388: 65%|██████▌ | 13/20 [01:17<00:45, 6.44s/it][2026-03-05 17:20:05,863][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "[2026-03-05 17:20:05,942][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "[2026-03-05 17:20:13,247][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "Best trial: 12. Best value: 0.8388: 70%|███████ | 14/20 [01:25<00:40, 6.81s/it][2026-03-05 17:20:13,528][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "[2026-03-05 17:20:13,604][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "[2026-03-05 17:20:20,880][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "Best trial: 12. Best value: 0.8388: 75%|███████▌ | 15/20 [01:32<00:35, 7.06s/it][2026-03-05 17:20:21,169][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "[2026-03-05 17:20:21,249][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "[2026-03-05 17:20:26,635][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "Best trial: 12. Best value: 0.8388: 80%|████████ | 16/20 [01:38<00:26, 6.66s/it][2026-03-05 17:20:26,912][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "[2026-03-05 17:20:26,997][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "[2026-03-05 17:20:29,978][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "Best trial: 12. Best value: 0.8388: 85%|████████▌ | 17/20 [01:42<00:16, 5.66s/it][2026-03-05 17:20:30,236][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "[2026-03-05 17:20:30,314][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "[2026-03-05 17:20:39,876][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "Best trial: 12. Best value: 0.8388: 90%|█████████ | 18/20 [01:51<00:13, 6.95s/it][2026-03-05 17:20:40,189][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "[2026-03-05 17:20:40,266][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "[2026-03-05 17:20:50,473][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "Best trial: 12. Best value: 0.8388: 95%|█████████▌| 19/20 [02:02<00:08, 8.05s/it][2026-03-05 17:20:50,796][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "[2026-03-05 17:20:50,872][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "[2026-03-05 17:21:01,721][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "Best trial: 12. Best value: 0.8388: 100%|██████████| 20/20 [02:13<00:00, 6.69s/it]\n",
+ "[2026-03-05 17:21:02,060][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "[2026-03-05 17:21:02,141][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n",
+ "[2026-03-05 17:21:09,344][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Study complete: 20 trials\n",
+ "Best R²: 0.8388\n",
+ "Best hyperparameters:\n",
+ " learning_rate : 0.1661524390633895\n",
+ " max_depth : 12\n",
+ " min_child_weight : 6.81957188819057\n",
+ " reg_alpha : 0.04112476622444426\n",
+ " reg_lambda : 0.0022086692193693247\n"
+ ]
+ }
+ ],
+ "source": [
+ "import optuna\n",
+ "optuna.logging.set_verbosity(optuna.logging.WARNING) # Suppress per-trial logs\n",
+ "\n",
+ "tuning_result = fit_with_tuning(config, train_dataset)\n",
+ "\n",
+ "print(f\"Study complete: {len(tuning_result.study.trials)} trials\")\n",
+ "print(f\"Best R²: {tuning_result.study.best_value:.4f}\")\n",
+ "print(f\"Best hyperparameters:\")\n",
+ "for k, v in tuning_result.best_params.items():\n",
+ " print(f\" {k:25s}: {v}\")\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "id": "096af1c0",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Final XGBoost hyperparameters (tuned values marked):\n",
+ " n_estimators : 200\n",
+ " learning_rate : 0.1661524390633895 <- tuned\n",
+ " max_depth : 12 <- tuned\n",
+ " min_child_weight : 6.81957188819057 <- tuned\n",
+ " gamma : 0\n",
+ " objective : pinball_loss\n",
+ " evaluation_metric : mean_pinball_loss\n",
+ " reg_alpha : 0.04112476622444426 <- tuned\n",
+ " reg_lambda : 0.0022086692193693247 <- tuned\n",
+ " max_delta_step : 0\n",
+ " max_leaves : 0\n",
+ " grow_policy : depthwise\n",
+ " max_bin : 256\n",
+ " num_parallel_trees : 1\n",
+ " subsample : 1.0\n",
+ " colsample_bytree : 1.0\n",
+ " colsample_bylevel : 1.0\n",
+ " colsample_bynode : 1.0\n",
+ " tree_method : auto\n",
+ " random_state : 42\n",
+ " early_stopping_rounds : None\n",
+ " use_target_scaling : True\n"
+ ]
+ }
+ ],
+ "source": [
+ "# The best config is already applied inside fit_with_tuning.\n",
+ "# Here we inspect which hyperparameters were tuned vs kept at their default.\n",
+ "print(\"Final XGBoost hyperparameters (tuned values marked):\")\n",
+ "final_hp = tuning_result.workflow.model.forecaster._config.hyperparams\n",
+ "baseline_hp = config.xgboost_hyperparams\n",
+ "\n",
+ "for field in type(final_hp).model_fields:\n",
+ " value = getattr(final_hp, field)\n",
+ " baseline = getattr(baseline_hp, field)\n",
+ " marker = \" <- tuned\" if field in tuning_result.best_params else \"\"\n",
+ " print(f\" {field:25s}: {value}{marker}\")\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d86e3cbc",
+ "metadata": {},
+ "source": [
+ "## Full-set training metrics\n",
+ "\n",
+ "`fit_with_tuning` trains the final model on the full training set with the best\n",
+ "hyperparameters. The fit result is available as `tuning_result.fit_result`.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "id": "5be7e4a8",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Final model already trained by fit_with_tuning!\n",
+ "Full-set metrics (tuned model):\n",
+ " quantile R2 observed_probability\n",
+ "0 0.5 0.978403 0.503819\n",
+ "1 0.1 0.968634 0.263426\n",
+ "2 0.9 0.955630 0.743750\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(\"Final model already trained by fit_with_tuning!\")\n",
+ "print(\"Full-set metrics (tuned model):\")\n",
+ "print(tuning_result.fit_result.metrics_full.to_dataframe())\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3fc5f542",
+ "metadata": {},
+ "source": [
+ "## Inspect the study and forecast\n",
+ "\n",
+ "1. How did $R^2$ improved over trials?\n",
+ "2. Which parameters had the most impact?\n",
+ "3. Final tuned model predictions on the held-out forecast window.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c29a1423",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAArwAAAH0CAYAAADfWf7fAAAQAElEQVR4AezdB5wTRRsG8CfJVXrvVaqCCggqKB1EEKSK8CmKoCi9CIIUAREU6b2KKCBVAUF6FQEpShcREUF6r9eT+/adI8fdJXfk7rK5lIcf22ZnZ2f+k1zebCYbYzT/UYACFKAABShAAQpQwIsFjOA/ClCAAhQAQAQKUIACFPBWAQa83tqzbBcFKEABClCAAhRIiYAXHsOA1ws7lU2iAAUoQAEKUIACFHgowID3oQXXKEABxwWYkwIUoAAFKOAxAgx4PaarWFEKUIACFKAABdxPgDXyBAEGvJ7QS6wjBShAAQpQgAIUoECKBRjwppiOB1LAcQHmpAAFKEABClAg7QQY8KadPc9MAQpQgAIU8DUBtpcCaSLAgDdN2HlSClCAAhSgAAUoQAFXCTDgdZU0z+O4AHNSgAIUoAAFKEABJwow4HUiJouiAAUoQAEKOFOAZVGAAs4RYMDrHEeWQgEKUIACFKAABSjgpgIMeN20YxyvFnNSgAIUoAAFKEABCiQlwIA3KR3uowAFKEABzxFgTSlAAQokIsCANxEYJlOAAhSgAAUoQAEKeIeArwW83tFrbAUFKEABClCAAhSggMMCDHgdpmJGClCAAt4kwLZQgAIU8B0BBry+09dsKQUoQAEKUIACFPBJgSQDXp8UYaMpQAEKUIACFKAABbxKgAGvV3UnG0MBCugkwGIpQAEKUMCDBRjwenDnseoUoAAFKEABClDAtQKeeTYGvJ7Zb6w1BShAAQpQgAIUoICDAgx4HYRiNgpQwHEB5qQABShAAQq4kwADXnfqDdaFAhSgAAUoQAFvEmBb3ESAAa+bdASrQQEKUIACFKAABSigjwADXn1cWSoFHBdgTgpQgAIUoAAFdBVgwKsrLwunAAUoQAEKUMBRAeajgF4CDHj1kmW5FKAABShAAQpQgAJuIcCA1y26gZVwXIA5KUABClCAAhSgQPIEGPAmz4u5KUABClCAAu4hwFpQgAIOCzDgdZiKGSlAAQpQgAIUoAAFPFGAAa8n9prjdWZOClCAAhSgAAUo4PMCDHh9/iFAAApQgAK+IMA2UoACvizAgNeXe59tpwAFKEABClCAAj4gwIA3TidzlQIUoAAFKEABClDA+wTcPuANDYvA36fP49qN27rrh4SG4d79UKeeR48yHalgdHS0aov4OZLfHfKklZU7tN2VdbhzLwT/nL2Is+evuPK0HnWuKLNZPX8iIiKTXe/fDv+FOYvW4PrNO8k+1o0OYFUoQAEKeJWA2wa823cfQoM3+6Liyx3Q+J0BqN6sOyrV/wBfTlmI1ARxO/cdxZjpS3Dp6g2bjmz41sd47pWOuB8SZrMvpQl6lBm3LotXbsH4WcviJqn185euqba07f652nb1bOnqbShToy1Wbdhl99TDxn2r9v/599nY/SmxMpstqj+Xr90RW44vrXw0bLpyFGvrVOu1nvhi8ne4fPWmDUXn/uNRuWEnNNIe6/Xf+Aj1WvfB1l0HbPJ5ckLTdgNtTKw2cZevvz800Wau3bxHPX+mfrMy0TyJ7di9/5h6TF65Zuuf2DFMpwAFKEABfQVSHvDqWK/Jc5aj08fjcObcZbR8tSY+6fkWOr7VGDmzZ8Y3S9ej+buDIFepUlKFQ3+cUldf7F0xrvxMGVR7/mmYTM5j0aPMuO1evelXzFqwOm6SWg8KDFBtqfBUSbXt6lm0JVqd0qJdaVYrCWbWdLkSbd2VEiuLxaL6c9OO36zF+NQySgv4pcEN61bGG83qoMnLL8om5i3bgLe6jcCNW3fVtnUWrl2x7NnhNXw9rh/GDumk9o+augiWB/1lzefJy5ovlFcOYiFT2VJFVXOeeqJYvPTqlZ9W6fZmOXNkUc+fwgVy29vNNApQgAIU8DAB50V2Tmr42fOXMe3blUgXHIT5kwdgcK+38XrjWujSrimWzBiCFyqVVYHwfO0F3UmnjC1meL93Me2LnpBgMTbRwZW4gVvcQ1JTZtxykrueI1tm1Za+nVsn91C7+RNrn93MKUxMK6sUVtetDuvctin6d3sTYrh+4WhUKlca5y5exc69R+LVc/boPnj3f6/g2fKlUa/Gs6hb7Rn1fLpxy3s+fu/WvrlyEAuZWjSqrgxaNqoRL71T2yYq3d7s+QpPqOdP0/pV7e22SWMCBShAAQq4t4DR3ao3a8FPqkofvPUqypctodatswzpgzG0Tzu1OWXuitirvGHhEejYb5y60rlG+yiybY8v1Eear77dH0tWbVP5ZbZs9XasXPeLrGL4hPnqGDlOhk9Iolzp6vHJZFlV07ET/6o8m3f8DhmTZ/2oVI459e95NbRi0pwfIOcpW/MdtO40DMdPnlHHWmcJy5wxb5UqU8pIOEmgH/c4+ci1apOuqi3y0fPo6YvjjQscPmEerEMC4pYlwxkiI6PUeaZ/+6O1SLW8eOUG5GNwa7liJcM81M4HM2u7t/zyu7pS2OK9wZD2STutVg+yOnWR0EoKl/b1GjIV8jG9DGmRuoydETMkRcb8ykf0km/vgT9Ve8VB8kuaTI60N+7j5/bd+/h60Vr0GjIFg0d/jYlffa/KleBRyos7yeNJznf0xOm4yWm+7u9nQvMG1VQ9Tp4+p5b2ZnfvhUDGmxbImxPyBslenoRpvx/5C+/2HqWGF8ljSJ4v8ibVmm/tlj3Ky97j5Mjxf9S+uMNPTp25gG6DJkLKkuEGb3YZjoSPR8kvzhcuXYMMFxgxcT6k36XPredNyTKpcuV5LOeMO9zjsPbpkKTJc1HqKo/Hdj1HOjQkRD5RGjllofpbIcfKcK0BX8yGmKSk7jyGAhSggJsKuG213C7g/e3wCYX1WqMaaplwljdXNrxS+3mVLEGnrERFmfHzr4cgY1n7DJsGCdgeL1EY8mI6dMxcyAub5JMASSZZv3HzDq5ev6WmsPBwSYIMd9j48361LjO56iXlygvymOlLEBIaDvmIU9IkUJShFRJQysfEEjTIC2L/z2fJobFTwjLvh4RCzh13kvJkOnfhauxxP27YCfliUanihdSVONkhgVgnLbCPMptlE7fv3NfqFDPe2NoWWZq1/VHaR91S5h8n/1V5ZSZfUpKg9afNv0J86td6Tll16DMaK9fvlCxqsra768CJaiyobBcrnE95ylATKUdldPIsodXpsxfR/N1PsH7bXjymnb/qc09qH8HfwVcL12CfFuDKx/DSXqlGSGiY6kvZlvpKmtTTkfZaHz8LV2xGwzb9MFp7Y7F+2z5IwJ8/T0712FqxNuaNkpQrk/TBhNnLsP/QCZQoWkCS3GoK1d4ESoUSq9vN23fx7oej1FXgLwZ0kKyPnDbt+A1tuo5QQaf0RdnSj0GeL/Xf6Iu//okJrOV88rj7Zsk6m/LkzefP2vNU+lJ2ip30z2btDWWRgnkhZR44ehLyeNy266BkUdO//11SffDhp9NUsL3gh02Q/ecuXlH7UzpLqtxbt++pc164dD22ePl7IvVPFxyoXRmvqL0hL449B46jS/8JsBfgWw+U7xxIYPzt0vUICPBXf78CteUK7c23mFjzcUkBClCAAvoJuFXAK0GEjNvNliUjMmVIl2irixXJr/bFDRAlQY6bNLw79q2djmWzhmLepAGSDAlKzVoA+NZr9dC6aR2VNmZIJ5VH8slHuyoxkZkEezKcYv3CUVgzfyQkULxx6y7kRUuOl/R1332pBaaV1Au/BF2JFIVe77fE4hmDY6dRn3yghm9I3bu/2yL2sJmjemP36imQj6BlrOXaBV+i1gvlIVcT/z17SeX7ctAHqPBkzBhdqYd1KpQ/t9qfcDZZuxotgaEcJ+WP/qQjVnz9mTr/Z+PnqW+lxz1G2v3d1EHYsnQcfvxmBDo/+Ah4046Hbwri5re3Lm8A5OpdwmnJj1vtZY+XtnrTbrX9qXZVP8ahMzYtHotxQ7sgv3ZVUq74S79IphpVysX259zx/SQJyW2vfMmr/JMl8M2Ej7FjxSTMnzwQL9d8VpW1+MctiNTeWKkNbbZjz2Et+L6LNi3qqseBluQ2/+Vq4lffxXxSUrliGZt6yVVdCTQvXL6mniMJP0mxOUBLkDd1cmVVW8Xqbz/H2CGd1Uf+Uz/vKUkYO2OxWhYvmh8yVlYCQfmkQSVqM3nc/bDmZ8hj6ukniiFKe1P26dhvtD3Aj3OHa/Xoj+kjP1RlS6K8mZBl3Enu1jK419tYu2CkekzWeqFC3N0pXne03CoVy2LrsvFYPuczjP+0C+Q5ZH38xX3DmLAiB7UgXoJlGWctz1F5/kkZcuyz5UonzM5tClCAAhTQQcCoQ5kpLvL6jZhxhPly50iyjGxZM6r9Ce+0UKnc4yooVDu1WQUteJGrRucuXsWV67e0lJT9ly8DlSlVJPbg6s8/rdbbtHhJXSmVDYPBoF2hekpW8fuRk2r5qJlc+ek+aBIkGBgzuDNy5cgSe4hcgTUajJCr2HL1aOX6X2AwGtR+aY9aScZMAgy5sisBh/UKuRyeP08OvPP6y6oOEghJmnWSdj+tBSfW7dpVn1GrFy9fV0tHZrlzZtWuiuexmWSM9qOON5lMKsv5S1djg02jZvBS9YpaoF9C7UtslpL2ymNl4rBuqPh0KWTT3nTJ1fz06YLUl8HkDc7Puw/Fnk7ujiEbzV+JGR8q6/YmGVoiV/FSMskVb3tl2ksbPX0R5CPyD/qOUXc0kceIfNkz4VAF+RREvswWFh6JwR+2hUF7SMlVVbkabq9ca9off/2r7vrwRrO6KFoorzUZ1Ss/rV3pLIEde47EDjGSsbKSYfXG3bJQ05ZfDqhlqya11fL4ybOQIFC+lCpXd83aG1KZ5M2aBOByxTjhLcG+GtNHfYlV8sjjKkvmDKqs1M4cLVfOKc9RGfby+5G/1CcPh4+fUqc/ffaCWtqbGR98Cfam9iZZjrXmkb8pjV6qYt3kkgIU8EEBNtl1Am4V8GZ98AJ29UbSwal8lC9ECV/MJS3hVPzBx83OvEVQ+vTB6jRmi0UtrTO54ijrEsDK8lGTXDGTF3b51rx8iShu/k3ax8fVm3XDq20HqDtWDBz5FTbv+F1lsd7hQG04OJOrl5L1iTiBu2zLVOKxmI/k416Rk/SEU6aM6VVSRGSUWjoyk6vW8uXDhJNc7XrU8XUeBNgy7rlKo86QsblyZVjeKDzq2JS0N11wTL8mLNsa1MpVXtknwaQEeHLFXd4wSFpiU0hYOIaOmZuiSYYLJFZuwnR5bMhH5FIv2de/2xvqy56yHneSMbayLY9RebMlY2Zl+nrxWklOdLJ+mlK6eEGbPE+UjHkzeOHSNbWvXo1KaileMuxENlZob9hk2aDWc7LAfw/uASz9+VTtdog7SQAuma4luPd2cHCgJDt9crRcCVblMSiPRRnaIevyycijKiSfwsgbKBmbLMfKmxIZr3/lWtJ/5x5VLvdTgAIUoIDjAm4V8Mr4NrmKIsFK2IMxiPaaIsMeJF2u9MgyqcmiXTmS/aYHV1lkCMU++gAAEABJREFUPbWTUS6L2SnEZHScU8YVy0e88lF8u1YN4pUmX8yRYCRMuwr3UefW2kfrA9RHqQN7tImXLzkbYQ88/f38bA7z84u5khr+II9NhgcJJqPj7XtwSKoWJbVAfOOi0ZBbS0lB67ftxVDtY/CXWn2I02cvSlKikzPaay28VLGC6iqmBCz/XbgC63je/zWtY82S6FKG5mzQ2pCS6b03GgJItOh4O2TIy7Ftc9XH7LJj/Kzv1RhwWY87ycfwMowl4SS3/YubL+F6WESESrL3+PF/8PixXpFNFxykgm15HsuVUAmE5TEtb3KsV2Xvh4aq8uQK59De78DeZM2rMrrBrPPH49VV3RpVymHyiO6QoR27Vk2BBLNJVU98fpo/Eu+0qg/5+yZvSibPWY6aLXpgw/b9SR3KfRSgAAUo4CQB10YwDlRaroZINgkIZZlwko+WJVCU9McKP/xoVbbtTWfOX1bJBfLkVEvrTD4+ta67enni1H+QK7by4jfi4/dgNGqfK8epxM97DqstGSf59mv1VLAlH6Wm5HZpqiBtZh0mIgGbthnv/6UrN9R2vjzZ1dKdZvny5FC3ktq7ZhpkHLHcJkoeA6s27opXTbM55ot81kRnt7dV41qq6CU/boNcuZQvKT5X4QmVltTMYDBArgKnZMr84Ip6UuUn3PdCpbLo1+V/aohKx75jIV++iptHhmmU0D71SDjJ4ytuvoTr1uePvU8BLl65rrLnyfXw8SP9JIkr1+/ET5t/lVU0b/Bw+EfBfLlUWsG8OdGiYXW7kwTOKpMbzORLfnLlWe7pO2VED9SsUl4N7XC0j+SNT+8PXldjj7f/MAF9OrVSrXrUlXWViTMKUCBGgHMKpELA7QLe99s0Us0ZO2OpzS2+QsMi8Nn4b9V+uZdo1swxY3lVgp2Z3NJKvs0t42GtV4uyZMqgcl568CKtNlw4kx/M6DZwojqjvHDae8G0funN3z/myqtkjtICuuMJbnkm6VmzxLTnUR+PBgcFqPHG+w7+iVNnHo43lHLlY2Upy/rRtKy7w7RDC/ytAZvBYFBfeHqjWcxV1ZMP7grg7x9zxTrhGFRnt1fGL0sAJrenk4BbvgCZ8I2KO5hJHWRsebMG1dQdGHoMngwZRyzpqZmsw16WrNoK+QKbtSwZR79+2z515VJ+GMaa/mTpoqq/5M2p3J1A3iDI2GjrfrlqLutzl6xXY4Nl3TrJMIgtv/xu3XSLpdxVRSpifbzJukzyaZM8HmQ9senYiX8hY/Gt+2Uo1hvN6qovi8qdXazpXFKAAhSggH4CbhfwypUnuQevjDGUe65+Ou5bLFq5BVO+Xg65DZi8uMpVqnat4w8DEKL12kfecu/UBT9sxNgZS7T8n0gyPurUWi1lVrp4IVlA7okpv0Y1+7uf1G2WVKILZjJuV8aAFiucDz//ehgyPtU6WQPPSk+XUjUZPOpryEef0vbX3hsMuR2T2hFn9mTpx9TWR59Nx8IVmzF+1jLIvWdVYoKZjBWWJPm5YTFdtWEXOvQere4sIVcwrVfdJI87THJ1sG6r3pD788oXoOSLYvJ4kLpJwCBLmSpXLKN+PGHQl3OUwZjpSyQZzmyvBNBipArWZvLxvLZw2/+DerRRnwzIG5zPJsxLdT0lSJM3ozJMoW2PL9Rt7OQ+xP/rNEyV3bdzaxgM8T+paN005gtqEhCKXdw3CPJmVcYZy/O84VsfY+o3K1WZ8viV57ncEk8V7CYzGT4lQxfkKq/cx3ruknXqS4JyP91HVfHYX/+qsfj9RszE0tXbIM+7j7V1aXuntxs/6nDupwAFKEABJwi4XcArberarhnkdkcS2EqQM0wLeuUF8er125Ara9/PHgZ7V0blBUmuDI2YuEDdq1WGDMitjuJ+IUzu3CAfLcpYxC8mf4dxM5fi3KWrclqbyWiM4TEY4r+QGwwx23IXhXgHPUiPl5ZgQ26BJElylVV+1CDuJC+isq+59hGvjFuVwFi+3CJtDwoKVN9Ql/1xT9O6SW38Twss5CrSZ+PnqR/fCAmJGR8peePWUT7ultsphYVHQkzlBVhuHyVjCyVgkfwyJdZu2SeTdb+sJzo9qKTxwTJhPoMhxtBgiFkm3C/bcjcM6VNx6Tt8BiTYFT8JlJ5/5uFwgo+1j/Dr1agEuZooBhLMy/GOttdgSLwOUo51sp5T7ixg7/FnzefKpdEYU3fr0npuGQ8vfS1+Eph+t3yzdVeKl53aNkHnd5pCrkrK7ebkzeXde6H4on8H2Lu1X4Naz8eey94bhP81rQO5NV7GDMHqDa2UOWvBau3K9DU13tV6sMEQ00YDDNakZC0ND45L+Lg1GAyqHMOD/WrjwcxgMKg1gyFmKVd2JwzrpsbryhANeRMmXxLsrJnIlX+V+cHswSGwnu+JkoXVmw8JdIeMngt53smXB19rWAPvJmOc9oPiuaCAgwLMRgEKxBUwxt1wp3W53ZHc83bvmunq/qqbloyFjOOUwEyuttmra6Vyj2Pb9xPUOLlt349XS7nVVMK8EuDJfXNl+mXlJMgLj+SROwkc2zZXVtUkAZNsS4CjEh7MpG6S3vyVag9SYha1XigPSbeOX5TUhGXKfTglj71J2ivH+JlMatyq3PNT7tW5eelYLJw6CIN7va3Kr1mlvGRTk9wZYkD3Ntj142R1f1K5B3GxIvkhRnIOCXpUxgezutUqYs9P07S8X6r7if6+YRbkDYAESA+yILF2yzhPKVPqYc2b2FJuTSV5GyVy2yW5ZZbst15xl3ISWsmxco9j+WKQ3LdUvvgl63Gv7spx0l4Z77x79VSo/JqFpMvkSHvl1mNSl7FDOskhiU5rHoxFlbYlmsnFOyRglLrLkIGEp5arsjtWTFKPGXlTlHB/crflcdlJuyJ5cONs/Dh3uLon9a+aufSTvbIyZ0qvzi31y5k9i00Wg8Gg7mm9Zek4SL/KF+lkfKs8z+UxaT2gx3stVDlyj19rWnKWMkZY6tC43gvxDkuqXHlzI8fEdZM3y/J3SB6LMu1fNxOdtIBXnnOybS1c3hTIsdZhGzLuVx7bkl++6CaTrA/p3dbt7uFsbQOXFKAABbxNwG0DXiu0BCOPlygM+YU1gyHmaot1n72l3I1Bruzae4GNm99gMEA+wpePVuOmu9O6BJhyr848ObM9slpyBUo+dk14tcnegXI1sFD+XCj5WAGPeMGVq6lSV/nil3zj3V6bJE2+GCSBn1jItnVyRnsvX70JuaIn94iVx6O1bF9ciq+8yZBPYOT55gwD6WMZziRBusHw6Oe5M86ZkjLkx2bksSiTvKlMThmSX+5hLJOsJ+dY5qUABShAgdQJuH3Am7rm8WgKOEdA7swgJcnH8LLkRAEKeJUAG0MBCni5gFcEvEFBARj2UTu0fLWGl3cXm5dWAmVKFlWPsTpVK6RVFXheClCAAhSgAAVSKOAVAa+MLZTbMD3vwH1RU+gE8ECfFqitBbryGIs71tmnQdh4ClCAAhSggAcJeEXA60HerCoFKEABjxdgAyhAAQp4mgADXk/rMdaXAhSgAAUoQAEKUCBZAjoFvMmqAzNTgAIUoAAFKEABClBANwEGvLrRsmAKUIACAIhAAQpQgAJpLsCAN827gBWgAAUoQAEKUIAC3i+Qli1kwJuW+jw3BShAAQpQgAIUoIDuAgx4dSfmCShAAccFmJMCFKAABSjgfAEGvM43ZYkUoAAFKEABClAgdQI82qkCDHidysnCKEABClCAAhSgAAXcTYABr7v1COtDAccFmJMCFKAABShAAQcEGPA6gMQsFKAABShAAQq4swDrRoGkBRjwJu3DvRSgAAUoQAEKUIACHi7AgNfDO5DVd1yAOSlAAQpQgAIU8E0BBry+2e9sNQUoQAEK+K4AW04BnxNgwOtzXc4GU4ACFKAABShAAd8SYMDrW/3teGuZkwIUoAAFKEABCniJAANeL+lINoMCFKAABfQRYKkUoIDnCzDg9fw+ZAsoQAEKUIACFKAABZIQYMCbBI7ju5iTAhSgAAUoQAEKUMBdBRjwumvPsF4UoAAFPFGAdaYABSjghgIMeN2wU1glClCAAhSgAAUoQAHnCaRFwOu82rMkClCAAhSgAAUoQAEKPEKAAe8jgLibAhSggH4CLJkCFKAABVwhwIDXFco8BwUoQAEKUIACFKBA4gI672HAqzMwi6cABShAAQpQgAIUSFsBBrxp68+zU4ACjgswJwUoQAEKUCBFAgx4U8TGgyhAAQpQgAIUoEBaCfC8yRVgwJtcMeanAAUoQAEKUIACFPAoAQa8HtVdrCwFHBdgTgpQgAIUoAAFYgQY8MY4cE4BClCAAhSggHcKsFUUAANePggoQAEKUIACFKAABbxagAGvV3cvG+ewADNSgAIUoAAFKOC1Agx4vbZr2TAKUIACFKBA8gV4BAW8UYABrzf2KttEAQpQgAIUoAAFKBArwIA3loIrjgswJwUoQAEKUIACFPAcAQa8ntNXrCkFKEABCribAOtDAQp4hAADXo/oJlaSAhSgAAUoQAEKUCClAgx4Uyrn+HHMSQEKUIACFKAABSiQhgIMeNMQn6emAAUo4FsCbC0FKECBtBFgwJs27jwrBShAAQpQgAIUoICLBNwu4HVRu3kaClCAAhSgAAUoQAEfEWDA6yMdzWZSgAIeJ8AKU4ACFKCAkwQY8DoJksVQgAIUoAAFKEABCughkPoyGfCm3pAlUIACFKAABShAAQq4sQADXjfuHFaNAhRwXIA5KUABClCAAokJMOBNTMbB9AvXQ6H3dO1OuKpNRKRF93Pp3RZfKD8iyoKrt8PZVy54bqT28RRpjsbVW2HsKw/oqyitr66wrzzisWq2ROPyzTCbuqoXMs5cIcBz2BFgwGsHhUkUoAAFKEABClCAAt4jwIDXe/qSLaGA4wLMSQEKUIACFPAhAQa8PtTZbCoFKEABClCAAvEFuOUbAgx4faOf2UoKUIACFKAABSjgswIMeH2269lwxwWYkwIUoAAFKEABTxZgwOvJvce6U4ACFKAABVwpwHNRwEMFGPB6aMex2hSgAAUoQAEKUIACjgkw4HXMibkcF2BOClCAAhSgAAUo4FYCDHjdqjtYGQpQgAIU8B4BtsTbBa7fvIObt+/aNPP2nftYu2WPTbo1wWKJRkhoOGRpTXPGMjLKjLDwCGcU5ZQybt+NcYiOjnZKeakphAFvavR4LAUoQAEKUIACPicgwWzVJl1RrWk3vNi4K2q91hNbfvk91uHs+cvo/ek0JBbo/XPmAirVfx+nzpyPPSa5K+cuXkWvIVMQZTbHHjrj2x/RuuOnsdvOWGnTdQQGj/7apqg1m/dobfgAERGRNvusCecuXFUOZovFmpRmS68NeOVd06WrN+I9EB6lfPHKDae/23rUObmfAhSgAAUoQAHnCtzRLrru2mvBxq0WnD7j3KuL23cfUkHce280xK+rp2LXqilo3aQ2ug6ciH0H/3SoIfzVIqMAABAASURBVAXy5cSSGUNQMF8uh/Lby3T3XgjWb9uHaO1qsXV/y1drYvQnHa2bTlm+Wq8KJLgNTxDY/rR5NxrWrYyAAH+nnEfvQrwy4JUH43OvdETt13rh6drtsWTVtiQdv126HvVa98EbnYeherNuGDtjid3842YuRZkabXFHe5DZzcBEClCAAhRIqQCPo4BTBE6fjcbHwyIxZ4EZi1eYMXxsFJaufHgVNLUnmTTnBzStXxVvvVYPGTOkQ+aM6SHBb70alTDxqx/iFT993o/q6m+l+h9g9nc/qX2rNuzC290+x6djv1HDGiQxNCwCX0z+DnLV+NW3+2PBDxshabJPrhIvW70dTdsNVFdU5YrrgaMnMejLObIbrTsNw+vvD8WhP05h36E/sWD5ZpXea8hULF29Ta1bZ10HTNCC5L1qc/+hE+o4qVv/z2fhyJ+nVXrCWd2qFbV6hmHnvqOxu2QYx7ZdB9Gg1nO4dfueqoOUI1PbHl/gxKn/YvPGXRkyem68oR5bdx1A3+EzYrM4WqfYA5Kx4nUBrzxA5GOELu2a4tDmrzBhWFcMHTMXcunfnsuxE/9i5JSFGPZRe2xZOg7fTOyPrxauUQ+cuPmXr90R+2CNm851ClCAAhSgAAXcR2CDdlU3PDx+fdZvscAZQ1tljOzxk2dQp+oz8U+gbdXRAsPfj/wFCVC1TfX/9JmLGNr7HbRsVANy0UxikYrlSqNd6wY4euI0IiOjVL6RWrB74MhJjNKuzg7o0QYLftiETT/vV/tWb9ythhS8XPM5fDWmD16oVBbHT57FG83qqP0fvt8SvTu+jiIF8+D6jdv49+xFlV6mVBHMXvBTbH0k3tmy8wAqPFkSZ89fwdvdP0e9mpXw3dSByJc7B7oPmhibVxXwYJYlcwbUrloBUo8HSdi843dky5JRlWUwGiDBvtRt3qT+yJU9CwZ8MduaNd7y1JkLuKkFyNZECZb/ehAcJ6dO1uOTs/SsgNeBlu09cFy9E2nduBb8TCb1oCxcIDe27z5o9+h7IaEqPU+urGr5WKG8qhPPnrustmW2T/uIYsTEBU7/mEDK5kQBClCAAhSggPMELl6yP4Th8lX76ck5881bd1X2bFqwp1bizLJqgaFs3r0fE1fI+siB76Pqc0+hT6dWkFhE4om8ubKhfNkSsltNcqFuqXYltvHLL6qrxZm0q8YS1G7cERPwLv5xKxq9VAXvt2mEp54ohg/eehX/a1obpYsXUsdXfLoUKmlBtFxpVgkPZo3qVlEX+w4e+1ulrFy/UwWmObWAdPXGXao+lZ8pg6goM6pXfhqXr95M9MqslLV+217ce9A2Kav5K9VhMhlVnV9/tRZCtXcUh7RzyRAHeVOgTpqMWXLrlIyiVVavC3gvX7upOlHAVQu1WbHC+XDpyk1tzfZ/+TLFIe92mr87GPOWbcC0b1ciR7bMqF6lnMp8Rgt8O308HuM/7YISRQuoNM4oQAEKpLUAz08BCtgXyJvHYHdH7pz20+1mTiQx64NA9/qtOzY5bjy4W4MErDY7tQQJUI/aGTZw6cp1bS/ww5qfMXzCfDXJFVy5aCc7ZHhApadLy2qyplw5skCuzK5ct1O7uh0J+aRaglQp5OyFK7h6/bY6l5xTPumWIFzuOiH7E04vPvuUStqqXSG+ePk65Ep2g9rPq7S/T5/HS60+VJ+m/6Fd/Y77JTqVwcFZcuvkYLGx2bwu4L1z9z7SBQfFNlBWAgMDIIO7ZT3hJIFxteefgrzjWq19bDB5znJUe/5prYxAyG1FOvQZjZ4dXlMfISQ8VrZzZg6E3lOW9P5yKvj7GXU/l95t8YXy/bV3vFkzBLCvXPDcSO3jyc9kQNaM+j+HU1vPDAGBCLkTAFmmtixPPd6k9VU2D+grPXyl3RH3A4Ao93+sSvtN2kfc2TPZ1hUu+vdSTSMCA+OfrF4tLU0jjJ+a/C1/PxMeL1EYG7fHXH2NW4JcAX2u/ONxk+Kty5CC7NoFtXiJ2ka2rJm0OfBpn3cwf/KA2GnskM4qvUDeHDh5+pxajzszGAxq05LELb9ea1hDjeNds/lXZMwQjOcrPKGOyZkti7b+eOy5rOeVK8sqQ4JZcFAAWjSsjp8278aGn/dDLiSWfCzmIuD3WqBerEh+rPrmczV8o3WT2gmOfrgpfond1SG5dXpYKhxa9bqAN1PG9GpIQ9zWh2uX2WVgedw06/qOPYcxftYyzJ8yEItnDMbMUb3x3fLN+H71dvz6+zH1ccB/2juhL6csxOyFMQPOJb/1cv2t+5HQe7oXFjPYPsps0f1cerfFF8qPslhwN1T/x4UvWOrdRrM5GndDItz6eTV3YRR6DTTji/EWtZy7KMqt66tXn1m0vrrj5n2lR9t3/xaFvoPN+GyMBZ+MMGPISDP+OefejwGzJRq379s+r6yvu3ovixYy4PNB/mj3hgmvNzFhQC8/vNbY5LTTdm3XDPKR/tzF69SX2OVes9O//VGNa+3Utkm88/x34aq6L64MWZDxu9W0C2zxMmgbMhRBAuXPJ30HuVuUjBOW8b3fLF2v7QXqVH0GP23aDYlXosxm/PrbH9i04zft0+w8ar8MWQgNi9BinwQDl7W9lSuWUcM0B478ChKIyhAELRk1XyiHLdrVWvkCnZQpV3YXrdwCuVor++1Nr9SurNXhCL5Zsg7NXqkWmyVDuiA11OGGdtVbrv4uXRX/i3KxGbWViuVKY9vugxCzP/76V7uqvUNLjfmfkjrFHOnY3OsC3tw5skKGIVgHggvDX/+cQ55cMWN0ZTvu9Nvhv9Q7FetHEPLu5tnypSHpxbV3LN3fbQ4Zl5MlcwZY82TJlB4B/n6qmMgoC/SeJNCVk8mbOL3PxfJT35/ST1HaizMtU2/pNMNEnqcyos+d++rPv6KxZ78B/tHhKBp+GMXCD+DaLwdxfssBmP/43aemKNVe32v3gcUHkOfmAdX30v8Z/juAw0ud5xB557bTX8Pk9cre80rSXTVlyghUedaIutrV3qKFY66EOuvc1Ss/rb7T85V2Eaxyw06o0qgz5K4Kk4Z3h4ynVed5cPW1+buf4Jl6HSB3J+jbuTXKliqqdsf9YpskfN6/AzKkD0adlr1Qrk57dfeE23fuyS60a/2K+uT5g75j8XTt9ur2Z0ajEcHaVdeObzVGu54jUfHlDpDxswZD/LbKsIjWTeuocl596QW1lJkM5Rz2UTt8Ou5bVabcT1juWBUQEBPbSJ6E0zNPlVTBs4z1fbnms7G7m71SXa3XaN4DdV7/ENdu3FLbMktQHdTXjpN2idnb3b9A+nSBMJlMklUNL01undSBDs68LuCtpL17kLYvXLEZ8q5F3gXJu6rqlWPG5O47+CdavDdYBcWSr+RjBSHfGpR3TvIAlG8Jyq02nihZBMW0gLfDm41gnVo2qimHoO3r9dU+tcEZBShAAR0EDP+dQsCmJehwvTc+v/QyOt/ojo43eqmpyMLeCBrXx6em0GHd4T/G99r99rkPVZ9b+16Wdfd96LS+N547pcOj1/uLrF/rOexYMQnbf5iAn5dPVOu1Xigf2/AnSxfFsW1z1T161y8chf3rZqrbmFkzXH0QFGbWLqBJWu6cWTHti574bf1MdccouctUt/bNZZcKbIf3excHNszC1mXj1b1/refq0q6pKlvuBSxXc9u0eAlzxvVVx1lnnd5urOoi55A069SsQTXsXTNNtUGOXzN/JArlz23dbbM0mYyqndKuPDmzxe7Pmysbls0aio2LRmPf2hmYPvJDdT7JILGU5JfAW7aLFsqL5XM+w+alY7F79RSVV46VfTIlt05yjKOT1wW86YIDIe+yZAC2vBPqPmgSBvZogwJ5cyqTeyGhOH7yjPqIQRLkXYo8YD4bPw/PNuiItj0+h9xP743mdWU3JwpQgAKuEQi5C9Nv2xE45wsEf/Qagkd8gFIHZqJkxG/q/Bf8iuJUwNNqupPvKVhK+tZkeqIcon2szVHFn8I/D/rc2veyPJ/paaf1P4IzqMcXZykTkC+5Z38wBtdeCTJmVeIPuRor+9dv24sen0xGt4ET0eTlFxEUGCDJsZNsS2BqDRBjd2grAQH+yJUji3ZFNH7oJmXLsAgtS7L/GwwG9UX9lB4f94T58uRQ33+Km5bYugTM9too+Q0G59VJyrNO8dWsqR6+lHc+hzfPwQbt3cbBjbMh41asTapZpbx651GqWEGVZDQaIB8JyDuwlV9/hk2Lx6LHey0gD1KVIc6seNH86ljr0IY4u7hKAS8SYFNcImAxw3TqGPxXf4OgkV2RrndzBM7+DKZ9m2G4ewvR6TMirFx1fJ/9IwzJ9QPG5pyDadnHY07e8QjvNQZhPX1rCtYuXkT2HutT7Y74cAx+rjZO9bv0vXU62dJ5DpaCxV3ycOdJYgQeL1EEz1V4HF/0f1/d/z8mlXNXCHhlwCtwcuk9v/Zuw//BWFtJe9Qk704kAH5UPu6nAAVcK3D3LnDhAhAR6drzOvtshlvX4ffLGgTO+lQLcFsgcHQP+P80H8Z//wS0qxrmx55AZMO3EPbRRIR+uQyW9wfi2R4v4ckXM6NEiWhUrmzBB++akT49Uv3PbAEuXQZu3Iw/5i/VBftwAZevAGvWGTF/oQkbNhlx81bqbZu8akb9ehY8XtqCck9Fo2ULCypV0DrPh51d2nQnn6xQ/lzqIpx8V4jxhpNxH1Gc1wa8j2g3d1OAAh4gEBYOzJ1nwqhxfpg+2w9fjPLDr3s96M9WRARMx/bBf9k0BH36LoI/boWABeNg+n0HEHoPlqw5EfVCfYS/NwihY5YjvM8ERL7SBpaijwPGmHZmzxGN+nUtaNNaC3y0pWyntuv+OmnAqLF+mDrDD+MnmTB5mh+uXTektlifPv6WFtzOmOWnHp/i+8suI2bMNkEew6mB0T7FRuXnLGjd0oJmTcwo+4RF3hulpkgeSwGfFIj5i+qTTWejKeAUARaio8Bvvxvxz2kDskVdwGPhB1H4/gGcXHUI4YcOwvhX6ie504HhROrLiVcXrTz/TcsQOOljpOv+CgIn94f/5h9gvHhGSZmfqIjI5u8jdMB0hI34DhFv9oK5QjVEB6VT+10xW73GiJCQh2e6chXYtp0vBw9Fkr/2x58GRMXcQTL2YDE+qb25iE3gCgUokGYC/AuXZvQ8MQUoYCNw/y6MWsDopwWIAfPH4qmV3TD8Un30v/oGOt3oqb6t/v61Xsg6vY9TvqUeNqw7/MY4+Zv/4/vA//sZMP0Rc2N6S97CiKzTHOFdRiBkwk8I7/q5tt0C0QWK2TTfFQkyPOTWbduruecvuuLs3nuO27ftt+2qT105t2/AVAq4gwADXnfoBdaBAi4WkPGbJ/4yYuduI2SZ8MqU7tXRPuo3/nsCfjvXQj7uD5zYD8F9WyJd72YI0gLGgGXT1L7ct48hMDoMoYYM+CfgSXWHAvmWeliRp5zyLXW9vvlvrlAVEf/rjtDhCxD2yWxZEDXcAAAQAElEQVTtiu4HMJepBAQE6E77qBPI+F+DbbyLjBkedST3JyVQpLD9vSWKyd2e7e9jKgUo4DoBBryus+aZABAh7QWiogAZa7hgkRHrNxohy+mz/CDpTq+dxQLjpbPqdltyN4LAGUMQPPhtpOvREEEju0Cu4srH/abjv8Fw5yaiAwJhKVwSUVVeRkTzD/Bf65EYmut7DMqzClOzT1TfVl9Wahyi+oxxyrf1gwZNQpQO3/wPf+8TRFVtiOhsueBu/2RocJknom2qVbasbZpNJiYkKiBfKnsqjqG8qajyvAUFC9A1UTTuoIALBRjwuhA7JacKCQW2bjdg0swozF9iwal/7FyaSUnBPMbnBAy3rsFw7hQubDyAPP9uxQv3l6Pu3W/w0t25KHdqLu5++y38Vztj+gaBX3+BoOEfIF3negga2l7dbkvuRmA6uBOGKxeA6GhYchdEVIVqiGz0NsLfH4zQoXMROmE1wvpNQUSbDxFVpzmyV6uAlu0zq2+llyxhQY3qFrR722z9PpfP9aGzGsxv/jtLMn45LZqZ0a9PFDq8a0b/vlF4+SVL/Azxt7hFAZcJnD57EXsOHHfZ+dzxRAx43bFX4tRp/ncmrN9kwKFj0di1NxrfzDfh5N8MeuMQ+eyq4cYVGM+cgOnYXpj2bIT/pmXw//FrddU0cNonkFteBQ1ui3S9miJdx7oI/rg1grUgtPSPH+HNW5+i6Z2JqHdvLl66pwW92pR/3zz4/+SMaT5MezfDqAXX0jmWLDnUx/mRL72O8LYfqYA2ZNpGhA2Zg4j3BiGywZswl3sR0bnyw96/woWi0aihBW+2tqCWFvDKR/L28jHNcYEAf/Cb/45zJStnumCgQL5oJPg9gWSVwczuLTDoyzkoU6Nt7FS1SVfMWrBaex+f8qv58ouwvYZMgfxCrL3Wh4SGqfOt3rjbZvfQsd+gY79xNulxE+TXZGd8+2PcJJ9bZ8Drxl1+85YB587HBLf5Iv9Gx+s91JTn6w8RNI6TuxqED+sGv9G9nN5HgV92Q/DANxHco1FMADvgDQR90QWBkwcgcO6XkC9K+a/9To19NR3erX7UwHjlvLr9lTzMozNkhiVPIdzN/xQOB1XDrnSvYmOGt7Ahw9tqOl+pDeSWWM6YIlp3Q1ivsQgduwJhny+EfGErsum7MD9XVw1ZkPpwogAFKOCpAvVqVMKmJWOxdsGX6NS2CcbPWgb5FdeUtufuvRCs37YP0Rb7QXO64CC8Uvt5rN60K94pIiIiIUFwo7pV4qVzw1bAaJvEFHcRuHbtYU2CLXdRLOKQmnLfOATjX4c5uamB+fhBGE4ccnr/mE4fh+H6ZRjCw9QDIzpTNkTnfwzmUuURVbEGomo0VsMDIlp3h4whVb/E9ckshH65FCHaFdXQUcsQNvgrRPcbgw2lh+KHzD2xPuM72JCxLQ4Wa4uMb70F+dEDZ0xR1RrBUuJJRAenV3XlzHcEbt8xqB8JcfaYcN8RZEs9QUAC0Ly5skF+SKJO1WdUlY0yQF5bi46OxuKVW9Dgzb6oql39HTdzKS5dvaHtAf67cAWd+49HpfofqH0fDZsOCVrlqrFkaN1pGF5/fygO/XFKNuNNr9SpjB17juD6zTux6bv2H4Nc/a1R5WnsP3QCr77dX5Ut5UvZt+/ej81rXYmMMqtznDl32ZqEqXNXYN6yDWo7qfqrDB46Y8Drxh1XuGB07Je6z/sXx7RsY9W0s4Z8YWcUwnpySo3BzfdH4XybUbjX1bmOgQPHI6r3GKf3j/wogYxzDRm7PCaAHbkYoQNnILzHl4hoPwARr3eBDA+IqtYQ5gpVY+5ikLcIojNmifco9/MD3n8vCm+0sqBeXYtafqBtS3q8jNygQDIEtE9cMftrE8aMN8X+SMj+32I+oUpGMcxKARuBiE0rEbbkK5dP0TfjXHVKUKuT/5zDd8s34+tFa9Gl/wQ0eflFlCpWUOVas2UPRk9fgi7vNMPMUb1x+r+LmPL1CrVv2LhvYdGu4s7XPpkbO6QzDEYDJAB9o1kdtf/D91uid8fXUaRgHrUdd1alYhlIoL15x2+xyWs2/4pGL1VR6UFBAXinVX3Mm9RfO++H+PPvs/jqu59i81pXoi0WHD1xGqFxfhVFhlRcvnZTZUmq/iqDh868KOD10B5IotoBgUCDl80q6A0zZsSpwPKILF4OpRrJLZnKaQENJ0vJ5BtEPFYOc/Y8g+E/VsS4TRXx2YqK+OV6Bad5mp6ogOhSya/Xo9pifuyJmHGuwam/f5RJe+aXKmnBC5UtkKWfKYkHIndRwAGB3XuMOPvfwwBX+6QVP60zaS+qDhzMLBRIQiB8048IW/a1yydLEgHv1Ru31BXVI3/+A6P2B3XD9v3YuvOAasVCLRB+qXpFFC2UR23XqFwO67buVeNzQ0LDERjgj6yZM6JSudIYOeB9pE8XhNLFC6m8FZ8updIzZ0yvtuPO/P390LR+Vfy4IWZYw/2QMPwkAW/dmOEMZUsVxYvPPgm5cnv0z9PInCkDTp25ELcIh9aTqr9DBbhpJu1lz01rxmopgQrlovHJxxYM6u2H4QNNePcdM9KlU7s4S6HA3v1G9etd1sPlo9f1m4y4d8+awiUFPFwgDap/6ZLtSc1m4NKlh0GwbQ6mUODRAoF1XkVQi3dcPhmz5ki0clUqlsXYIZ20qTMWTh2Edq3ra1d1F6v8Z85dUsHw8AnzIdMPa3aoq7+3bt9Dt/bNcfj4KdRs0QP1WvfB0tXb1DGOzl6p8zwOHD2J85euYfvuQ+rK7nMVHleHr9WuLNdo3gPzv9+ohk6YtEDcLE9CtdfxWVL1d7wU98vJgNf9+sSmRvJRc+GCBmSN/8m0TT4mOCZw6bLtC3B0NHCRL8yOATIXBewIBAXZPq8kW4bUfyAhxXDyYYGAOo0R1LK9yydDEgFvwu4oVji/urIqwxNy58yGN5vXhQxbiDvlyJYZz5YvjY2LxmDl18PRpP6LGDJ6LuSWYQZDzPPHIi9GCQuPs/3U44+hQN6c2LBtn3Z1dzdaNKwOP1PMR3TTvlmJzu80VUMa+nd7E9Wefwr2/hkejDWOjIyytxtJ1d/uAW6eaK0eA16rBJc+IxAcpEW3dlobFGQnkUkUoIBDAk+WsdjkK5A/Gjlz2H++2WRmAgU8SCAkNAwXr9zA2fOXsXPfUUye8wNqVCkHfz8TZDjDzPmrcOT4PzCbLVqeKxg7Y4lq3ZjpSyDjZYsVyQcZ6iCJYeERKFwgZvjDwWN/IzQsAiGh4bLLZjIYDGj88ouY9/0GbNt1EA1qPx+bJ1PG9Lh6/Rbkjg9yx4j1W/fF7ou7InWs8GRJbP7ld9y5F6KuFO/Yczg2S1L1j83kgSsMeD2w01jl1AmULWP7Aiwvyvnz2aan7kw82jMEWEtnCJQoHo233zSjQvlolCphQe2aFrz5P7MzimYZFHA7AbmFWJ2WvVD/jb7oN3wGKpYrjRH93lP1bNvyZTSsWwWtOn6Kp2q30/J8hMNa8Cs7//3vorp7Q9ma76i7NfTs8BoeL1EYwUEB6PhWY7TrORIVX+6AQ1rgK/ntTfVrPovLV2+qK71lSxWJzdLx7cbY9PN+PN+wE97q9jlkzK/BEBPmGQwxV5Ctmd95/WV8/9N2VNbyjpzyHeTqswEGtTup+qsMHjqLkfDQyrPaFEiJgPzUZ/u2ZlSqYEFJ7YWZv96VEkUeQwFbgWKPRaNJIzPeaG1B9aoWyI8w2OZiCgU8W2DYR+1wbNvc2GnHikn4pOdbyJwp5otmAQH+6Nu5NQ5t/gpblo7D/nUzMXd8P9XoScO747f1M7F12Xi1793/vaLSZdalXVOVd9eqKahcsYwk2Z2KFsqrzr1+4SgYDDFBqmR8oVJZbP1+PNZ99yWkDBlOMe2LnrILbVq8hDnj+qp1mdV6sYLKK/VbM38kls/5DB9+0BLQdiZVf223x/5nwOuxXceKp0aAv96VGj0eSwEKUIACjxKQsbW5c2ZVV2/j5g0KDECuHPa/lCNXeu3doSHu8UmtyzkL5ssFGbaQVD7ZJ3mlfrJub7LulzrZ2+9paQx4Pa3HWF8KpK0Az56IgHzX5NARA5b9YMLipUbI3UCi+Il+IlpMpgAFKOBaAQa8rvXm2ShAAS8V2LHTiO+Xm3D4qAHHjhuxeo0Ra9fyT6yXdjebRQEARPAkAf419qTeYl0pQAG3FThyzPbP6eGjRlhsb17gtm1gxShAAQp4q4DtX2hvbSnbRYE0EOApfUfg9i3btoZHALfvPPxSiW0OplCAAhSggCsEGPC6QpnnoAAF3Erg/n1gy3Yjps42Y8UqI86cTX1QWqSI7aXc7NmjkTULb3fnVp3PyqSVAM9LgTQVYMCbpvw8OQUo4GoBGWIw5xsTtmkB75E/orFnvwFfzTXhv3OpC3rr1LIgmxbgWtuTMUM0GjawDYKt+7mkAAUoQAHXCTDgdZ01z/QoAQ/fHxIKbN9hxLSvLPh+hQGn/kldAOXhHG5b/ctXgKvXbPvm4EHbtOQ0IldOoHsnM7p1NqPLB1H4sIcZxYry6m5yDO3lPf2vAfIGpXu/KIydZMT2n/myZc+JaRSgQNIC/MuRtA/3uoHAFS1A2bPPiP2/GXDrVuqCEj2bM/87EzZvNUKuGu7/3YBv5ptw8m/3ra+eFu5c9jU7wa7U9+r11PeV3AM+h3aVN1cuwMi/rsKaqknGQH+3yIR/zxgg69J3m7cZcfSYIVXlesLBrCMFKOBcAf5Jdq4nS3OygAS6k6f74ae1Rvz4kwkTpphw/IT7PWzliuG587Yvwva+ue9kIhaXTIGiRaJhMtkeVKokr8baqqRtyoULMYFuwlqcPm37XEuYh9uPFpAvVF64AERFPTovc1DA0wXcL3LwdFGX1d83TiRDBOK21GwGdvzifi92cuUpbj2t67duWde4dBeBDBmAenUt8PN7WKPHikbjmQqWhwlco4AXC4SGAbO/NmHMeBOmz/bDF6P81CdoXtxkNo0CYMDLB4HbCsgf5Xv3bKuXWHBpm9N1KYULWexeNeQYTtf1QXLO9PyzFvTrE4WPe5rQv7cZbduYERSYnBKY1xUC+fJFIzDA9kxFtTco8VK5kSyB3XuMOPvfwwsHEZHAT+tMiAhPVjHMTAGPEmDA61Hd5VuVDQ4C5GpcwlbnyBGdMCnNt9OlA1552YwA/4dVKVQwGs9qgdXDFK65k4D0VaGCBmTM6E61Yl3iCkiw+79WZhQpHBP4ynO/dg0LypZxv78Bcevt7uvn7NyRRD49u3z1YRDs7m1g/SiQXAFfCXiT68L8biJQvaolXk1k7GXVF93zxa7iM9HqqmG/Hkb0+9CCd98xQ4L2eA3gBgUokCwBGXPd7m0zJnzhh15dLaheLf7fhGQVxsxKwN6FBNmRWLrs40QBTxdgwOvpPejl9X+ukkXd4umV+ha8+ooZ3Tub8Xgp933B8/MD5Kph5sxe3jFsngcLsOq+M9ZsrQAAEABJREFULvBkGdu/oQXyR/NHUnz9geHl7WfA6+Ud7A3Nk1s8SeArV1Cz8FervKFL2QYKUCANBUoUj8bbb5pRoXw0SpWwoHZNC978nzkNa8RTU0B/AbsBr/6n5RkoQAEKUIACFEgrgWKPRaNJIzPeaG2BDB1LF5xWNeF5KeAaAQa8rnHmWShAAc8UYK0pQAEKUMALBBjwekEnsgkUoAAFKEABClBAXwHPLp0Br2f3H2vvAwLya0i/HzBA7p156bIPNJhNpAAFKEABCjhZgAGvk0FZHAWcKXDqtAHjJ5mwYpUJa9cbMXWGHxL++pwzz5fasng8BShAAQpQwB0FGPC6Y6+wThR4ILBrtxFyQ/gHm2rx804jLLZ3FVL7OKMABShAAbcQYCXcTIABr5t1CKtDgbgCV6/G3YpZj4wAZJhDzBbnFKAABShAAQo8SsBrA16LJRqXrt5AVMLLY0mIXLxyQ7tyZvsrXlKG7AuXHxxP4njuokCyBBzInDOnbSb/ACBzJtvHqW1OplCAAhSgAAUoIAJeGfBu330Iz73SEbVf64Wna7fHklXbpK2JTt8uXY96rfvgjc7DUL1ZN4ydsSQ276wFq1UZdVr2QoWX3kOvIVO0q2v3Y/dzhQJ6ClSpbIH8nHLcc1R7wQKjVz5z47aS6xSggC8JsK0U0FvA6142Q8Mi0PvTaejSrikObf4KE4Z1xdAxc3Huop3PhjXdYyf+xcgpCzHso/bYsnQcvpnYH18tXINDf5zS9gJZMmfAV2M/wv51M7F8zmfYd/BPLF+7Q+3jjAJ6CxQrGo0eXc3qBvH161nQ6f0odZN4vc/L8ilAAQpQgALeJOB1Ae/eA8cREhqG1o1rwU+7NFan6jMoXCA3tu8+aLff7oWEqvQ8ubKq5WOF8iJblow4ey7m/k+vNayB5ys8geCgAJR8rABqVCmPn389pPJy5koB3z2XDF+oUD4alZ+zIE9u33VgyylAAQpQgAIpFfC6gPfytZsqwA0I8I81KVY4Hy5duRm7HXelfJniqPBkSTR/dzDmLduAad+uRI5smVG9Srm42dR6ZJQZO/cdQZlSRdW2zAwGQPcJD/654lw8R6r7U3pLY0x1Obo/rrRK+vo52FfwmMcptH/aQ9Zj6qvrc0uDcOfyta6y20+SzokCaSXgdQHvnbv3kS44KJ5nYGAA7t4LiZdm3ZDAuNrzTyFvrmxYvXE3Js9ZjmrPP62VEWjNErv8bPy3WjmhaNPipdi0PFmDofeULWNMXQL8jLqfS++2+EL50k/ZMweyr1zw3Ejt48nfZED2zEHsKw/oKz+tr3KwrzzisWoyGpDTTl/FvnByhQJpIOB1AW+mjOnVkIa4luHhEciYIV3cpNj1HXsOY/ysZZg/ZSAWzxiMmaN647vlm/H96u2xeWRl6twVWKalzRnXF7lyZJEkNV28EQq9p+t3w9W5IiItjp6L+VzQL4n1e0SUBdduh7MP0rAPEuubhOmR5mitr8LYVx7QV1FaX129zb5K+Bh2x22zJRpXbtn2lXoh44wCaSTgdQFv7hxZcebcZURGRsWS/vXPOeR5MEY3NvHBym+H/4IMecj0ICB+oVJZPFu+NCRdssjtzUZNXYSvF6/D0plD8GTph8MZZD8nClCAAhRwZwHWjQIUoADgdQFvpXKlVb8uXLFZ3YN3047f1B0aqleOGZMrd1lo8d5gFRRLxpKPFcSpMxcgV3qjo6Nx9vwVbNt1EE+ULCK78cmoOZi7ZB3GDumMzJky4Pyla2qSe/OqDJxRgAIUoAAFKEABCri1gNcFvOmCAzFpeHd1qzG5B2/3QZMwsEcbFMibU3WE3JXh+MkzCAuPUNsv13wWcguzz8bPw7MNOqJtj8/x3hsN8Ubzumq/BMiy8kHfMXipVe/Y6fzFa5LMiQIUoAAFKEABClDAzQW8LuAV71ovlMfhzXOwYdFoHNw4G62b1JZkNdWsUh7Hts1FqWIF1bbRaEDHtxpj/cJRWPn1Z9i0eCx6vNcC/n4mtV/SJX/CSW51pjJwRgEKUMB7BNgSClCAAl4p4JUBr/SUyWRE/jw54O/vJ5sOTfm0/BIAO5SZmShAAQpQgAIUoAAFPEIg+QGvRzSLlaQABShAAQpQgAIUoECMAAPeGAfOKUABCiRbgAdQgAIUoIBnCDDg9Yx+Yi0pQAEKUIACFKCAuwq4fb0Y8Lp9F7GCFKAABShAAQpQgAKpEWDAmxo9HksBCjguwJwUoAAFKECBNBJgwJtG8DwtBShAAQpQgAK+KcBWu16AAa/rzXlGClCAAhSgAAUoQAEXCjDgdSE2T0UBxwWYkwIUoAAFKEABZwkw4HWWJMuhAAUoQAEKUMD5AiyRAk4QYMDrBEQWQQEKUIACFKAABSjgvgIMeN23b1gzxwWYkwIUoAAFKEABCiQqwIA3URruoAAFKEABCniaAOtLAQrYE2DAa0+FaRSgAAUoQAEKUIACXiPAgNdrutLxhlhz3rhpwKXLgNliTeGSAhSgAAUoQAEKeJ8AA17v69NHtuimFuhOnuaH8ZNMmDrDD6PG+uHEX3woPBKOGShAAW8TYHsoQAEfEWCU4yMdHbeZW3824srVhykhIcCqnwwPE7hGAQpQgAIUoAAFvEiAAe+jOtML91+8ZBvc3rlrwN27XthYNokCFKAABShAAZ8XYMDrgw+B4KBom1YbtBg4MMAmmQkUoAAFYgW4QgEKUMBTBRjwemrPpaLeZcvaBrxlnohGQGAqCuWhFKAABShAAQpQwE0FnBzwumkrWa14ApUqWNCyhQXlnorG46UtqF/PgiavmuPl4QYFKEABClCAAhTwFgEGvN7Sk8lohwxfKPuEBc2amNG6pQWVn7MgwD8ZBTArBSjwaAHmoAAFKEABtxFgwOs2XcGKUIACFKAABShAAe8TcIcWMeB1h15gHShAAQpQgAIUoAAFdBNgwKsbLQumAAUcF2BOClCAAhSggH4CDHj1s2XJFKAABShAAQpQIHkCzK2LAANeXVhZKAUoQAEKUIACFKCAuwgw4HWXnmA9KOC4AHNSgAIUoAAFKJAMAQa8ycBiVgpQgAIUoAAF3EmAdaGAYwIMeB1zYi4KUIACFKAABShAAQ8VYMDroR3HajsuwJwUoAAFKEABCvi2AANe3+5/tp4CFKAABXxHgC2lgM8KuDTgDQ2LQGSU2Wex2XAKUIACFKAABShAAdcL6B7wRpnNmPrNSlRt0hUVX+6AdVv2qFZ+0HcMug2aqNY5cyMBVoUCFKAABShAAQp4mYDuAe8ve45gytfLUaNKeRTImzOWr1mD6ti843fcvns/No0rFKAABShAAb0FQkKBlatNGDXWhC9G+2Hx9ybcum2wOS0TKEAB7xHQPeBdtHIz/te0NoZ91A6FC+SOlXvqicfU+oVL19SSMwpQgAIUoIArBDZtMeK33w24e8+AkBDg2DEDVv1kdMWpeQ4KUCCNBHR/hv/1zzmULFYw0eYFBPgnus/9d7CGFKAABSjgaQJ//217NffvUwZYLJ7WEtaXAhRwVED3gPepx4vhp02/an9IouPVacmPW9V23GEOKoEzClCAAhTwPAHWmAIUoIAbC+ge8HZ8uzH2HfwTDd/qh+Mnz2DD9n3o2G8cZsxbhR7vtUAgr/C68cODVaMABSjgfQLFi0fbNKp4sWgYdX9FtDktEyhAARcJ6P70LlWsIH74ahiKFsqLsPBIbNl5AJeuXMfQ3u+gfetXXNRM29NERETi8tWbiI62/cNnmxsICQ3D7Tv8gp09G6ZRgAIU8CSBOrUseKZCNDJmiEa6dECZMtFo9IrFk5rAulKAAskU0D3glfpI0DtlRA/sWzsdR7d+jeVzPkOLhtW1d9O246gkv56TBLhTv1mJ8i+9h1qv9US1pt1w6I9TiZ5SguKuAyagerMeqPP6h2jTdYS6Up3oAdxBAQpQ4JECzJCWAumCgcYNzejTy4x+vaPwenMzsmR27OJHWtab56YABVIuoHvAe+rMBRw4ejJ2Onjs79h1SZf79Ka8+sk/Us4vt0mbN6k/Dm6cjSYvV0XPwZNtxhhbSx4zfTHCtavBu36cjN2rp6BIwTyYMHuZdTeXFKAABShAAQpQgAIpFXDRcboHvONnLsWbXYYnOt0PCXNRU2NOs+WXA6hcsQwqPFkS/v5+aNPiJTW04cSpszEZEswvXL6OnNmzqLx+JpN2XAnInScSZOMmBShAAQpQgAIUoICbCuge8Pbv9iZWfj3cZipbqijq13oOGeSzJRfiXLxyHUW1q7TWU+bKkUWtXrl2Sy0Tztq1qo8V635Rvwq3ddcBzFqwGp3ebpIwG7cpQAH9BFgyBShAAQpQIFUCuge8eXNnR/Gi+W2mLu2aYu2WPerLYKlqQTIPvnP3PoICA+MdlS44CPfkp3fipcZslCpeSP1ghtFgxEfDZuDuvRCUK1M8Zqc2DwowQe8pwC+mm4xGg+7n0rstvlC+1k0I9Deyr1zw3Ejt48lgAPvKA/pJ+pl9pf9rjTg7Y9KeVnafV9pLJv+nWoAFpFQgJpJK6dGpOM76q2t//3s+FaUk/9BMGdMjPCIi3oFyB4bErjT3GjwFDetWwfhPu2DL0rGoVO5xtO40DNaxx+kCTdB7CvI3qfoatd7S+1wsP/X9adQ6KlDrM1qm3lJvQ5MWRQUG+On+HNa7Hb5QvlHrqyD2lUc8Vg1GA4IDbZ9X6oWMMwqkkYAWQul75qvXb+Hs+cvxpmMn/lX34ZUzP1Y4nyxcNuXNlR3//ncp9nzWoQzWoQ2xO7QVGV989MRplC4W80txGTOkQ/vWDdRV6dNnL2o5gBt3I3Sf7oRGqnNFRUXrfi5XtMfbzxFltuBOSGSa9ZW3+zqzfVGWaNy5r/9z2Jl19tWyzFpf3WZfecTfFYvWV7fu2T6v1AsZZxRIIwHdA95Px36D+m/0jTe1fH8INmzfj486t0Zm7YqrK9te68Xy2LnvKH4/chKRUWZ8u2w9cufMilLFCqlqzF2yTt16TDbSpwuC/BLcklVbcfvufURGRmHN5l/VEIeihfJKFk4UoAAFKEABCrinAGtFgVgBY+yaTitd2jXDV2M+ijctmvaJusXX26/V0+msiRcr428/eOtVLagdjnJ12mPxyq0YM7gTjNpHMHLU1Wu38OffD+/YIEMZAgL8UaVRZ1R5tQv+0a7sjhzwPvxMJsnOiQIUoAAFKEABClDAzQV0D3hLFSuI5595It705OOPpVnAaDAY0FULwn9bPxMbF43Gnp+moXzZErHd1KdTK/UDGdaEx0sUxsRh3bB3zXRsWjwG077oCam/dT+XHi7A6lOAAhSgAAUo4PUCugS8MmZXxuk6MpnNafNzjkGBAciXJ0fsld1H9bQMb8icKf2jsnE/BShAAQpQwCMFWGkKeLOALgHvqKmLION0HZnuJXI7MG9GZ9soQAEKUIACFKAABVwnoEvA26dTayydOcShKbHbgbmOgCpCYM0AABAASURBVGdyXIA5KUABClCAAhSggOcJ6BLwFsqfC0+ULOLQZDLpUgXP6wnWmAIUoAAFPEeANaUABTxKwCXRptwGbPysZRg+YZ7NFBoW/0cgPEqPlaUABShAAQpQgAIUcHsB3QPenzb/ig59RmPBD5vw3fLN6h64+w+dUOvrtu6F2Wx2e6QUVpCHUYACFKAABShAAQq4gYDuAe/SVdtQr0YlbFoyRjV39ug+WD7nM7z3RkMUyJcLGdIHq3TOKEABClDAWwXYLgpQgAJpK6B7wHvx8nVUqVgWGdOnUy29euO2Wjao/TwO/3EKp89eVNucUYACFKAABShAAQpQQA8B3QPewAB/3L0Xou53Kz/iIMMZpCFRUVGywB1tn6xwogAFKEABClCAAhSggB4Cuge8BfPnwv7DJ1Tda71YAWNnLMHIKQsx4IvZyJYlI8qUKqL2cUYBClCAAkqAMwpQgAIUcLKA7gFvl3eaomWjmqra77ZugIZ1K+PbpeuRIX06fDnwA/iZTGofZxSgAAUoQAEKUIACFHgo4Lw1XQLeE6f+w5faVdxjJ/6FDGOoXvlpVeOAAH+MHPA+jmz5GvMm9UflimVUOmcUoAAFKEABClCAAhTQS0CXgFcq+412FVd+WrjBm30xZ9EayJfXJF0mo9EgC04UoAAFUi3AAihAAQpQgAKPEtAl4C1VrCD2r5uJsUM6oVjhfBgzfQnqvP4h2vUciZXrd6ovsT2qYtxPAQpQgAIUoAAFKOCwADMmIaBLwCvnCw4KQL0az2LS8O74ZeUkDP6wLSIio9D/81l4vmEnfDRsOnbsOQKLJVqyc6IABShAAQpQgAIUoIAuAroFvHFrmzVzRrRsVAPzJw/Auu++RI/3WmDrroP4oO8Y3L0fEjcr1ylAAT0FWDYFKEABClDABwVcEvBaXa/duI1f9h7Bpp9/Q0homEo2GDieV0FwRgEKUIACFKCAywR4It8S0D3glcB2zeY96NhvHKo3647Pxs9Twp/0fAs7VkxCpgwxv8CmEjmjAAUoQAEKUIACFKCAkwV0CXijzGY1PrffiJmoVP8D9Bk2DSdOnUXntk2w+tvPsXjGYLzeuBbkhyec3B4WRwEnCrAoClCAAhSgAAW8QUCXgPfwH/+o8bmbd/yOlq/WVPfc3bR4LDppAW/RQnm9wY1toAAFKEABCviOAFtKAQ8X0CXgzZ0zK8Z/2gU7VkzE4F5vo8KTJcF773r4I4XVpwAFKEABClCAAh4qoEvAmz9PDtStVhFBgQEeysJqp0CAh1CAAhSgAAUoQAG3FNAl4HXLlrJSFKAABShAAZcI8CQUoIC7CTDgdbceYX0oQAEKUIACFKAABZwqwIDXqZyOF8acFKAABShAAQpQgAKuEWDA6xpnnoUCFKAABewLMJUCFKCA7gIuCXj3HDgOuSdv607DsH33IdWo0dMX4+tFa9U6ZxSgAAUoQAEKUIACFNBLQPeA99iJf9Gu50js1YLev0+fx52791Vb8uXOAQl6w8Ij1HaSM+6kAAUoQAEKUIACFKBACgV0D3gXrdyC2lUrYPOSsShftnhsNSs/84RaP3/xqlpyRgEKUIACjxZgDgpQgAIUSL6A7gHvtl0HUKNyORgMhni1y5wpg9qOiIxSS84oQAEKUIACFKAABSjgoECysuke8JYqXggyhjdhrXbtO6qSCuTNqZacUYACFKAABShAAQpQQA8B3QPe11+tidUbd2P4hHm4dOUGTp4+h7mL16Hv8Blo8vKLyJghnR7tYpkUoAAFABpQgAIUoAAFNAHdA9661Spi8IdtsWLdTpw6cwFfLVyDUdMW4ZXaz+Ojzq21KvA/BShAAQpQgAIUoICeAr5etu4BrwC3bFQDO1dOwqpvP8fiGYO19cn4ctAHyJwxvezmRAEKUIACFKAABShAAd0EdA94+42YiRETF+D0f5fwWKG8KFuqKLJkjvnCmm6tYsEUoEAKBHgIBShAAQpQwDsFdA94y5cpjuVrd6BZ+0F4s8twNZ43NIz33vXOhxNbRQEKUIACFPACATbB6wR0D3hfb1wLu1ZNweQR3ZFVu7IrX1ar1rSb+tGJf85e9DpQNogCFKAABShAAQpQwL0EdA94pbn+fibUrFIek4Z3x9Zl49G2ZT31s8KN3voYtx/88prk40QBDxJgVSlAAQpQgAIU8BABlwS8VotjJ/7FrAWrMPWblSrphUplEeDvr9Y5owAFKEABClDAEwVYZwq4v4DuAe/tO/exaOUWNG03EC3fH6JuT/Z+m0ZYu+BLzBzVG8FBAe6vxBpSgAIUoAAFKEABCnisgO4B78CRszFs3LfIni0zxg3tgl0/Tka39s1RKH8uXdEslmhcunoDUWazU84TEhoGCd6dUpgPFsImU4ACFKAABShAgbQS0D3gbfzyi9rV3JGYPboPXqpeEf7+frq3dfvuQ3julY6o/VovPF27PZas2pboOeUOEmVqtEXCqdeQqeqYy1dvouuACajerAfqvP4h2nQdgeMnz6h9nFGAAhSgAAWSKcDsFKBAGgjoHvDWqfqMdjU3t8uaJrc86/3pNHRp1xSHNn+FCcO6YuiYuTh38ardOsgvwa2ZPxJxp6eeKIbsWTOq/GOmL0Z4RKS6Mr179RQUKZgHE2YvU/s4owAFKEABClCAAhRwfwFdAt7fj/yF198fiotXbmDGvFXo3H98opMMFXAm094DxyFltm5cC34mEyTgLlwgN7bvPmj3NBnSB0P2W6fbd+7h8B+n0KZFPZX/wuXryJk9i7oyLeVVeLIE/vrnnNqn24wFU4ACFKAABShAAQo4TUCXgBcwwGiKKdpgAIzaLLEJTv53+dpNFcAGBDy8+0Oxwvlw6cpNh840duZStNKCZesY43at6mPFul/QbdBEbN11ALMWrEant5s4VBYzUYACFKBA6gR4NAUoQAFnCMREpc4oKU4ZchV04dRByJsrGzq82Ujdf1fuwWtvShccFOfI1K/euXsfCcsMDAzA3Xshjyx8x54j2HfwT1Vna+ZSxQupANpoMOKjYTNUOeXKFLfuRub0/rpPGYL81PlMJoPu53JFe7z9HH5GAzIE+7GvXPDcSO1jySR9lU7/53Bq68nj/WHU+ioj+8oj/q4YtYtcmez0lXoh44wCaSRg1Pu8Q0bPxYIfNtqc5sSp/1DrtZ64efuuzb7kJcTPnSljejWkIW5qeHgEMmZIFzfJZt1stmDsjMVo37oBcufMGru/1+ApaFi3CsZ/2gVblo5FpXKPo3WnYbF3f4g0R0PvKcoSreoTrS30PhfLT31/WrTeinLB44J9lfq+itaeVFFRFt2fw+yr1PcV2Fce8ziNhvS37fNK+9PI/xRIMwHdA97rN2/jjp2rq9myZITcAeHSlRtObXzuHFlx5txlREZGxZYrY27z5HoYxMbuiLOybtteNTb3nVb1Y1Pvh4Th6InTKF2soEqToFkCYhkjfPrBzyKHhEVB7ykswqzOL7da0/tcLD/1/Sn9JH1Gy9Rb6m0o7yW9qq9c8PdI7z5JrHzpq1Dtb2Fi+5nuPs837b0JQsPNNq+N6oWMMwqkkYBuAa/cuku+/HXz9j1cuHRdfRFMtmX6/chfmDl/lWpykYJ51dJZs0rlSquiFq7YrK7Cbtrxm7pDQ/XK5VT6voN/osV7g1VQrBK0WUREJORuDJ3faYqsmWPuzqAlI326IBTImxNLVm3F7bv3VRC9ZvOvaohD0ULOrbecjxMFKEABClCAAhSgQOoFEpagW8Dboc9o9dH/gaMn8cOan9W6DAWQSe5lu27rXvTp1Mrpv7SWLjhQjRkeOWWhugdv90GTMLBHGxW4SuPvhYSq++iGhUfIppp+WLsDd++Fok3zumo77kyGMsgX4Ko06owqr3bBP9qV3ZED3ld3gIibj+sUoAAFKEABClCAAu4poFvAO3d8P3w/+1NUeLIkWr5aU63Ltkw/fjMC23+YiLYtX9ZFpdYL5XF48xxsWDQaBzfORusmtWPPU7NKeRzbNhelHgxTkB1yV4Z9a6fbHef7eInCmDisG/aumY5Ni8dg2hc98eTjj8lhnChAAY8WYOUpQAEKUMBXBHQLeIsVyY/SxQtheL938ULFssiRLbPaljS5TdjOfUfVlVa9oE0mI/LnyaHun+uMc8jwhsyZ0jujKJZBAQpQgAIUoAAF3EfAB2qiW8BrtVu6ahuGjp2LwDj3xZV9u/YfhQx7iDLHfCFL0jhRgAIUoAAFKEABClDA2QK6B7zyy2fNX6luM1ygZaMauHHrLs5fvObsNrE8ClDA+QIskQIUoAAFKOCxAroHvKFh4Qjw97MBin6QIvsfrHJBAQp4sECU9mHN3v1GLF5qxLIfTDh0xCC3TvXgFrHqFKAABewJMM0TBXQPeB8vWRhyi7C4d0UQqCU/bpUFCubLpZacUYACni2wdq0Rq9cYcey4EYePGvD9chN27NT9T4xno7H2FKAABSjgEgHdX406vNFQDV14pl4H9BoyFXK7sHqt+2Desg1o16qButetS1rKk1DAhQK+diqLBdoVXds/J0eO2ab5mg3bSwEKUIACaS+g+6uR3K1h2ayhqPrck9ix5zC+XbpefYGtf7c30P295mkvwBpQgAKpFrh9x4CISNtibt+yTWMKBSjgUwJsLAXcQkD3gFdaKfeynT7yQ8i9bo9s+RpyH943mtXljzcIDicKeIFA1izRyJbVOjL/YYMee0y79Ptwk2sUoAAFKECBNBFwScC758Bx9BsxU/3amlzllZaOnr4YXy9aK6ucfF2A7fcKgUYNLciY4WHQmy17NGrVYMDrFZ3LRlCAAhTwcAHdA95jJ/5Fu54jIbcn+/v0edy5e1+R5cudAxL0Jvwym9rJGQUo4HECxYpG48MeZnT5IArdOpvRvZMZuXJ6XDNYYQqkqQBPTgEK6COge8C7aOUW1K5aAZuXjEX5ssVjW1H5mSfU+vmLV9WSMwpQwPMFjNpflFy5gBza1V2DwfPbwxZQgAIUoIB3CGgvT/o2ZNuuA6hRuRwMhvivfpkzZVAnjoiMUkvOHBVgPgpQgAIUoAAFKECB5AjoHvCWKl4IMoY3YaV27Tuqkgrk5WeeCoIzClCAAhRIngBzU4ACFHBQQPeA9/VXa2L1xt0YPmEeLl25gZOnz2Hu4nXoO3wGmrz8IjJmSOdgVZmNAhSgAAUoQAEKUIACyRfQPeCtW60iBn/YFivW7cSpMxfw1cI1GDVtEV6p/Tw+6tw6+TVO3hHMTQEKUIACFKAABSjg4wK6B7zi27JRDexcOQmrvv0ci2cM1tYn48tBHyBzxvSymxMFKEABCuguwBNQgAIU8F0BlwS8whsQ4I/HCuVF2VJFkSVzzBfWJJ0TBShAAQpQgAIUoAAF9BSIF/A660S/HzmJ198fiotXbmDGvFXo3H98otOQ0XOxc99RREaZnXV6lkMBClCAAhSgAAUoQIFYAV0C3tjStZWjf/5O+V/HAAAQAElEQVQD+cEJbdXu/+Mnz6BDn9GYv2yD3f1MpAAFKJAGAjwlBShAAQp4kYAuAW+FJ0uosbp5c2VTVE3qv4gpI3rYnWRMb5d2TbF09TaVlzMKUIACFKAABShAAXcR8I566BLwxqX54K3G6o4McdMSrufOkRVXr99OmMxtClCAAhSgAAUoQAEKpFpA94C3TKkiKJQ/t7r/7tZdB7B5x+9qPTo6OrbyxYrkx+f934vd5goFKOBZAqwtBShAAQpQwJ0FdA94790PxZtdhqPJOwPRpf8EdBs0Ua236ToCZ89fVjZPP1EMdao+o9Y5owAFKEABClCAAh4qwGq7qYDuAe+E2ctw4OhJfPhBS8yfPABLZw5Bn06tcOHyNRUAR5l5dwY3fWywWhSgAAUoQAEKUMArBHQPeNdt3Qv5tbV2rRqgfNkSeKJkEbRt+TJ6dWipfnntnzMXvQKSjaCAwwLMSAEKUIACFKCASwV0D3hLFS+EPA/u1hC3ZS8++6TaDAsLV0vOKEABClCAAhTwLQG2lgKuEtA94H2tYQ18/9PPuH33frw2nTpzQW0XK5JfLTmjAAUoQAEKUIACFKCAHgK6BLy9hkxFmRpt1dRryBSEhIahSqPOatua/la3Eao9ZotFLTmjgH0BplKAAhSgAAUoQIHUCegS8L5S+3n06djKoSkwwD91LeDRFKAABShAAV8QYBspQIEUCxhTfGQSB9auWgFtX3/ZoYkBbxKQ3EUBClCAAhSgAAUokGoBY6pLeEQBR47/g++Wb8YXk7/DmOlLsGz1dpw+yzszPIItpbt5HAUoQAEKUIACFKBAAgHdAt7bd+6jxyeT0arjpxg+YR7mLduAOYvWYPDor9HwrY8xcspC8B68CXqDmxSgAAUo4CQBFkMBClDgoYBuAe/Qsd9g48/70a19c2xdNh5Ht36NQ5u/wtoFI/G/prXx7dL1mLNwzcOacI0CFKAABShAAQpQgAI6COgS8Motx9Zv24vP+rbH+20aIVeOLDAYDPAzmVAof24M6N4Gb79WDxNmf4/IyCgdmuVYkcxFAQpQgAIUoAAFKOD9AroEvH+fPqfkGtatopb2Zs0bVlfJZ85dVkvOKEABClAgzQR4YgpQgAJeLaBLwHs/JAzpgoO0K7qJF58+XZCClXv0qhXOKEABClCAAhSgAAUooINA4hFpwpMlY7t4kfzqxyaOnzyT6FG79x9T+x4rnE8tOaMABShAAQpQgAIUoIAeAroEvKWLF0LhArnRc/AU/Pn3WZt679x3FCMmLkCtF8ojQ/pgm/1MoAAFKODOAqwbBShAAQp4loAuAW9AgD9Gf9IRN27dRfN3P8Hr7w9FvxEz0WvIVLz6dn906DMa2bJkxOAP23qWFmtLAQpQgAIUoAAFKGAV8JilLgGvtP6JkkWwackYdHyrMWS87s69R3Dw2Enky5MdfTu3xo/fjECObJnBfxSgAAUoQAEKUIACFNBTQLeAVyqdOWN6dGnXFHPG9cWOFZOwZek4TB/5Id56rR70/klhiyUal67ecOqPW8gt1M5fuoaIiEhpHicKUMARAeahAAUoQAEKpLGArgFvWrVt++5DeO6Vjqj9Wi88Xbs9lqzalmhVlq/dgTI12tpMMvzCetDpsxfRpusIlKv7Ll5q1Rs/aMdY93FJAQpQgAIUoAAFHBFgnrQT8LqANzQsAr0/naauLMsvu00Y1hVDx8zFuYtX7SrXrVYRa+aPjDc99UQxZM+aUeW/fPUmGr71MXLnzIp5k/pj/7qZqFejktrHGQUoQAEKUIACFKCA+wt4XcC798BxdUu01o1rQX7ZrU7VZ9QdI7bvPmi3N+QuEXJHCet0+849HP7jFNq0qKfyf7NknfqC3RcDOqDCkyURHBSArJljgmGVgTMKOFWAhVGAAhSgAAUo4GwBrwt4L1+7qQJcuVOEFatY4Xy4dOWmdTPJ5diZS9FKC5YL5c+l8v2y9wjy5c6B3kOnqbtNDBk9FzI2WO3kjAIUoAAFKEABfQRYKgWcKOB1Ae+du/fVr7zFNQoMDMDdeyFxk+yu79hzBPsO/okObzaK3X/qzAV1l4naL1ZAu9b1cfTEabTrORLyBTbJlCtLEPSesmYIkFPB38+o+7n0bosvlC/9lC1jAPvKBc+N1D6e/E0GZMsUyL7ygL7y0/oqO/vKIx6rJqMBOTLbPq/UCxlnFEgjAa8LeDNlTI+EP1ccHh6BjBnSJUlsNlswdsZitG/dQI3XjZv5jWZ10eilKqhX41mMGvQBzpy7jH/OXlRZbtwNh97TnZCYu0JEaXXU+1weVr7u9inxiIqy4Pb9SLesW0ra483HRJqjcfteBPvKBX/HUvs4itL66hb7yiMeq2ZLNG7etX1eqRdNziiQRgJeF/DmzpFVBaTWK7Di+tc/55AnV1ZZTXRat20vJN87rerHy/N4icI4e/5ybJrFYlHrEZFRail/hPWe5I+HnCw6GtD7XCw/OtXGWjdB+oyWqbfU21CeV+wr9+8neRywrx7VT+6zP7G+knROFEgrAa8LeCuVK60sF67YrAUuZmza8Zu6Q0P1yuVU+r6Df6LFe4NVUKwStJncV3fM9MXo/E5Tmy+kNaj9HOYsWgO5/+7tu/cxb9lG9SW24kXya0fyPwUoQAEKUIACFKCAuwt4XcCbLjgQk4Z3x8gpC9U9eLsPmoSBPdqgQN6cqi/uhYTi+MkzCAuPUNsy+2HtDty9F4o2zevKZrzpzWZ18VyFJ9T9d6s06oyf9xzClBE91N0a4mX0gA1WkQIUoAAFKEABCviigNcFvNKJtV4oj8Ob52DDotE4uHE2WjepLclqqlmlPI5tm4tSxQqqbZm1alwL+9ZOtzvOV+72MPqTjti9eio2LR6DzUvGQu7TK8dxogAFKEABjxRgpSlAAR8T8MqAV/rQZDIif54c8Pf3k81UT5kypEPe3NlhMBhSXRYLoAAFKEABClCAAhRwnYDXBrypJmQBFKAABShAAQpQgAJeIcCA1yu6kY2gAAUooJ8AS6YABSjg6QIMeD29B1l/ClCAAhSgAAUoQIEkBZwU8CZ5Du6kAAUoQAEKUIACFKBAmgkw4E0zep6YAhTwSgE2igIUoAAF3E6AAa/bdQkrRAEKUIACFKAABTxfwJ1awIDXnXqDdaEABShAAQpQgAIUcLoAA16nk7JAClDAcQHmpAAFKEABCugvwIBXf2OegQIUoAAFKEABCiQtwL26CjDg1ZWXhVOAAhSgAAUoQAEKpLUAA9607gGenwKOCzAnBShAAQpQgAIpEGDAmwI0HkIBClCAAhSgQFoK8NwUSJ4AA97keTE3BShAAQpQgAIUoICHCTDg9bAOY3UdF2BOClCAAhSgAAUoIAIMeEWBEwUoQAEKUMB7BdgyCvi8AANen38IEIACFKAABShAAQp4twADXu/uX8dbx5wUoAAFKEABClDASwUY8Hppx7JZFKAABSiQMgEeRQEKeJ8AA17v61O2iAIUoAAFKEABClAgjgAD3jgYjq8yJwUoQAEKUIACFKCApwgw4PWUnmI9KUABCrijAOtEAQpQwAMEGPB6QCexihSgAAUoQAEKUIACKRdwRcCb8trxSApQgAIUoAAFKEABCqRSgAFvKgF5OAUoQAHHBZiTAhSgAAXSQoABb1qo85wUoAAFKEABClDAlwVc3HYGvC4G5+koQAEKUIACFKAABVwrwIDXtd48GwUo4LgAc1KAAhSgAAWcIsCA1ymMLIQCFKAABShAAQroJcByUyvAgDe1gjyeAhSgAAUoQAEKUMCtBRjwunX3sHIUcFyAOSlAAQpQgAIUsC/AgNe+C1MpQAEKUIACFPBMAdaaAjYCDHhtSJhAAQpQgAIUoAAFKOBNAgx4vak32RbHBZiTAhSgAAUoQAGfEWDA6zNdzYZSgAIUoAAFbAWYQgFfEGDA6wu9zDZSgAIUoAAFKEABHxZgwOvDne9405mTAhSgAAUoQAEKeK4AA17P7TvWnAIUoAAFXC3A81GAAh4pwIDXI7uNlaYABShAAQpQgAIUcFSAAa+jUo7nY04KUIACFKAABShAATcS8NqA12KJxqWrNxBlNrsRN6tCAQpQwJcE2FYKUIAC7iHglQHv9t2H8NwrHVH7tV54unZ7LFm1LVHt5Wt3oEyNtjZTryFTbY4ZN3OpynfnXojNPiZQgAIUoAAFKEABCrinQJoHvM5mCQ2LQO9Pp6FLu6Y4tPkrTBjWFUPHzMW5i1ftnqputYpYM39kvOmpJ4ohe9aM8fJLYDz7u5/ipXGDAhSgAAUoQAEKUMD9Bbwu4N174DhCQsPQunEt+JlMqFP1GRQukBvbdx+02xsZ0ger/ZJHptt37uHwH6fQpkW92Pz7Dv6JERMXYPQnHWPTuEIBClDAyQIsjgIUoAAFdBLwuoD38rWbKoANCPCPJStWOB8uXbkZu53UytiZS9FKC5YL5c+lsp05dxmdPh6P8Z92QYmiBVRa3JnRaIDuk8EA9U9b6H4uV7THy88hfaU1Uf/HhXYSPh4MqXKG9k9jTFUZ7AODS/yg/WNfGVxindrHNLR/9vpKS+Z/Cjgo4PxsXhfw3rl7H+mCg+JJBQYG4K4D42537DkCuZrb4c1G6vjbd+6jQ5/R6NnhNbxQqaxKSzjLlTkQek9Z0scE7wF+Rt3PpXdbfKF86aesGfV/XPiCpd5t9DcZkDVTEJ9XLvg7ltq+9NP6Khv7yiMeqyYt2s2e2fZ5lfD1k9sUcKWA1wW8mTKmV0Ma4iKGh0cgY4Z0cZNs1s1mC8bOWIz2rRsgd86sav+vvx9TY3//u3AFX05ZiNkLY8bwjp+1DMdPnlF5Lt0Mg97TjXsR6lwRkRbdz6V3W3yh/IgoC67fCWdf6fzccMZjKdIcjeu39X8OO6Ouvl5GlNZX19hXHvF3xWyJxtVbts8r9ULGGQXSSMDrAt7cObJChiFERkbFkv71zznkyRUTxMYmJlhZt20vJN87rerH7ileJD+6v9scWTNnQBZtyvQgaM6SKT0C/P1i83GFAhSgAAUoQAEKpJEAT+uAgNcFvJXKlVbNXrhis7oH76Ydv6mrtNUrl1Pp+w7+iRbvDVZBsUrQZhERkRgzfTE6v9NUC24f3p2hmBbwyvAG69SyUU0tN9D29fqQfWqDMwpQgAIUoAAFKEABtxbwuoA3XXAgJg3vjpFTFqp78HYfNAkDe7RBgbw5VUfcCwlVwxHCwmOGCUjiD2t34O69ULRpXlc2OVHA+wTYIgpQgAIUoIAPC3hdwCt9WeuF8ji8eQ42LBqNgxtno3WT2pKspppVyuPYtrkoVayg2paZ3JVh39rpjxznW7xofnWsdWiDHMuJAhSgAAUoQAHPEWBNfVPAKwNe6UqTyYj8eXLAn2NthYMTBShAAQpQgAIU8FkBrw14fbZH2XAnCLAIClCAAhSgAAW8SYABrzf1JttCAQpQgAIUcKYAy6KAlwgw4PWSjmQzNlRxBwAAEABJREFUKEABClCAAhSgAAXsCzDgte/CVMcFmJMCFKAABShAAQq4tQADXrfuHlaOAhSgAAU8R4A1pQAF3FWAAa+79gzrRQEKUIACFKAABSjgFAEGvE5hdLwQ5qQABShAAQpQgAIUcK0AA17XevNsFKAABSgQI8A5BShAAZcJMOB1GTVPRAEKUIACFKAABSiQFgLuHfCmhQjPSQEKUIACFKAABSjgVQIMeL2qO9kYClDAWwXYLgpQgAIUSLkAA96U2/FIClCAAhSgAAUoQAHXCqTobAx4U8TGgyhAAQpQgAIUoAAFPEWAAa+n9BTrSQEKOC7AnBSgAAUoQIE4Agx442BwlQIUoAAFKEABCniTANsSI8CAN8aBcwpQgAIUoAAFKEABLxVgwOulHctmUcBxAeakAAUoQAEKeLcAA17v7l+2jgIUoAAFKEABRwWYz2sFGPB6bdeyYRSgAAUoQAEKUIACIsCAVxQ4UcBxAeakAAUoQAEKUMDDBBjweliHuXN1b94yYMMmI+YvNGHNOiMuX3Hn2rJuFKAABSiQOgEeTQHPEWDA6zl95dY1DQsHZsw24ZddRvx10oBf9xoxY5YfbmlBsFtXnJWjAAUoQAEKUMDrBRjwen0Xu6aBJ7UgNyQk/rmizMAffxriJ3KLAhSgAAUoQAEKuFiAAa+Lwb31dFev2w9sb9/21hazXRSgAAWSJcDMFKBAGgow4E1DfG86dYli0XabU6Sw3WQmUoACFKAABShAAZcJMOB1GbUDJ/LgLAULRKPK8xYY4lzofapsNB4vbfHgVrHqFKAABShAAQp4gwADXm/oRTdpw8svWdC/bxQ6vGtGvz5RaNHM7CY1YzUoQAFPE2B9KUABCjhTgAGvMzVZFgIDgAL5opEumBgUoAAFKEABClDAPQQ8OOB1D0DWggIUoAAFKEABClDAvQUY8Lp3/7B2FKAABR4twBwUoAAFKJCkAAPeJHm4kwIUoAAFKEABClDAUwQSqycD3sRkmE4BClCAAhSgAAUo4BUCDHi9ohvZCApQwHEB5qQABShAAV8TYMDraz3O9lKAAhSgAAUoQAER8KGJAa8PdTabSgEKUIACFKAABXxRgAGvL/Y620wBxwWYkwIUoAAFKODxAgx4Pb4L2QAKUIACFKAABfQX4Bk8WYABryf3HutOAQpQgAIUoAAFKPBIAQa8jyRiBgo4LsCcFKAABShAAQq4nwADXvfrE9aIAhSgAAUo4OkCrD8F3EqAAa9bdQcrQwEKUIACFKAABSjgbAEGvM4WZXmOCzAnBShAAQpQgAIUcIEAA14XIPMUFKAABShAgaQEuI8CFNBXgAFvKn3zZQ+G3lOOTIGqlgH+Rt3PpXdbfKH8AD8jcmYOZF+54LmR2seTv8mAnFmC2Fce0Fd+Wl/lYl95xGPVZDQgd1bb55V6IeOMAmkkwIA3jeCTf1oeQQEKUIACFKAABSiQEgEGvClR4zEUoAAFKJB2AjwzBShAgWQKMOBNJlhaZb924zZCwyLS6vQ8LwW8QsBiiYbZbLHbFtl36eoNRJnNdvcz0bUC0h/mRPrKtTXh2ZISkNelC5euQfrLXj5J5/PKngzTXC3grQGvqx11O9/Z85fR4M2+qN6sOyq+3AGDvpyDyCi+IOsGnoqCR05ZiDI12sab3uwyPBUl8lBnCkRHR2Po2Ln4dNw3NsVu330Iz73SEbVf64Wna7fHklXbbPIwwXUCSfXVq2/3j/cck+fc1LkrXFc5nilWoOuACep1qW6r3tprVDeMmb4kdp+s8HklCpzcRYABr7v0RCL1+Gz8PJQuXgj7183E6m8/x7qte7Fuy55EcjM5LQXkRbpGlXJYM39k7DR6cMe0rBLP/UBg/ba9qNa0G5at3v4g5eFCrlD1/nQaurRrikObv8KEYV0xdMxcnLt49WEmj17zrMon1VfWlnRr3zz2OSbPt/81rWPdxaULBUoVK4Tlcz7Db+tnYthH7TFn0RocOf6PqgGfV4qBMzcSYMDrRp2RsCq3797Hzn1H0abFSwgOCkDRQnnR5OUXsGH7voRZue0mAhkzpEPhArljpzw5s7lJzXy7GlWfexpLZw1Fw7qVbSD2HjiOkNAwtG5cC34mE+pUfUb13/bdB23yMkF/gaT6ynr2nNkzqz6yPteyZM4A/nO9gLxJLPlYAQQFBkDe7OfOmRW7fzumKsLnlWLgzI0EVMDrRvVhVeIIXLt+S20VyJtTLWVWKH9uXLxyQ1Y5uaGA/JHv//ksjJq6CL8d/ssNa+ibVUoXHAh585E+XbANwOVrN1XwFBDgH7uvWOF8uHTlZuw2V1wnkFRfWWuxVLtSP3DkV5g6dwVk2Jc1ncu0Ezhz7jIuX70JueorteDzShQ4uZMAA1536o0EdblzL0SlxH0hDtTeSd+4dUelc+ZeAmVKFkHT+lVRpGAe/HfxCt7qNgLy8ax71ZK1SShwR/skJV1wkDVZLeV5dvfB808lcOY2AvVqVEK1559Cvjw5sGXnATR/dzCD3jTunfshYejxySRUeLIkXnz2SVUbPq8UA2duJMCA1406I2FVMmVIp5IiI6PUUmbh4RHIliWTrHJyM4FGL1VB13bN0OHNRpg4rBtke/naHW5WS1YnoUCmjOnVkIa46fI8k+EpcdO47h4Cnd9pio5vNUantxtj4dRByJghGJt3/O4elfPBWshY3Z6DJ6u7n0z6rBtMppiwgs8rb3gweFcbYh6Z3tUmr2lNjuxZVFv+u3BFLWX273+XkDcXx4WKhbtP8hH6/ZBwd6+mz9cvd46skI9j476x/Oufc8iTK6vP27g7gL+/H3Jmy4JQ7UKAu9fVG+snn0J27DcWt+/cx7cT+yPuWGo+r7yxxz27TQx43bj/MmtXnipXLIN5yzZC3kWfPnsRP27YhZeqV3LjWvtu1cbNXIpT/55Xt407euI0FvywKfbjPW9V8ZR2yf1cJaA1m82IijJD1uX+oFL/SuVKywILV2xGlLZ/047f1B0aqlcup9I5c62A2WxR/WOvr2S87twl6yD3dZXbM67euBvyXHuu/OOurSTPpn0qEo43O3+GK9du4tOP2uF+aBjOX7oW+x0TPq/4IHE3AQa87tYjCeozoNubOKYFT3IP3oZvfawFuxXxcs1nE+TipjsI/PrbH3i17QCUq9Mer78/VPXV2y3ruUPVfL4O3/+0HeXqvqtuS7Zi3S9qfcW6HcpFviQ1aXh3yH2U5R683QdNwsAebRD3y6IqI2cuEUiqr6QC3y5dr+6XLM+zvsNnoG/n1njmqZKyi5MLBWSM+6kzF9SnI83aD8JLrXqrqWWHwaoWPvi8Uu3mzH0FGPC6b9+omsmtyNYvHIUtS8dh75rpGN7vXcjHeGonZ24lsHjGYPy6eirWLhip7pssfSW363GrSvpoZVq+WhPHts2NNzVrUC1Wo9YL5XF48xxsWDQaBzfORusmtWP3ccW1Akn1ldylZvOSsfh5+USs++5Ldd/kt17jm0rX9lDM2eQWZAmfU7K9Y8WkmAzanM8rDYH/3UaAAa/bdEXSFZE/LunTxf8medJHcG9aCMgXneRFOTgowPb0THFrAfmyTf48OfiG0q17CTAYDMieNRMK5ssFuW8y+M+tBfi8cuvu8anKMeD1qe5mYylAAQpQgAJpL8AaUMDVAgx4XS3O81GAAhSgAAUoQAEKuFSAAa9LuXkyxwWYkwIUoAAFKEABCjhHgAGvcxxZCgUoQAEKUEAfAZZKAQqkWoABb6oJWQAFKEABClCAAhSggDsLMOB1595xvG7MSQEKUIACFKAABSiQiAAD3kRgmEwBClCAAp4owDpTgAIUsBVgwGtrwhQKUIACFKAABShAAS8S8MmA14v6j02hAAUoQAEKUIACFHiEAAPeRwBxNwUoQAEvFmDTKEABCviEAANen+hmNpICFKAABShAAQr4rsCjA17ftWHLKUABClCAAhSgAAW8QIABrxd0IptAAQq4RoBnoQAFKEABzxRgwOuZ/cZaU4ACFKAABShAgbQS8LjzMuD1uC5jhSngGwJ7D/yJLb/8nui0ffchuxBnz1/B8rU7cPP2Xbv7EyaGhUegdadh2LHncMJd3KYABShAAS8RYMDrJR3JZlDA7QRSWaHPJ81H14ETE506fTzO7hmO/PkPBo78CucvXbO7P2GixRKNw3+cwq3b9xLu4jYFKEABCniJAANeL+lINoMC3iawdNZQHNz0lZqWaevSvkmfdVPbkn5o81eSZDO9VK0idq6cjNLFC9nsYwIFKECBtBDgOdNegAFv2vcBa0ABCtgR8DOZ4O8XM/lpS8liipN27MS/eLPLcJw6cwGT5vyAd3uPwnfLN+PPv8+iy4AJuHkrZkjDpas30LbHF6japCvK1GiLWq/1xPhZyxAZZZYiOVGAAhSggA8IMOD1gU5mEz1BgHVMrsCdu/dx4OhJvPp2f2zcvh/Zs2ZSRdy5F6LSwyMi1XaEtsyWJSO6vNMU4z/tghYNa2DWgtWYu3it2s8ZBShAAQp4vwADXu/vY7aQAl4t8Hn/9/DjNyMwcsD7+F/T2jZtLZQ/N8YO6YzXG9dClYpl8epLVVC+bAn8dviETV4mUIACbiDAKlBABwEGvDqgskgKUMB1ApXKPZ7kyaLMZkz7dqUayvBsgw9Qr3UfdQX4fkh4ksdxJwUoQAEKeI8AA17v6UtfagnbSgGHBabOXYHJc5bjjWZ1sXzOZ9i9eioaaVd5HS6AGSlAAQpQwOMFGPB6fBeyARSgQFICO/cexQuVyqJ96wYo+VgBZMqQDkaDIalDuI8CHiTAqlKAAo4IMOB1RIl5KEABjxV4tvzjOHD0b2ze8TsO/XFK3dFh5fqdHtseVpwCFKAABZIvwIA3+WYedwQrTAFvETAaba/MJrxYa3yQYDDE5G3VpJa6J2+3QRPxv07DsGv/MZQtVRQmU8yfP4MhJp+3GLEdFKAABShgKxDzF982nSkUoAAF3EagRNECOLZtLqo+91RsnWRd0vLkzBabJiuVK5ZRefPnySGbkOW8Sf2xafEYbFk6DgunDsLiGYMxd3w/tT84KEDl57hexeHtM7aPAhTwUQEGvD7a8Ww2BXxNIG/u7MidM6uvNZvtpQAFKEABTYABr4YQ7z83KEABClCAAhSgAAW8SoABr1d1JxtDAQpQwHkCLIkCFKCAtwgw4PWWnmQ7KEABClCAAhSgAAXsCqQy4LVbJhMpQAEKUIACFKAABSjgNgIMeN2mK1gRClDAowVYeQpQgAIUcFsBBrxu2zWsGAUoQAEKUIACFPA8AXesMQNed+wV1okCFKAABShAAQpQwGkCDHidRsmCKEABxwWYkwIUoAAFKOA6AQa8rrPmmShAAQpQgAIUoEB8AW65RIABr0uYeRIKUIACFKAABShAgbQSYMCbVvI8LwUcF2BOClCAAhSgAAVSIcCANxV4PJQCFKAABShAAVcK8FwUSJkAA96UuV4ZXDcAAAIiSURBVPEoClCAAhSgAAUoQAEPEWDA6yEdxWo6LsCcFKAABShAAQpQIK4AA964GlynAAUoQAEKeI8AW0IBCjwQYMD7AIILClCAAhSgAAUoQAHvFGDA65396nirmJMCFKAABShAAQp4uQADXi/vYDaPAhSgAAUcE2AuClDAewUY8Hpv37JlFKAABShAAQpQgAKaAANeDcHx/8xJAQpQgAIUoAAFKOBpAgx4Pa3HWF8KUIAC7iDAOlCAAhTwIAEGvB7UWawqBShAAQpQgAIUoEDyBfQMeJNfGx5BAQpQgAIUoAAFKEABJwsw4HUyKIujAAUoYCvAFApQgAIUSEsBBrxpqc9zU4ACFKAABShAAV8SSKO2MuBNI3ielgIUoAAFKEABClDANQIMeF3jzLNQgAKOCzAnBShAAQpQwKkCDHidysnCKEABClCAAhSggLMEWI6zBBjwOkuS5VCAAhSgAAUoQAEKuKUAA1637BZWigKOCzAnBShAAQpQgAJJCzDgTdqHeylAAQpQgAIU8AwB1pICiQow4E2UhjsoQAEKUIACFKAABbxBgAGvN/Qi2+C4AHNSgAIUoAAFKOBzAgx4fa7L2WAKUIACFKAAQAMK+JIAA15f6m22lQIUoAAFKEABCvigAANeH+x0x5vMnBSgAAUoQAEKUMDzBRjwen4fsgUUoAAFKKC3AMunAAU8WoABr0d3HytPAQpQgAIUoAAFKPAogf8DAAD//1SgmO4AAAAGSURBVAMAjW7+L8r2EsgAAAAASUVORK5CYII="
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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"
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "from optuna.visualization import plot_optimization_history, plot_param_importances\n",
+ "\n",
+ "study = tuning_result.study\n",
+ "\n",
+ "# How the best score evolved over trials\n",
+ "fig = plot_optimization_history(study)\n",
+ "fig.update_layout(title=\"Optimization History: R² over Trials\")\n",
+ "fig.show()\n",
+ "\n",
+ "# Which hyperparameters mattered most (requires ≥ ~20 trials for reliable ranking)\n",
+ "fig2 = plot_param_importances(study)\n",
+ "fig2.update_layout(title=\"Hyperparameter Importances\")\n",
+ "fig2.show()\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 19,
+ "id": "571d30d9",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "[2026-03-05 17:22:52,777][WARNING] No aggregation functions specified for RollingAggregatesAdder. Returning original data.\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "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"
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "from openstef_beam.analysis.plots import ForecastTimeSeriesPlotter\n",
+ "\n",
+ "forecast = tuning_result.workflow.predict(forecast_dataset)\n",
+ "\n",
+ "fig = (\n",
+ " ForecastTimeSeriesPlotter()\n",
+ " .add_measurements(measurements=forecast_dataset.data[\"load\"])\n",
+ " .add_model(\n",
+ " model_name=\"XGBoost (tuned)\",\n",
+ " forecast=forecast.median_series,\n",
+ " quantiles=forecast.quantiles_data,\n",
+ " )\n",
+ " .plot()\n",
+ ")\n",
+ "fig.update_layout(\n",
+ " title=\"Tuned XGBoost Forecast vs Actual\",\n",
+ " yaxis_title=\"Load (MW)\",\n",
+ " xaxis_title=\"Time\",\n",
+ " height=500,\n",
+ ")\n",
+ "fig.show()\n"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "openstef (3.12.10)",
+ "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.10"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/packages/openstef-models/src/openstef_models/models/forecasting/gblinear_forecaster.py b/packages/openstef-models/src/openstef_models/models/forecasting/gblinear_forecaster.py
index b181b7bd5..ad20bbd39 100644
--- a/packages/openstef-models/src/openstef_models/models/forecasting/gblinear_forecaster.py
+++ b/packages/openstef-models/src/openstef_models/models/forecasting/gblinear_forecaster.py
@@ -11,7 +11,7 @@
to predict values outside the range of the training data.
"""
-from typing import ClassVar, Literal, override
+from typing import Annotated, ClassVar, Literal, override
import numpy as np
import pandas as pd
@@ -22,7 +22,6 @@
from openstef_core.datasets.mixins import LeadTime
from openstef_core.datasets.validated_datasets import ForecastDataset, ForecastInputDataset
from openstef_core.exceptions import InputValidationError, MissingExtraError, NotFittedError
-from openstef_core.mixins.predictor import HyperParams
from openstef_core.utils.pandas import normalize_to_unit_sum
from openstef_models.explainability.mixins import ContributionsMixin, ExplainableForecaster
from openstef_models.models.forecasting.forecaster import Forecaster
@@ -32,6 +31,7 @@
get_objective_function,
xgb_prepare_target_for_objective,
)
+from openstef_models.utils.tuning import CategoricalRange, FloatRange, IntRange, TunableHyperParams
try:
import xgboost as xgb
@@ -39,19 +39,19 @@
raise MissingExtraError("xgboost", "openstef-models") from e
-class GBLinearHyperParams(HyperParams):
+class GBLinearHyperParams(TunableHyperParams):
"""Hyperparameter configuration for GBLinear forecaster."""
# Learning Parameters
- n_steps: int = Field(
+ n_steps: Annotated[int, IntRange(50, 1000)] = Field(
default=500,
description="Number for steps (boosting rounds) to train the GBLinear model.",
)
- updater: str = Field(
+ updater: Annotated[str, CategoricalRange(("shotgun", "coord_descent"))] = Field(
default="shotgun",
description="The updater to use for the GBLinear booster.",
)
- learning_rate: float = Field(
+ learning_rate: Annotated[float, FloatRange(0.01, 0.5, log=True)] = Field(
default=0.15,
description="Step size shrinkage used to prevent overfitting. Range: [0,1]. Lower values require more boosting "
"rounds.",
@@ -68,15 +68,15 @@ class GBLinearHyperParams(HyperParams):
)
# Regularization
- reg_alpha: float = Field(
+ reg_alpha: Annotated[float, FloatRange(1e-8, 1.0, log=True)] = Field(
default=0.0001, description="L1 regularization on weights. Higher values increase regularization. Range: [0,∞]"
)
- reg_lambda: float = Field(
+ reg_lambda: Annotated[float, FloatRange(1e-8, 1.0, log=True)] = Field(
default=0.1, description="L2 regularization on weights. Higher values increase regularization. Range: [0,∞]"
)
# Feature selection
- feature_selector: str = Field(
+ feature_selector: Annotated[str, CategoricalRange(("cyclic", "shuffle", "random", "greedy", "thrifty"))] = Field(
default="shuffle",
description="Feature selection method.",
)
diff --git a/packages/openstef-models/src/openstef_models/models/forecasting/xgboost_forecaster.py b/packages/openstef-models/src/openstef_models/models/forecasting/xgboost_forecaster.py
index 87a956378..8717db795 100644
--- a/packages/openstef-models/src/openstef_models/models/forecasting/xgboost_forecaster.py
+++ b/packages/openstef-models/src/openstef_models/models/forecasting/xgboost_forecaster.py
@@ -9,7 +9,7 @@
comprehensive hyperparameter control for production forecasting workflows.
"""
-from typing import ClassVar, Literal, override
+from typing import Annotated, ClassVar, Literal, override
import numpy as np
import pandas as pd
@@ -18,7 +18,6 @@
from openstef_core.datasets import ForecastDataset, ForecastInputDataset, TimeSeriesDataset
from openstef_core.exceptions import MissingExtraError, NotFittedError
-from openstef_core.mixins import HyperParams
from openstef_core.utils.pandas import normalize_to_unit_sum
from openstef_models.explainability.mixins import ContributionsMixin, ExplainableForecaster
from openstef_models.models.forecasting.forecaster import Forecaster
@@ -28,6 +27,7 @@
get_objective_function,
xgb_prepare_target_for_objective,
)
+from openstef_models.utils.tuning import CategoricalRange, FloatRange, IntRange, TunableHyperParams
try:
import xgboost as xgb
@@ -35,7 +35,7 @@
raise MissingExtraError("xgboost", "openstef-models") from e
-class XGBoostHyperParams(HyperParams):
+class XGBoostHyperParams(TunableHyperParams):
"""XGBoost hyperparameters for gradient boosting tree models.
Configures tree-specific parameters for XGBoost gbtree booster. Provides
@@ -65,28 +65,28 @@ class XGBoostHyperParams(HyperParams):
"""
# Core Tree Boosting Parameters
- n_estimators: int = Field(
+ n_estimators: Annotated[int, IntRange(50, 500)] = Field(
default=100,
description="Number of boosting rounds/trees to fit. Higher values may improve performance but "
"increase training time and risk overfitting.",
)
- learning_rate: float = Field(
+ learning_rate: Annotated[float, FloatRange(0.01, 0.5, log=True)] = Field(
default=0.3,
alias="eta",
description="Step size shrinkage used to prevent overfitting. Range: [0,1]. Lower values require "
"more boosting rounds.",
)
- max_depth: int = Field(
+ max_depth: Annotated[int, IntRange(1, 15)] = Field(
default=6,
description="Maximum depth of trees. Higher values capture more complex patterns but risk "
"overfitting. Range: [1,∞]",
)
- min_child_weight: float = Field(
+ min_child_weight: Annotated[float, FloatRange(1.0, 10.0)] = Field(
default=1,
description="Minimum sum of instance weight (hessian) needed in a child. Higher values prevent "
"overfitting. Range: [0,∞]",
)
- gamma: float = Field(
+ gamma: Annotated[float, FloatRange(0.0, 5.0)] = Field(
default=0,
alias="min_split_loss",
description="Minimum loss reduction required to make a split. Higher values make algorithm more "
@@ -103,10 +103,10 @@ class XGBoostHyperParams(HyperParams):
)
# Regularization
- reg_alpha: float = Field(
+ reg_alpha: Annotated[float, FloatRange(1e-8, 10.0, log=True)] = Field(
default=0, description="L1 regularization on leaf weights. Higher values increase regularization. Range: [0,∞]"
)
- reg_lambda: float = Field(
+ reg_lambda: Annotated[float, FloatRange(1e-8, 10.0, log=True)] = Field(
default=1, description="L2 regularization on leaf weights. Higher values increase regularization. Range: [0,∞]"
)
max_delta_step: float = Field(
@@ -119,7 +119,7 @@ class XGBoostHyperParams(HyperParams):
max_leaves: int = Field(
default=0, description="Maximum number of leaves. 0 means no limit. Only relevant when grow_policy='lossguide'."
)
- grow_policy: Literal["depthwise", "lossguide"] = Field(
+ grow_policy: Annotated[Literal["depthwise", "lossguide"], CategoricalRange(("depthwise", "lossguide"))] = Field(
default="depthwise",
description="Controls how new nodes are added. 'depthwise' grows level by level, 'lossguide' adds leaves "
"with highest loss reduction.",
@@ -136,11 +136,11 @@ class XGBoostHyperParams(HyperParams):
)
# Subsampling Parameters
- subsample: float = Field(
+ subsample: Annotated[float, FloatRange(0.5, 1.0)] = Field(
default=1.0,
description="Fraction of training samples used for each tree. Lower values prevent overfitting. Range: (0,1]",
)
- colsample_bytree: float = Field(
+ colsample_bytree: Annotated[float, FloatRange(0.5, 1.0)] = Field(
default=1.0, description="Fraction of features used when constructing each tree. Range: (0,1]"
)
colsample_bylevel: float = Field(
@@ -151,7 +151,10 @@ class XGBoostHyperParams(HyperParams):
)
# Tree Construction Method
- tree_method: Literal["auto", "exact", "hist", "approx", "gpu_hist"] = Field(
+ tree_method: Annotated[
+ Literal["auto", "exact", "hist", "approx", "gpu_hist"],
+ CategoricalRange(("auto", "hist", "approx")),
+ ] = Field(
default="auto",
description="Tree construction algorithm. 'hist' is fastest for large datasets, 'exact' for small "
"datasets, 'approx' is deprecated.",
diff --git a/packages/openstef-models/src/openstef_models/presets/__init__.py b/packages/openstef-models/src/openstef_models/presets/__init__.py
index 0615a0ea4..fde973bf7 100644
--- a/packages/openstef-models/src/openstef_models/presets/__init__.py
+++ b/packages/openstef-models/src/openstef_models/presets/__init__.py
@@ -7,9 +7,18 @@
Provides configurations and utilities for setting up forecasting workflows.
"""
-from .forecasting_workflow import ForecastingWorkflowConfig, create_forecasting_workflow
+from .forecasting_workflow import (
+ ForecastingWorkflowConfig,
+ TuningResult,
+ create_forecasting_workflow,
+ fit_with_tuning,
+ tune,
+)
__all__ = [
"ForecastingWorkflowConfig",
+ "TuningResult",
"create_forecasting_workflow",
+ "fit_with_tuning",
+ "tune",
]
diff --git a/packages/openstef-models/src/openstef_models/presets/forecasting_workflow.py b/packages/openstef-models/src/openstef_models/presets/forecasting_workflow.py
index 028302c1b..14bd91f47 100644
--- a/packages/openstef-models/src/openstef_models/presets/forecasting_workflow.py
+++ b/packages/openstef-models/src/openstef_models/presets/forecasting_workflow.py
@@ -10,8 +10,9 @@
from datetime import timedelta
from decimal import Decimal
-from typing import Literal
+from typing import Any, Literal
+import optuna
from pydantic import Field
from pydantic_extra_types.coordinate import Coordinate, Latitude, Longitude
from pydantic_extra_types.country import CountryAlpha2
@@ -23,6 +24,7 @@
R2Provider,
)
from openstef_core.base_model import BaseConfig
+from openstef_core.datasets import TimeSeriesDataset
from openstef_core.mixins import TransformPipeline
from openstef_core.types import LeadTime, Q, Quantile, QuantileOrGlobal
from openstef_models.integrations.mlflow import MLFlowStorage, MLFlowStorageCallback
@@ -34,6 +36,7 @@
from openstef_models.models.forecasting.lgbmlinear_forecaster import LGBMLinearForecaster, LGBMLinearHyperParams
from openstef_models.models.forecasting.median_forecaster import MedianForecaster
from openstef_models.models.forecasting.xgboost_forecaster import XGBoostForecaster, XGBoostHyperParams
+from openstef_models.models.forecasting_model import ModelFitResult
from openstef_models.transforms.energy_domain import WindPowerFeatureAdder
from openstef_models.transforms.general import (
Clipper,
@@ -63,6 +66,7 @@
)
from openstef_models.utils.data_split import DataSplitter
from openstef_models.utils.feature_selection import Exclude, FeatureSelection, Include
+from openstef_models.utils.tuning import get_search_space, run_optuna_study, suggest_hyperparams
from openstef_models.workflows.custom_forecasting_workflow import (
CustomForecastingWorkflow,
ForecastingCallback,
@@ -278,6 +282,16 @@ class ForecastingWorkflowConfig(BaseConfig): # PredictionJob
default=0, description="Verbosity level. 0=silent, 1=warning, 2=info, 3=debug"
)
+ # Hyperparameter tuning (Optuna)
+ optuna_n_trials: int = Field(
+ default=20,
+ description="Number of Optuna trials to run when any search-space field has tune=True.",
+ )
+ optuna_seed: int | None = Field(
+ default=42,
+ description="Random seed for the Optuna TPE sampler. Set to None to disable seeding.",
+ )
+
# Metadata
tags: dict[str, str] = Field(
default_factory=dict,
@@ -515,3 +529,179 @@ def create_forecasting_workflow(
callbacks=callbacks,
experiment_tags=config.experiment_tags,
)
+
+
+class TuningResult:
+ """Result of a :func:`fit_with_tuning` call.
+
+ Attributes:
+ workflow: The fitted :class:`CustomForecastingWorkflow`.
+ fit_result: The :class:`ModelFitResult` from the final training run, or
+ ``None`` if fitting was skipped (e.g. by an MLflow callback).
+ study: The completed :class:`optuna.Study`.
+ best_params: Flat dict of the best hyperparameter values found by Optuna,
+ or an empty dict when tuning was not performed.
+ """
+
+ def __init__(
+ self,
+ workflow: CustomForecastingWorkflow,
+ fit_result: ModelFitResult | None,
+ study: optuna.Study | None,
+ best_params: dict[str, Any],
+ ) -> None:
+ """Initialize a TuningResult with workflow and tuning outcomes.
+
+ Args:
+ workflow: The fitted forecasting workflow.
+ fit_result: The result from the final training run, or None if fitting was skipped.
+ study: The completed Optuna study, or None if no tuning was performed.
+ best_params: Dictionary of best hyperparameter values found, or empty if no tuning.
+ """
+ self.workflow = workflow
+ self.fit_result = fit_result
+ self.study = study
+ self.best_params = best_params
+
+ def __repr__(self) -> str:
+ """Return a string representation of the TuningResult."""
+ tuned = f"{len(self.best_params)} params tuned" if self.best_params else "no tuning"
+ return f"TuningResult({tuned})"
+
+
+def tune(
+ config: ForecastingWorkflowConfig,
+ train_dataset: TimeSeriesDataset,
+) -> tuple[ForecastingWorkflowConfig, optuna.Study, dict[str, Any]]:
+ """Run hyperparameter tuning for a forecasting workflow configuration.
+
+ Inspects the ``xgboost_hyperparams`` / ``gblinear_hyperparams`` instance of
+ *config* to determine which hyperparameters are marked for tuning
+ (by passing a ``TuningRange(tune=True)`` as the field value).
+
+ The metric maximised during the study is determined by
+ :attr:`ForecastingWorkflowConfig.model_selection_metric`.
+
+ Args:
+ config: Workflow configuration. Pass ``TuningRange(tune=True)`` objects as
+ field values on ``xgboost_hyperparams`` / ``gblinear_hyperparams`` to mark
+ fields for tuning. ``optuna_n_trials`` and ``optuna_seed`` control the study.
+ train_dataset: Dataset used for all trial fit calls.
+
+ Returns:
+ A tuple of:
+
+ - The config updated with the best hyperparameters found.
+ - The completed :class:`optuna.Study`.
+ - A flat dict of the best hyperparameter values.
+
+ Raises:
+ ValueError: If the model type does not support tuning (e.g. ``flatliner``),
+ or if the model supports tuning but no field has ``tune=True``
+ in the hyperparams instance.
+ """
+ if config.model not in {"xgboost", "gblinear"}:
+ msg = (
+ f"Model type '{config.model}' does not support hyperparameter tuning. "
+ "Use 'xgboost' or 'gblinear' and pass TuningRange(tune=True) as field values."
+ )
+ raise ValueError(msg)
+
+ if config.model == "xgboost":
+ current_hp = config.xgboost_hyperparams
+ hp_field = "xgboost_hyperparams"
+ else: # gblinear
+ current_hp = config.gblinear_hyperparams
+ hp_field = "gblinear_hyperparams"
+
+ # Build the effective search space
+ space = get_search_space(current_hp)
+
+ if not space:
+ msg = (
+ f"No tunable hyperparameters found on `{hp_field}`. "
+ "Pass TuningRange(tune=True) objects as field values when constructing it, "
+ "e.g. `n_estimators=IntRange(100, 800, tune=True)`."
+ )
+ raise ValueError(msg)
+
+ # Build the Optuna objective
+ target_quantile, metric_name, _ = config.model_selection_metric
+
+ def _objective(trial: optuna.Trial) -> float:
+ tuned_hp = suggest_hyperparams(trial, space, current_hp)
+ tuned_config = config.model_copy(update={hp_field: tuned_hp})
+ trial_workflow = create_forecasting_workflow(tuned_config)
+ trial_result = trial_workflow.fit(train_dataset)
+ if trial_result is None:
+ return float("-inf")
+ metrics = trial_result.metrics_val if trial_result.metrics_val is not None else trial_result.metrics_train
+ score = metrics.get_metric(quantile=target_quantile, metric_name=metric_name)
+ return float(score) if score is not None else float("-inf")
+
+ # Run the study
+ study = run_optuna_study(
+ objective=_objective,
+ n_trials=config.optuna_n_trials,
+ seed=config.optuna_seed,
+ study_name=f"tuning_{config.model_id}",
+ )
+
+ best_hp = current_hp.model_copy(update=study.best_params)
+ best_config = config.model_copy(update={hp_field: best_hp})
+ return best_config, study, study.best_params
+
+
+def fit_with_tuning(
+ config: ForecastingWorkflowConfig,
+ train_dataset: TimeSeriesDataset,
+) -> TuningResult:
+ """Create, optionally tune, and fit a forecasting workflow in one call.
+
+ Inspects the ``xgboost_hyperparams`` / ``gblinear_hyperparams`` instance of
+ *config* to determine whether any hyperparameter is marked for tuning
+ (by passing a ``TuningRange(tune=True)`` as the field value).
+
+ * **One or more tunable fields** runs an Optuna Bayesian search for
+ :attr:`ForecastingWorkflowConfig.optuna_n_trials` trials via :func:`tune`,
+ then trains the final model with the best hyperparameters found.
+
+ The metric maximised during the study is determined by
+ :attr:`ForecastingWorkflowConfig.model_selection_metric`.
+
+ Args:
+ config: Workflow configuration. Pass ``TuningRange(tune=True)`` objects as
+ field values on ``xgboost_hyperparams`` / ``gblinear_hyperparams`` to mark
+ fields for tuning. ``optuna_n_trials`` and ``optuna_seed`` control the study.
+ train_dataset: Dataset used for **all** workflow fit calls (both tuning
+ trials and the final fit).
+
+ Returns:
+ :class:`TuningResult` with the fitted workflow, fit result, optional study,
+ and the best hyperparameter values.
+
+ Example::
+
+ from openstef_models.presets import ForecastingWorkflowConfig, fit_with_tuning
+ from openstef_models.utils.tuning import FloatRange, IntRange
+ from openstef_core.types import LeadTime, Q
+
+ config = ForecastingWorkflowConfig(
+ model_id="demo",
+ model="xgboost",
+ quantiles=[Q(0.5), Q(0.1), Q(0.9)],
+ horizons=[LeadTime.from_string("PT36H")],
+ xgboost_hyperparams=XGBoostForecaster.HyperParams(
+ n_estimators=IntRange(100, 500, tune=True),
+ learning_rate=FloatRange(None, None, log=True, tune=True),
+ ),
+ optuna_n_trials=20,
+ mlflow_storage=None,
+ )
+ result = fit_with_tuning(config, train_dataset) # doctest: +SKIP
+ print(result.best_params) # doctest: +SKIP
+ """
+ tuned_config, study, best_params = tune(config, train_dataset)
+ workflow = create_forecasting_workflow(tuned_config)
+ result = workflow.fit(train_dataset)
+ return TuningResult(workflow=workflow, fit_result=result, study=study, best_params=best_params)
diff --git a/packages/openstef-models/src/openstef_models/utils/tuning.py b/packages/openstef-models/src/openstef_models/utils/tuning.py
new file mode 100644
index 000000000..3d0cbb731
--- /dev/null
+++ b/packages/openstef-models/src/openstef_models/utils/tuning.py
@@ -0,0 +1,328 @@
+# SPDX-FileCopyrightText: 2025 Contributors to the OpenSTEF project
+#
+# SPDX-License-Identifier: MPL-2.0
+"""Hyperparameter tuning utilities for OpenSTEF models.
+
+Provides dataclasses for describing hyperparameter search spaces, helper functions to
+extract and merge search spaces from annotated HyperParams classes, and a thin wrapper
+around Optuna for running Bayesian hyperparameter optimisation studies.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, cast
+
+import optuna
+from pydantic import BaseModel, PrivateAttr, model_validator
+
+if TYPE_CHECKING:
+ from collections.abc import Callable
+
+ from pydantic.fields import FieldInfo
+
+from openstef_core.mixins import HyperParams
+
+
+@dataclass(frozen=True)
+class FloatRange:
+ """Search space metadata for continuous float hyperparameters.
+
+ Attach to a ``HyperParams`` field via ``Annotated`` to declare the
+ range that a hyperparameter tuner should explore.
+
+ Args:
+ low: Lower bound of the search interval (inclusive).
+ high: Upper bound of the search interval (inclusive).
+ log: When ``True`` the sampler draws on a log scale, which is
+ recommended for parameters like learning rates and
+ regularisation coefficients.
+
+ Example:
+ >>> learning_rate: Annotated[float, FloatRange(0.01, 0.5, log=True)] = 0.3
+ """
+
+ low: float | None
+ high: float | None
+ log: bool = False
+ tune: bool = False
+
+
+@dataclass(frozen=True)
+class IntRange:
+ """Search space metadata for discrete integer hyperparameters.
+
+ Attach to a ``HyperParams`` field via ``Annotated`` to declare the
+ integer range that a hyperparameter tuner should explore.
+
+ Args:
+ low: Minimum integer value (inclusive).
+ high: Maximum integer value (inclusive).
+ log: When ``True`` the sampler draws on a log scale.
+
+ Example:
+ >>> n_estimators: Annotated[int, IntRange(50, 500)] = 100
+ """
+
+ low: int | None
+ high: int | None
+ log: bool = False
+ tune: bool = False
+
+
+@dataclass(frozen=True)
+class CategoricalRange:
+ """Search space metadata for categorical hyperparameters.
+
+ Attach to a ``HyperParams`` field via ``Annotated`` to list the
+ discrete choices that a hyperparameter tuner should explore.
+
+ Args:
+ choices: Tuple of allowed values for the parameter.
+
+ Example:
+ >>> tree_method: Annotated[str, CategoricalRange(("hist", "approx"))] = "hist"
+ """
+
+ choices: tuple[Any, ...] | None
+ tune: bool = False
+
+
+#: Union alias for any single-parameter search space descriptor.
+TuningRange = FloatRange | IntRange | CategoricalRange
+
+
+class TunableHyperParams(HyperParams):
+ """HyperParams subclass that accepts ``TuningRange`` objects as field values.
+
+ Pass a :class:`FloatRange`, :class:`IntRange`, or :class:`CategoricalRange` as the
+ value for any field during construction. The range is stored in the private
+ ``_instance_ranges`` attribute and the field itself keeps its declared default value.
+ ``None`` for ``low`` / ``high`` / ``choices`` falls back to the class-level
+ ``Annotated`` metadata when the search space is resolved.
+
+ This means the tuning search space lives **on the HyperParams instance itself** — no
+ separate dict is needed.
+
+ Example::
+
+ hp = XGBoostHyperParams(
+ n_estimators=IntRange(100, 800, tune=True),
+ learning_rate=FloatRange(None, None, log=True, tune=True), # → class default [0.01, 0.5]
+ )
+ # hp.n_estimators == 100 (the class default; the IntRange was extracted)
+ # get_search_space(hp) → {'n_estimators': IntRange(100, 800), 'learning_rate': FloatRange(0.01, 0.5)}
+ """
+
+ _instance_ranges: dict[str, TuningRange] = PrivateAttr( # pyright: ignore[reportUnknownVariableType]
+ default_factory=dict
+ )
+
+ @property
+ def instance_ranges(self) -> dict[str, TuningRange]:
+ """Public view of the per-instance tuning ranges extracted at construction."""
+ return self._instance_ranges
+
+ @model_validator(mode="wrap")
+ @classmethod
+ def _extract_tuning_ranges(
+ cls,
+ data: dict[str, object] | object,
+ handler: Callable[[dict[str, object] | object], TunableHyperParams],
+ ) -> TunableHyperParams:
+ """Strip TuningRange values from the input dict and store them as instance metadata.
+
+ Returns:
+ A new :class:`TunableHyperParams` instance with TuningRange values removed
+ from the fields and stored in the private ``_instance_ranges`` attribute.
+ """
+ instance_ranges: dict[str, TuningRange] = {}
+ if isinstance(data, dict):
+ cleaned: dict[str, Any] = {}
+ for key, value in cast("dict[str, object]", data).items():
+ if isinstance(value, (FloatRange, IntRange, CategoricalRange)):
+ instance_ranges[key] = value
+ # Keep the key absent: Pydantic uses the declared field default
+ else:
+ cleaned[key] = value
+ data = cleaned
+ result: TunableHyperParams = handler(data)
+ if instance_ranges and result.__pydantic_private__ is not None:
+ result.__pydantic_private__["_instance_ranges"] = instance_ranges
+ return result
+
+
+def _get_class_range(field_info: FieldInfo) -> TuningRange | None:
+ """Return the first TuningRange found in a Pydantic FieldInfo's metadata."""
+ for meta in field_info.metadata:
+ if isinstance(meta, (FloatRange, IntRange, CategoricalRange)):
+ return meta
+ return None
+
+
+def _merge_range(override: TuningRange, class_range: TuningRange | None) -> TuningRange:
+ """Merge *override* with *class_range*, filling ``None`` from the class defaults.
+
+ For ``FloatRange`` / ``IntRange``, ``None`` values for ``low`` or ``high`` are filled
+ in from *class_range*. For ``CategoricalRange``, ``None`` for ``choices`` falls back
+ to *class_range*. The ``tune`` flag always comes from *override*.
+
+ Returns:
+ A new :class:`TuningRange` with ``None`` bounds merged from *class_range*.
+ """
+ if isinstance(override, FloatRange):
+ cr = class_range if isinstance(class_range, FloatRange) else None
+ return FloatRange(
+ low=override.low if override.low is not None else (cr.low if cr else None),
+ high=override.high if override.high is not None else (cr.high if cr else None),
+ log=override.log,
+ tune=override.tune,
+ )
+ if isinstance(override, IntRange):
+ cr = class_range if isinstance(class_range, IntRange) else None
+ return IntRange(
+ low=override.low if override.low is not None else (cr.low if cr else None),
+ high=override.high if override.high is not None else (cr.high if cr else None),
+ log=override.log,
+ tune=override.tune,
+ )
+ cr = class_range if isinstance(class_range, CategoricalRange) else None
+ return CategoricalRange(
+ choices=override.choices if override.choices is not None else (cr.choices if cr else None),
+ tune=override.tune,
+ )
+
+
+def get_search_space(
+ hyperparams: BaseModel,
+ include: set[str] | None = None,
+) -> dict[str, TuningRange]:
+ """Extract the effective tunable search space from a *HyperParams* instance.
+
+ Reads per-instance ``TuningRange`` objects stored in ``_instance_ranges``
+ (set by passing ranges directly in the constructor of a
+ :class:`TunableHyperParams` subclass) and merges them with the class-level
+ ``Annotated`` metadata. ``None`` bounds fall back to the class-level defaults.
+ Only fields where the resulting ``tune`` flag is ``True`` are included.
+
+ Args:
+ hyperparams: A :class:`TunableHyperParams` (or plain ``HyperParams``) instance.
+ include: If given, restrict the output to exactly these field names. A
+ ``KeyError`` is raised immediately for any name that is absent or has no
+ ``tune=True`` annotation (catches typos early).
+
+ Returns:
+ Mapping of field-name → effective :class:`TuningRange` for all tunable fields.
+
+ Raises:
+ KeyError: If ``include`` is specified and any requested field name is not
+ present in the tunable search space.
+
+ Example::
+
+ hp = XGBoostHyperParams(
+ n_estimators=IntRange(100, 800, tune=True),
+ learning_rate=FloatRange(None, None, log=True, tune=True),
+ )
+ space = get_search_space(hp)
+ # {'n_estimators': IntRange(100, 800), 'learning_rate': FloatRange(0.01, 0.5, log=True)}
+ """
+ # Per-instance ranges take precedence over class-level annotations
+ instance_ranges: dict[str, TuningRange] = {}
+ if isinstance(hyperparams, TunableHyperParams):
+ instance_ranges = hyperparams.instance_ranges
+
+ result: dict[str, TuningRange] = {}
+ for field_name, field_info in type(hyperparams).model_fields.items():
+ class_range = _get_class_range(field_info)
+ override = instance_ranges.get(field_name)
+
+ if override is not None:
+ if not override.tune:
+ continue
+ result[field_name] = _merge_range(override, class_range)
+ elif class_range is not None and class_range.tune:
+ result[field_name] = class_range
+
+ if include is not None:
+ missing = include - result.keys()
+ if missing:
+ msg = (
+ f"Fields {sorted(missing)!r} not found in the tunable search space. "
+ "Check that they exist on the HyperParams class and were passed as "
+ "TuningRange(tune=True) in the constructor."
+ )
+ raise KeyError(msg)
+ result = {k: result[k] for k in include}
+
+ return result
+
+
+def suggest_hyperparams[HP: BaseModel](
+ trial: optuna.Trial,
+ space: dict[str, TuningRange],
+ current: HP,
+) -> HP:
+ """Create an updated *HyperParams* using Optuna trial suggestions.
+
+ Args:
+ trial: Optuna trial object for suggesting values.
+ space: Search space returned by :func:`get_search_space`.
+ current: Current ``HyperParams`` instance to copy-and-update.
+
+ Returns:
+ A new ``HyperParams`` instance with the suggested values applied.
+ """
+ updates: dict[str, Any] = {}
+ for field_name, param in space.items():
+ if isinstance(param, FloatRange):
+ if param.low is not None and param.high is not None:
+ updates[field_name] = trial.suggest_float(field_name, param.low, param.high, log=param.log)
+ elif isinstance(param, IntRange):
+ if param.low is not None and param.high is not None:
+ updates[field_name] = trial.suggest_int(field_name, param.low, param.high, log=param.log)
+ elif param.choices is not None:
+ updates[field_name] = trial.suggest_categorical(field_name, list(param.choices))
+ return current.model_copy(update=updates)
+
+
+def run_optuna_study(
+ objective: Callable[[optuna.Trial], float],
+ n_trials: int,
+ seed: int | None = 42,
+ direction: str = "maximize",
+ study_name: str = "hyperparameter_tuning",
+) -> optuna.Study:
+ """Run a Bayesian hyperparameter optimisation study using Optuna.
+
+ Args:
+ objective: Callable that receives an :class:`optuna.Trial` and returns a
+ ``float`` score to optimise.
+ n_trials: Number of trials to evaluate.
+ seed: Random seed for the TPE sampler (``None`` disables seeding).
+ direction: ``"maximize"`` or ``"minimize"``.
+ study_name: Human-readable label for the study.
+
+ Returns:
+ Completed :class:`optuna.Study` with all trial results.
+ """
+ study = optuna.create_study(
+ direction=direction,
+ sampler=optuna.samplers.TPESampler(seed=seed),
+ pruner=optuna.pruners.MedianPruner(n_startup_trials=5),
+ study_name=study_name,
+ )
+ study.optimize(objective, n_trials=n_trials, show_progress_bar=True)
+ return study
+
+
+__all__ = [
+ "CategoricalRange",
+ "FloatRange",
+ "IntRange",
+ "TunableHyperParams",
+ "TuningRange",
+ "get_search_space",
+ "run_optuna_study",
+ "suggest_hyperparams",
+]
diff --git a/pyproject.toml b/pyproject.toml
index 15a43c8cc..b50e3d487 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -29,6 +29,7 @@ classifiers = [
dependencies = [
"openstef-core",
"openstef-models[xgb-cpu]",
+ "optuna>=4.7",
]
optional-dependencies.all = [
diff --git a/uv.lock b/uv.lock
index d6360eecc..a8c24e62d 100644
--- a/uv.lock
+++ b/uv.lock
@@ -172,6 +172,20 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/7e/b3/6b4067be973ae96ba0d615946e314c5ae35f9f993eca561b356540bb0c2b/alabaster-1.0.0-py3-none-any.whl", hash = "sha256:fc6786402dc3fcb2de3cabd5fe455a2db534b371124f1f21de8731783dec828b", size = 13929, upload-time = "2024-07-26T18:15:02.05Z" },
]
+[[package]]
+name = "alembic"
+version = "1.18.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "mako" },
+ { name = "sqlalchemy" },
+ { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/79/41/ab8f624929847b49f84955c594b165855efd829b0c271e1a8cac694138e5/alembic-1.18.3.tar.gz", hash = "sha256:1212aa3778626f2b0f0aa6dd4e99a5f99b94bd25a0c1ac0bba3be65e081e50b0", size = 2052564, upload-time = "2026-01-29T20:24:15.124Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/45/8e/d79281f323e7469b060f15bd229e48d7cdd219559e67e71c013720a88340/alembic-1.18.3-py3-none-any.whl", hash = "sha256:12a0359bfc068a4ecbb9b3b02cf77856033abfdb59e4a5aca08b7eacd7b74ddd", size = 262282, upload-time = "2026-01-29T20:24:17.488Z" },
+]
+
[[package]]
name = "annotated-doc"
version = "0.0.4"
@@ -632,6 +646,18 @@ 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 = "colorlog"
+version = "6.10.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "colorama", marker = "sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a2/61/f083b5ac52e505dfc1c624eafbf8c7589a0d7f32daa398d2e7590efa5fda/colorlog-6.10.1.tar.gz", hash = "sha256:eb4ae5cb65fe7fec7773c2306061a8e63e02efc2c72eba9d27b0fa23c94f1321", size = 17162, upload-time = "2025-10-16T16:14:11.978Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/6d/c1/e419ef3723a074172b68aaa89c9f3de486ed4c2399e2dbd8113a4fdcaf9e/colorlog-6.10.1-py3-none-any.whl", hash = "sha256:2d7e8348291948af66122cff006c9f8da6255d224e7cf8e37d8de2df3bad8c9c", size = 11743, upload-time = "2025-10-16T16:14:10.512Z" },
+]
+
[[package]]
name = "comm"
version = "0.2.3"
@@ -1236,6 +1262,45 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/0a/14/933037032608787fb92e365883ad6a741c235e0ff992865ec5d904a38f1e/graphql_core-3.2.7-py3-none-any.whl", hash = "sha256:17fc8f3ca4a42913d8e24d9ac9f08deddf0a0b2483076575757f6c412ead2ec0", size = 207262, upload-time = "2025-11-01T22:30:38.912Z" },
]
+[[package]]
+name = "greenlet"
+version = "3.3.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/8a/99/1cd3411c56a410994669062bd73dd58270c00cc074cac15f385a1fd91f8a/greenlet-3.3.1.tar.gz", hash = "sha256:41848f3230b58c08bb43dee542e74a2a2e34d3c59dc3076cec9151aeeedcae98", size = 184690, upload-time = "2026-01-23T15:31:02.076Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/f9/c8/9d76a66421d1ae24340dfae7e79c313957f6e3195c144d2c73333b5bfe34/greenlet-3.3.1-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:7e806ca53acf6d15a888405880766ec84721aa4181261cd11a457dfe9a7a4975", size = 276443, upload-time = "2026-01-23T15:30:10.066Z" },
+ { url = "https://files.pythonhosted.org/packages/81/99/401ff34bb3c032d1f10477d199724f5e5f6fbfb59816ad1455c79c1eb8e7/greenlet-3.3.1-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d842c94b9155f1c9b3058036c24ffb8ff78b428414a19792b2380be9cecf4f36", size = 597359, upload-time = "2026-01-23T16:00:57.394Z" },
+ { url = "https://files.pythonhosted.org/packages/2b/bc/4dcc0871ed557792d304f50be0f7487a14e017952ec689effe2180a6ff35/greenlet-3.3.1-cp312-cp312-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:20fedaadd422fa02695f82093f9a98bad3dab5fcda793c658b945fcde2ab27ba", size = 607805, upload-time = "2026-01-23T16:05:28.068Z" },
+ { url = "https://files.pythonhosted.org/packages/cf/05/821587cf19e2ce1f2b24945d890b164401e5085f9d09cbd969b0c193cd20/greenlet-3.3.1-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:14194f5f4305800ff329cbf02c5fcc88f01886cadd29941b807668a45f0d2336", size = 609947, upload-time = "2026-01-23T15:32:51.004Z" },
+ { url = "https://files.pythonhosted.org/packages/a4/52/ee8c46ed9f8babaa93a19e577f26e3d28a519feac6350ed6f25f1afee7e9/greenlet-3.3.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:7b2fe4150a0cf59f847a67db8c155ac36aed89080a6a639e9f16df5d6c6096f1", size = 1567487, upload-time = "2026-01-23T16:04:22.125Z" },
+ { url = "https://files.pythonhosted.org/packages/8f/7c/456a74f07029597626f3a6db71b273a3632aecb9afafeeca452cfa633197/greenlet-3.3.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:49f4ad195d45f4a66a0eb9c1ba4832bb380570d361912fa3554746830d332149", size = 1636087, upload-time = "2026-01-23T15:33:47.486Z" },
+ { url = "https://files.pythonhosted.org/packages/34/2f/5e0e41f33c69655300a5e54aeb637cf8ff57f1786a3aba374eacc0228c1d/greenlet-3.3.1-cp312-cp312-win_amd64.whl", hash = "sha256:cc98b9c4e4870fa983436afa999d4eb16b12872fab7071423d5262fa7120d57a", size = 227156, upload-time = "2026-01-23T15:34:34.808Z" },
+ { url = "https://files.pythonhosted.org/packages/c8/ab/717c58343cf02c5265b531384b248787e04d8160b8afe53d9eec053d7b44/greenlet-3.3.1-cp312-cp312-win_arm64.whl", hash = "sha256:bfb2d1763d777de5ee495c85309460f6fd8146e50ec9d0ae0183dbf6f0a829d1", size = 226403, upload-time = "2026-01-23T15:31:39.372Z" },
+ { url = "https://files.pythonhosted.org/packages/ec/ab/d26750f2b7242c2b90ea2ad71de70cfcd73a948a49513188a0fc0d6fc15a/greenlet-3.3.1-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:7ab327905cabb0622adca5971e488064e35115430cec2c35a50fd36e72a315b3", size = 275205, upload-time = "2026-01-23T15:30:24.556Z" },
+ { url = "https://files.pythonhosted.org/packages/10/d3/be7d19e8fad7c5a78eeefb2d896a08cd4643e1e90c605c4be3b46264998f/greenlet-3.3.1-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:65be2f026ca6a176f88fb935ee23c18333ccea97048076aef4db1ef5bc0713ac", size = 599284, upload-time = "2026-01-23T16:00:58.584Z" },
+ { url = "https://files.pythonhosted.org/packages/ae/21/fe703aaa056fdb0f17e5afd4b5c80195bbdab701208918938bd15b00d39b/greenlet-3.3.1-cp313-cp313-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7a3ae05b3d225b4155bda56b072ceb09d05e974bc74be6c3fc15463cf69f33fd", size = 610274, upload-time = "2026-01-23T16:05:29.312Z" },
+ { url = "https://files.pythonhosted.org/packages/cb/86/5c6ab23bb3c28c21ed6bebad006515cfe08b04613eb105ca0041fecca852/greenlet-3.3.1-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6423481193bbbe871313de5fd06a082f2649e7ce6e08015d2a76c1e9186ca5b3", size = 612904, upload-time = "2026-01-23T15:32:52.317Z" },
+ { url = "https://files.pythonhosted.org/packages/c2/f3/7949994264e22639e40718c2daf6f6df5169bf48fb038c008a489ec53a50/greenlet-3.3.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:33a956fe78bbbda82bfc95e128d61129b32d66bcf0a20a1f0c08aa4839ffa951", size = 1567316, upload-time = "2026-01-23T16:04:23.316Z" },
+ { url = "https://files.pythonhosted.org/packages/8d/6e/d73c94d13b6465e9f7cd6231c68abde838bb22408596c05d9059830b7872/greenlet-3.3.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4b065d3284be43728dd280f6f9a13990b56470b81be20375a207cdc814a983f2", size = 1636549, upload-time = "2026-01-23T15:33:48.643Z" },
+ { url = "https://files.pythonhosted.org/packages/5e/b3/c9c23a6478b3bcc91f979ce4ca50879e4d0b2bd7b9a53d8ecded719b92e2/greenlet-3.3.1-cp313-cp313-win_amd64.whl", hash = "sha256:27289986f4e5b0edec7b5a91063c109f0276abb09a7e9bdab08437525977c946", size = 227042, upload-time = "2026-01-23T15:33:58.216Z" },
+ { url = "https://files.pythonhosted.org/packages/90/e7/824beda656097edee36ab15809fd063447b200cc03a7f6a24c34d520bc88/greenlet-3.3.1-cp313-cp313-win_arm64.whl", hash = "sha256:2f080e028001c5273e0b42690eaf359aeef9cb1389da0f171ea51a5dc3c7608d", size = 226294, upload-time = "2026-01-23T15:30:52.73Z" },
+ { url = "https://files.pythonhosted.org/packages/ae/fb/011c7c717213182caf78084a9bea51c8590b0afda98001f69d9f853a495b/greenlet-3.3.1-cp314-cp314-macosx_11_0_universal2.whl", hash = "sha256:bd59acd8529b372775cd0fcbc5f420ae20681c5b045ce25bd453ed8455ab99b5", size = 275737, upload-time = "2026-01-23T15:32:16.889Z" },
+ { url = "https://files.pythonhosted.org/packages/41/2e/a3a417d620363fdbb08a48b1dd582956a46a61bf8fd27ee8164f9dfe87c2/greenlet-3.3.1-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b31c05dd84ef6871dd47120386aed35323c944d86c3d91a17c4b8d23df62f15b", size = 646422, upload-time = "2026-01-23T16:01:00.354Z" },
+ { url = "https://files.pythonhosted.org/packages/b4/09/c6c4a0db47defafd2d6bab8ddfe47ad19963b4e30f5bed84d75328059f8c/greenlet-3.3.1-cp314-cp314-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:02925a0bfffc41e542c70aa14c7eda3593e4d7e274bfcccca1827e6c0875902e", size = 658219, upload-time = "2026-01-23T16:05:30.956Z" },
+ { url = "https://files.pythonhosted.org/packages/80/38/9d42d60dffb04b45f03dbab9430898352dba277758640751dc5cc316c521/greenlet-3.3.1-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:34a729e2e4e4ffe9ae2408d5ecaf12f944853f40ad724929b7585bca808a9d6f", size = 660237, upload-time = "2026-01-23T15:32:53.967Z" },
+ { url = "https://files.pythonhosted.org/packages/96/61/373c30b7197f9e756e4c81ae90a8d55dc3598c17673f91f4d31c3c689c3f/greenlet-3.3.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:aec9ab04e82918e623415947921dea15851b152b822661cce3f8e4393c3df683", size = 1615261, upload-time = "2026-01-23T16:04:25.066Z" },
+ { url = "https://files.pythonhosted.org/packages/fd/d3/ca534310343f5945316f9451e953dcd89b36fe7a19de652a1dc5a0eeef3f/greenlet-3.3.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:71c767cf281a80d02b6c1bdc41c9468e1f5a494fb11bc8688c360524e273d7b1", size = 1683719, upload-time = "2026-01-23T15:33:50.61Z" },
+ { url = "https://files.pythonhosted.org/packages/52/cb/c21a3fd5d2c9c8b622e7bede6d6d00e00551a5ee474ea6d831b5f567a8b4/greenlet-3.3.1-cp314-cp314-win_amd64.whl", hash = "sha256:96aff77af063b607f2489473484e39a0bbae730f2ea90c9e5606c9b73c44174a", size = 228125, upload-time = "2026-01-23T15:32:45.265Z" },
+ { url = "https://files.pythonhosted.org/packages/6a/8e/8a2db6d11491837af1de64b8aff23707c6e85241be13c60ed399a72e2ef8/greenlet-3.3.1-cp314-cp314-win_arm64.whl", hash = "sha256:b066e8b50e28b503f604fa538adc764a638b38cf8e81e025011d26e8a627fa79", size = 227519, upload-time = "2026-01-23T15:31:47.284Z" },
+ { url = "https://files.pythonhosted.org/packages/28/24/cbbec49bacdcc9ec652a81d3efef7b59f326697e7edf6ed775a5e08e54c2/greenlet-3.3.1-cp314-cp314t-macosx_11_0_universal2.whl", hash = "sha256:3e63252943c921b90abb035ebe9de832c436401d9c45f262d80e2d06cc659242", size = 282706, upload-time = "2026-01-23T15:33:05.525Z" },
+ { url = "https://files.pythonhosted.org/packages/86/2e/4f2b9323c144c4fe8842a4e0d92121465485c3c2c5b9e9b30a52e80f523f/greenlet-3.3.1-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:76e39058e68eb125de10c92524573924e827927df5d3891fbc97bd55764a8774", size = 651209, upload-time = "2026-01-23T16:01:01.517Z" },
+ { url = "https://files.pythonhosted.org/packages/d9/87/50ca60e515f5bb55a2fbc5f0c9b5b156de7d2fc51a0a69abc9d23914a237/greenlet-3.3.1-cp314-cp314t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c9f9d5e7a9310b7a2f416dd13d2e3fd8b42d803968ea580b7c0f322ccb389b97", size = 654300, upload-time = "2026-01-23T16:05:32.199Z" },
+ { url = "https://files.pythonhosted.org/packages/1d/94/74310866dfa2b73dd08659a3d18762f83985ad3281901ba0ee9a815194fb/greenlet-3.3.1-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:92497c78adf3ac703b57f1e3813c2d874f27f71a178f9ea5887855da413cd6d2", size = 653842, upload-time = "2026-01-23T15:32:55.671Z" },
+ { url = "https://files.pythonhosted.org/packages/97/43/8bf0ffa3d498eeee4c58c212a3905dd6146c01c8dc0b0a046481ca29b18c/greenlet-3.3.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:ed6b402bc74d6557a705e197d47f9063733091ed6357b3de33619d8a8d93ac53", size = 1614917, upload-time = "2026-01-23T16:04:26.276Z" },
+ { url = "https://files.pythonhosted.org/packages/89/90/a3be7a5f378fc6e84abe4dcfb2ba32b07786861172e502388b4c90000d1b/greenlet-3.3.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:59913f1e5ada20fde795ba906916aea25d442abcc0593fba7e26c92b7ad76249", size = 1676092, upload-time = "2026-01-23T15:33:52.176Z" },
+ { url = "https://files.pythonhosted.org/packages/e1/2b/98c7f93e6db9977aaee07eb1e51ca63bd5f779b900d362791d3252e60558/greenlet-3.3.1-cp314-cp314t-win_amd64.whl", hash = "sha256:301860987846c24cb8964bdec0e31a96ad4a2a801b41b4ef40963c1b44f33451", size = 233181, upload-time = "2026-01-23T15:33:00.29Z" },
+]
+
[[package]]
name = "h11"
version = "0.16.0"
@@ -2055,6 +2120,18 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/0c/29/0348de65b8cc732daa3e33e67806420b2ae89bdce2b04af740289c5c6c8c/loguru-0.7.3-py3-none-any.whl", hash = "sha256:31a33c10c8e1e10422bfd431aeb5d351c7cf7fa671e3c4df004162264b28220c", size = 61595, upload-time = "2024-12-06T11:20:54.538Z" },
]
+[[package]]
+name = "mako"
+version = "1.3.10"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "markupsafe" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/9e/38/bd5b78a920a64d708fe6bc8e0a2c075e1389d53bef8413725c63ba041535/mako-1.3.10.tar.gz", hash = "sha256:99579a6f39583fa7e5630a28c3c1f440e4e97a414b80372649c0ce338da2ea28", size = 392474, upload-time = "2025-04-10T12:44:31.16Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/87/fb/99f81ac72ae23375f22b7afdb7642aba97c00a713c217124420147681a2f/mako-1.3.10-py3-none-any.whl", hash = "sha256:baef24a52fc4fc514a0887ac600f9f1cff3d82c61d4d700a1fa84d597b88db59", size = 78509, upload-time = "2025-04-10T12:50:53.297Z" },
+]
+
[[package]]
name = "markdown"
version = "3.10"
@@ -2685,6 +2762,7 @@ source = { editable = "." }
dependencies = [
{ name = "openstef-core" },
{ name = "openstef-models", extra = ["xgb-cpu"] },
+ { name = "optuna" },
]
[package.optional-dependencies]
@@ -2739,6 +2817,7 @@ requires-dist = [
{ name = "openstef-models", extras = ["xgb-cpu"], editable = "packages/openstef-models" },
{ name = "openstef-models", extras = ["xgb-cpu"], marker = "extra == 'all'", editable = "packages/openstef-models" },
{ name = "openstef-models", extras = ["xgb-cpu"], marker = "extra == 'models'", editable = "packages/openstef-models" },
+ { name = "optuna", specifier = ">=4.7.0" },
]
provides-extras = ["all", "beam", "meta", "models"]
@@ -3010,6 +3089,24 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/24/7d/c88d7b15ba8fe5c6b8f93be50fc11795e9fc05386c44afaf6b76fe191f9b/opentelemetry_semantic_conventions-0.59b0-py3-none-any.whl", hash = "sha256:35d3b8833ef97d614136e253c1da9342b4c3c083bbaf29ce31d572a1c3825eed", size = 207954, upload-time = "2025-10-16T08:35:48.054Z" },
]
+[[package]]
+name = "optuna"
+version = "4.7.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "alembic" },
+ { name = "colorlog" },
+ { name = "numpy" },
+ { name = "packaging" },
+ { name = "pyyaml" },
+ { name = "sqlalchemy" },
+ { name = "tqdm" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/58/b2/b5e12de7b4486556fe2257611b55dbabf30d0300bdb031831aa943ad20e4/optuna-4.7.0.tar.gz", hash = "sha256:d91817e2079825557bd2e97de2e8c9ae260bfc99b32712502aef8a5095b2d2c0", size = 479740, upload-time = "2026-01-19T05:45:52.604Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/75/d1/6c8a4fbb38a9e3565f5c36b871262a85ecab3da48120af036b1e4937a15c/optuna-4.7.0-py3-none-any.whl", hash = "sha256:e41ec84018cecc10eabf28143573b1f0bde0ba56dba8151631a590ecbebc1186", size = 413894, upload-time = "2026-01-19T05:45:50.815Z" },
+]
+
[[package]]
name = "optype"
version = "0.14.0"
@@ -4774,6 +4871,48 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/52/a7/d2782e4e3f77c8450f727ba74a8f12756d5ba823d81b941f1b04da9d033a/sphinxcontrib_serializinghtml-2.0.0-py3-none-any.whl", hash = "sha256:6e2cb0eef194e10c27ec0023bfeb25badbbb5868244cf5bc5bdc04e4464bf331", size = 92072, upload-time = "2024-07-29T01:10:08.203Z" },
]
+[[package]]
+name = "sqlalchemy"
+version = "2.0.46"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "greenlet", marker = "platform_machine == 'AMD64' or platform_machine == 'WIN32' or platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'ppc64le' or platform_machine == 'win32' or platform_machine == 'x86_64'" },
+ { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/06/aa/9ce0f3e7a9829ead5c8ce549392f33a12c4555a6c0609bb27d882e9c7ddf/sqlalchemy-2.0.46.tar.gz", hash = "sha256:cf36851ee7219c170bb0793dbc3da3e80c582e04a5437bc601bfe8c85c9216d7", size = 9865393, upload-time = "2026-01-21T18:03:45.119Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/b6/35/d16bfa235c8b7caba3730bba43e20b1e376d2224f407c178fbf59559f23e/sqlalchemy-2.0.46-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3a9a72b0da8387f15d5810f1facca8f879de9b85af8c645138cba61ea147968c", size = 2153405, upload-time = "2026-01-21T19:05:54.143Z" },
+ { url = "https://files.pythonhosted.org/packages/06/6c/3192e24486749862f495ddc6584ed730c0c994a67550ec395d872a2ad650/sqlalchemy-2.0.46-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2347c3f0efc4de367ba00218e0ae5c4ba2306e47216ef80d6e31761ac97cb0b9", size = 3334702, upload-time = "2026-01-21T18:46:45.384Z" },
+ { url = "https://files.pythonhosted.org/packages/ea/a2/b9f33c8d68a3747d972a0bb758c6b63691f8fb8a49014bc3379ba15d4274/sqlalchemy-2.0.46-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9094c8b3197db12aa6f05c51c05daaad0a92b8c9af5388569847b03b1007fb1b", size = 3347664, upload-time = "2026-01-21T18:40:09.979Z" },
+ { url = "https://files.pythonhosted.org/packages/aa/d2/3e59e2a91eaec9db7e8dc6b37b91489b5caeb054f670f32c95bcba98940f/sqlalchemy-2.0.46-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:37fee2164cf21417478b6a906adc1a91d69ae9aba8f9533e67ce882f4bb1de53", size = 3277372, upload-time = "2026-01-21T18:46:47.168Z" },
+ { url = "https://files.pythonhosted.org/packages/dd/dd/67bc2e368b524e2192c3927b423798deda72c003e73a1e94c21e74b20a85/sqlalchemy-2.0.46-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b1e14b2f6965a685c7128bd315e27387205429c2e339eeec55cb75ca4ab0ea2e", size = 3312425, upload-time = "2026-01-21T18:40:11.548Z" },
+ { url = "https://files.pythonhosted.org/packages/43/82/0ecd68e172bfe62247e96cb47867c2d68752566811a4e8c9d8f6e7c38a65/sqlalchemy-2.0.46-cp312-cp312-win32.whl", hash = "sha256:412f26bb4ba942d52016edc8d12fb15d91d3cd46b0047ba46e424213ad407bcb", size = 2113155, upload-time = "2026-01-21T18:42:49.748Z" },
+ { url = "https://files.pythonhosted.org/packages/bc/2a/2821a45742073fc0331dc132552b30de68ba9563230853437cac54b2b53e/sqlalchemy-2.0.46-cp312-cp312-win_amd64.whl", hash = "sha256:ea3cd46b6713a10216323cda3333514944e510aa691c945334713fca6b5279ff", size = 2140078, upload-time = "2026-01-21T18:42:51.197Z" },
+ { url = "https://files.pythonhosted.org/packages/b3/4b/fa7838fe20bb752810feed60e45625a9a8b0102c0c09971e2d1d95362992/sqlalchemy-2.0.46-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:93a12da97cca70cea10d4b4fc602589c4511f96c1f8f6c11817620c021d21d00", size = 2150268, upload-time = "2026-01-21T19:05:56.621Z" },
+ { url = "https://files.pythonhosted.org/packages/46/c1/b34dccd712e8ea846edf396e00973dda82d598cb93762e55e43e6835eba9/sqlalchemy-2.0.46-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:af865c18752d416798dae13f83f38927c52f085c52e2f32b8ab0fef46fdd02c2", size = 3276511, upload-time = "2026-01-21T18:46:49.022Z" },
+ { url = "https://files.pythonhosted.org/packages/96/48/a04d9c94753e5d5d096c628c82a98c4793b9c08ca0e7155c3eb7d7db9f24/sqlalchemy-2.0.46-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8d679b5f318423eacb61f933a9a0f75535bfca7056daeadbf6bd5bcee6183aee", size = 3292881, upload-time = "2026-01-21T18:40:13.089Z" },
+ { url = "https://files.pythonhosted.org/packages/be/f4/06eda6e91476f90a7d8058f74311cb65a2fb68d988171aced81707189131/sqlalchemy-2.0.46-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:64901e08c33462acc9ec3bad27fc7a5c2b6491665f2aa57564e57a4f5d7c52ad", size = 3224559, upload-time = "2026-01-21T18:46:50.974Z" },
+ { url = "https://files.pythonhosted.org/packages/ab/a2/d2af04095412ca6345ac22b33b89fe8d6f32a481e613ffcb2377d931d8d0/sqlalchemy-2.0.46-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e8ac45e8f4eaac0f9f8043ea0e224158855c6a4329fd4ee37c45c61e3beb518e", size = 3262728, upload-time = "2026-01-21T18:40:14.883Z" },
+ { url = "https://files.pythonhosted.org/packages/31/48/1980c7caa5978a3b8225b4d230e69a2a6538a3562b8b31cea679b6933c83/sqlalchemy-2.0.46-cp313-cp313-win32.whl", hash = "sha256:8d3b44b3d0ab2f1319d71d9863d76eeb46766f8cf9e921ac293511804d39813f", size = 2111295, upload-time = "2026-01-21T18:42:52.366Z" },
+ { url = "https://files.pythonhosted.org/packages/2d/54/f8d65bbde3d877617c4720f3c9f60e99bb7266df0d5d78b6e25e7c149f35/sqlalchemy-2.0.46-cp313-cp313-win_amd64.whl", hash = "sha256:77f8071d8fbcbb2dd11b7fd40dedd04e8ebe2eb80497916efedba844298065ef", size = 2137076, upload-time = "2026-01-21T18:42:53.924Z" },
+ { url = "https://files.pythonhosted.org/packages/56/ba/9be4f97c7eb2b9d5544f2624adfc2853e796ed51d2bb8aec90bc94b7137e/sqlalchemy-2.0.46-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a1e8cc6cc01da346dc92d9509a63033b9b1bda4fed7a7a7807ed385c7dccdc10", size = 3556533, upload-time = "2026-01-21T18:33:06.636Z" },
+ { url = "https://files.pythonhosted.org/packages/20/a6/b1fc6634564dbb4415b7ed6419cdfeaadefd2c39cdab1e3aa07a5f2474c2/sqlalchemy-2.0.46-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:96c7cca1a4babaaf3bfff3e4e606e38578856917e52f0384635a95b226c87764", size = 3523208, upload-time = "2026-01-21T18:45:08.436Z" },
+ { url = "https://files.pythonhosted.org/packages/a1/d8/41e0bdfc0f930ff236f86fccd12962d8fa03713f17ed57332d38af6a3782/sqlalchemy-2.0.46-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:b2a9f9aee38039cf4755891a1e50e1effcc42ea6ba053743f452c372c3152b1b", size = 3464292, upload-time = "2026-01-21T18:33:08.208Z" },
+ { url = "https://files.pythonhosted.org/packages/f0/8b/9dcbec62d95bea85f5ecad9b8d65b78cc30fb0ffceeb3597961f3712549b/sqlalchemy-2.0.46-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:db23b1bf8cfe1f7fda19018e7207b20cdb5168f83c437ff7e95d19e39289c447", size = 3473497, upload-time = "2026-01-21T18:45:10.552Z" },
+ { url = "https://files.pythonhosted.org/packages/e9/f8/5ecdfc73383ec496de038ed1614de9e740a82db9ad67e6e4514ebc0708a3/sqlalchemy-2.0.46-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:56bdd261bfd0895452006d5316cbf35739c53b9bb71a170a331fa0ea560b2ada", size = 2152079, upload-time = "2026-01-21T19:05:58.477Z" },
+ { url = "https://files.pythonhosted.org/packages/e5/bf/eba3036be7663ce4d9c050bc3d63794dc29fbe01691f2bf5ccb64e048d20/sqlalchemy-2.0.46-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:33e462154edb9493f6c3ad2125931e273bbd0be8ae53f3ecd1c161ea9a1dd366", size = 3272216, upload-time = "2026-01-21T18:46:52.634Z" },
+ { url = "https://files.pythonhosted.org/packages/05/45/1256fb597bb83b58a01ddb600c59fe6fdf0e5afe333f0456ed75c0f8d7bd/sqlalchemy-2.0.46-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9bcdce05f056622a632f1d44bb47dbdb677f58cad393612280406ce37530eb6d", size = 3277208, upload-time = "2026-01-21T18:40:16.38Z" },
+ { url = "https://files.pythonhosted.org/packages/d9/a0/2053b39e4e63b5d7ceb3372cface0859a067c1ddbd575ea7e9985716f771/sqlalchemy-2.0.46-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:8e84b09a9b0f19accedcbeff5c2caf36e0dd537341a33aad8d680336152dc34e", size = 3221994, upload-time = "2026-01-21T18:46:54.622Z" },
+ { url = "https://files.pythonhosted.org/packages/1e/87/97713497d9502553c68f105a1cb62786ba1ee91dea3852ae4067ed956a50/sqlalchemy-2.0.46-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:4f52f7291a92381e9b4de9050b0a65ce5d6a763333406861e33906b8aa4906bf", size = 3243990, upload-time = "2026-01-21T18:40:18.253Z" },
+ { url = "https://files.pythonhosted.org/packages/a8/87/5d1b23548f420ff823c236f8bea36b1a997250fd2f892e44a3838ca424f4/sqlalchemy-2.0.46-cp314-cp314-win32.whl", hash = "sha256:70ed2830b169a9960193f4d4322d22be5c0925357d82cbf485b3369893350908", size = 2114215, upload-time = "2026-01-21T18:42:55.232Z" },
+ { url = "https://files.pythonhosted.org/packages/3a/20/555f39cbcf0c10cf452988b6a93c2a12495035f68b3dbd1a408531049d31/sqlalchemy-2.0.46-cp314-cp314-win_amd64.whl", hash = "sha256:3c32e993bc57be6d177f7d5d31edb93f30726d798ad86ff9066d75d9bf2e0b6b", size = 2139867, upload-time = "2026-01-21T18:42:56.474Z" },
+ { url = "https://files.pythonhosted.org/packages/3e/f0/f96c8057c982d9d8a7a68f45d69c674bc6f78cad401099692fe16521640a/sqlalchemy-2.0.46-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4dafb537740eef640c4d6a7c254611dca2df87eaf6d14d6a5fca9d1f4c3fc0fa", size = 3561202, upload-time = "2026-01-21T18:33:10.337Z" },
+ { url = "https://files.pythonhosted.org/packages/d7/53/3b37dda0a5b137f21ef608d8dfc77b08477bab0fe2ac9d3e0a66eaeab6fc/sqlalchemy-2.0.46-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:42a1643dc5427b69aca967dae540a90b0fbf57eaf248f13a90ea5930e0966863", size = 3526296, upload-time = "2026-01-21T18:45:12.657Z" },
+ { url = "https://files.pythonhosted.org/packages/33/75/f28622ba6dde79cd545055ea7bd4062dc934e0621f7b3be2891f8563f8de/sqlalchemy-2.0.46-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:ff33c6e6ad006bbc0f34f5faf941cfc62c45841c64c0a058ac38c799f15b5ede", size = 3470008, upload-time = "2026-01-21T18:33:11.725Z" },
+ { url = "https://files.pythonhosted.org/packages/a9/42/4afecbbc38d5e99b18acef446453c76eec6fbd03db0a457a12a056836e22/sqlalchemy-2.0.46-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:82ec52100ec1e6ec671563bbd02d7c7c8d0b9e71a0723c72f22ecf52d1755330", size = 3476137, upload-time = "2026-01-21T18:45:15.001Z" },
+ { url = "https://files.pythonhosted.org/packages/fc/a1/9c4efa03300926601c19c18582531b45aededfb961ab3c3585f1e24f120b/sqlalchemy-2.0.46-py3-none-any.whl", hash = "sha256:f9c11766e7e7c0a2767dda5acb006a118640c9fc0a4104214b96269bfb78399e", size = 1937882, upload-time = "2026-01-21T18:22:10.456Z" },
+]
+
[[package]]
name = "sqlparse"
version = "0.5.3"