diff --git a/README.md b/README.md index a040282..b0947ec 100644 --- a/README.md +++ b/README.md @@ -10,12 +10,14 @@ million names from the Democratic Republic of Congo (DRC) annotated with gender ### Installation & Setup -**Unix based** ```bash -curl -LsSf https://astral.sh/uv/install.sh | sh - git clone https://github.com/bernard-ng/drc-ners-nlp.git cd drc-ners-nlp +``` + +**Linux** +```bash +curl -LsSf https://astral.sh/uv/install.sh | sh uv sync ``` @@ -23,12 +25,9 @@ uv sync **Macos & windows** ```bash docker compose build -docker compose run --rm app -docker compose run --rm app ners pipeline run --env=production -docker compose run --rm app ners research train --name=lightgbm --type=baseline --env=production -docker compose run --rm --service-ports app ners web run --env=production +docker compose exec app bash ``` - +s ## Data Processing This project includes a robust data processing pipeline designed to handle large datasets efficiently with batching, @@ -118,6 +117,10 @@ experiments and make predictions without needing to understand the underlying co uv run ners web run --env="production" ``` +```bash +docker compose run --rm --service-ports app ners web run --env=production +``` + ## Contributors diff --git a/assets/distribution_grid.png b/assets/distribution_grid.png index 9bb7237..3aca588 100644 Binary files a/assets/distribution_grid.png and b/assets/distribution_grid.png differ diff --git a/assets/distribution_grid.svg b/assets/distribution_grid.svg index 2dc75db..5959f1b 100644 --- a/assets/distribution_grid.svg +++ b/assets/distribution_grid.svg @@ -6,11 +6,11 @@ - 2025-09-28T23:42:03.900801 + 2025-10-05T23:19:48.322300 image/svg+xml - Matplotlib v3.10.3, https://matplotlib.org/ + Matplotlib v3.10.6, https://matplotlib.org/ @@ -29,957 +29,900 @@ z " style="fill: #ffffff"/> - - - +" style="fill: #1f77b4"/> - +" style="fill: #ff7f0e"/> + + - + - - - - - - - - - - - - + + + + + + - + - - - - - - - - - + + + + + - + - - - - - - - - - - + + + + + + + - + - - - - - - - + + + + + - + - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + - - - +" style="fill: #1f77b4"/> - +" style="fill: #ff7f0e"/> + + - + - - - - - + + + + - + - - - - - - + + + + + - + - - - - - - - + + + + + + - + - - - - - - - + + + + + - + - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + diff --git a/assets/identified_category_distribution_by_province.png b/assets/identified_category_distribution_by_province.png index a832385..a95d3ad 100644 Binary files a/assets/identified_category_distribution_by_province.png and b/assets/identified_category_distribution_by_province.png differ diff --git a/assets/identified_category_distribution_by_province.svg b/assets/identified_category_distribution_by_province.svg index 5bc9294..7750498 100644 --- a/assets/identified_category_distribution_by_province.svg +++ b/assets/identified_category_distribution_by_province.svg @@ -6,11 +6,11 @@ - 2025-09-28T23:42:04.307504 + 2025-10-05T23:19:50.456372 image/svg+xml - Matplotlib v3.10.3, https://matplotlib.org/ + Matplotlib v3.10.6, https://matplotlib.org/ @@ -30,1724 +30,1668 @@ z - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + + + + + + + + + - + - - + - - + + + + + + + - + - - - + + - - + + + + + + + - + - - - + + - - + + + + + + + - + - - - + + - - + + + + + + + - + - - - + + - - + + + + + + + - + - - - - + + + - + - - - - - - - - - + - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + - - + + + + + + + - + - - - - - - - - - - - - + + + + + + - - + + + + - + - - - - - - - - - - - + + + + + + + + - - + + + + - + - - - - - - - - - - - - - + + + + + + + + + - - + + + + - + - - - - - - - - - + + + + + + + + - - + + + + - + - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + - - + + + + - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + - - + + + + - - - - - - - - + + + + + + + + - - + + + + - + - - - - - - - - - + + + + + + + + - - + + + + - + - - - - - - - - + + + + + + + - - + + + + - + - - - - - - - - - - + + + + + + + + + - - + + + + - - - - - - - - - - + + + + + + + + + + - - + + + + - - - - - - - - - + + + + + + + + + - + - - - - - - - - - - - + + + + + + + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + - + - + - + - - + - - - - - - - - - - - + + + + + + + + - +" style="fill: #3182bd"/> - + - - - - - - - - - + + + + + + + - +" style="fill: #d9d9d9"/> - + - - - - - - - + + + + + + - - + + diff --git a/assets/name_by_gender_distribution_grid.png b/assets/name_by_gender_distribution_grid.png index a2cfe1f..5dbeaaf 100644 Binary files a/assets/name_by_gender_distribution_grid.png and b/assets/name_by_gender_distribution_grid.png differ diff --git a/assets/name_by_gender_distribution_grid.svg b/assets/name_by_gender_distribution_grid.svg index 43472ac..1c7ccfc 100644 --- a/assets/name_by_gender_distribution_grid.svg +++ b/assets/name_by_gender_distribution_grid.svg @@ -6,11 +6,11 @@ - 2025-09-28T23:43:05.966790 + 2025-10-05T22:52:00.716620 image/svg+xml - Matplotlib v3.10.3, https://matplotlib.org/ + Matplotlib v3.10.6, https://matplotlib.org/ @@ -29,1103 +29,1036 @@ z " style="fill: #ffffff"/> - - - +" style="fill: #1f77b4"/> - +" style="fill: #ff7f0e"/> - +" style="fill: #2ca02c"/> + + - + - - - - - - + - - - - - - - - - - - + + + + + + + + + - + - - - - - - - - - - + + + + + - + - - - - - - - - - - - - - + + + + + + + + + + + - + - - - - - - - - + + + + + - + - - - - - - - - - - + + + + + + - + - - - - - - + + + + + - + - + + + + + + + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - +" style="fill: #1f77b4"/> - +" style="fill: #ff7f0e"/> - +" style="fill: #2ca02c"/> + + - - - - - - - - - - + + + + + + + + + + - + - - - - - - + + + + + - - - - - - - - - - - - + + + + + + + + + + + + - - - - - - + + + + + + - - - - - - - + + + + + + + - - - - - - + + + + + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/assets/regions-clusters-readable.png b/assets/regions-clusters-readable.png index 25e2f52..0f1e5df 100644 Binary files a/assets/regions-clusters-readable.png and b/assets/regions-clusters-readable.png differ diff --git a/config/gpu_research_templates.yaml b/config/gpu_research_templates.yaml deleted file mode 100644 index c309415..0000000 --- a/config/gpu_research_templates.yaml +++ /dev/null @@ -1,412 +0,0 @@ -baseline_experiments: - # BiGRU Models (GPU-enabled) - - name: "bigru" - description: "Baseline BiGRU with full name features (GPU)" - model_type: "bigru" - features: [ "full_name" ] - model_params: - embedding_dim: 64 - gru_units: 32 - epochs: 2 - batch_size: 32 - use_gpu: true - mixed_precision: true - tags: [ "baseline", "neural", "bigru", "gpu" ] - - - name: "bigru_native" - description: "Baseline BiGRU with native name features (GPU)" - model_type: "bigru" - features: [ "native_name" ] - model_params: - embedding_dim: 64 - gru_units: 32 - epochs: 2 - batch_size: 32 - use_gpu: true - mixed_precision: true - tags: [ "baseline", "neural", "bigru", "native", "gpu" ] - - - name: "bigru_surname" - description: "Baseline BiGRU with surname features (GPU)" - model_type: "bigru" - features: [ "surname" ] - model_params: - embedding_dim: 64 - gru_units: 32 - epochs: 2 - batch_size: 32 - use_gpu: true - mixed_precision: true - tags: [ "baseline", "neural", "bigru", "surname", "gpu" ] - - ## CNN Models (GPU-enabled) - - name: "cnn" - description: "Baseline CNN with character patterns (GPU)" - model_type: "cnn" - features: [ "full_name" ] - model_params: - embedding_dim: 64 - filters: 64 - kernel_size: 3 - dropout: 0.5 - epochs: 2 - batch_size: 32 - use_gpu: true - mixed_precision: true - tags: [ "baseline", "neural", "cnn", "gpu" ] - - - name: "cnn_native" - description: "Baseline CNN with native name character patterns (GPU)" - model_type: "cnn" - features: [ "native_name" ] - model_params: - embedding_dim: 64 - filters: 64 - kernel_size: 3 - dropout: 0.5 - epochs: 2 - batch_size: 32 - use_gpu: true - mixed_precision: true - tags: [ "baseline", "neural", "cnn", "native", "gpu" ] - - - name: "cnn_surname" - description: "Baseline CNN with surname character patterns (GPU)" - model_type: "cnn" - features: [ "surname" ] - model_params: - embedding_dim: 64 - filters: 64 - kernel_size: 3 - dropout: 0.5 - epochs: 2 - batch_size: 32 - use_gpu: true - mixed_precision: true - tags: [ "baseline", "neural", "cnn", "surname", "gpu" ] - - ## Ensemble Models (CPU) - - name: "ensemble" - description: "Baseline Ensemble with multiple models" - model_type: "ensemble" - features: [ "full_name" ] - model_params: - base_models: [ "logistic_regression", "random_forest", "xgboost" ] - voting: "soft" - cv_folds: 5 - tags: [ "baseline", "ensemble" ] - - - name: "ensemble_native" - description: "Baseline Ensemble with native name" - model_type: "ensemble" - features: [ "native_name" ] - model_params: - base_models: [ "logistic_regression", "random_forest", "xgboost" ] - voting: "soft" - cv_folds: 5 - tags: [ "baseline", "ensemble", "native" ] - - - name: "ensemble_surname" - description: "Baseline Ensemble with surname" - model_type: "ensemble" - features: [ "surname" ] - model_params: - base_models: [ "logistic_regression", "random_forest", "xgboost" ] - voting: "soft" - cv_folds: 5 - tags: [ "baseline", "ensemble", "surname" ] - - # LightGBM Models (GPU-enabled) - - name: "lightgbm" - description: "Baseline LightGBM with engineered features (GPU)" - model_type: "lightgbm" - features: [ "full_name" ] - model_params: - n_estimators: 100 - max_depth: -1 - learning_rate: 0.1 - num_leaves: 31 - subsample: 0.8 - colsample_bytree: 0.8 - use_gpu: true - tags: [ "baseline", "lightgbm", "gpu" ] - - - name: "lightgbm_native" - description: "Baseline LightGBM with native name features (GPU)" - model_type: "lightgbm" - features: [ "native_name" ] - model_params: - n_estimators: 100 - max_depth: -1 - learning_rate: 0.1 - num_leaves: 31 - subsample: 0.8 - colsample_bytree: 0.8 - use_gpu: true - tags: [ "baseline", "lightgbm", "native", "gpu" ] - - - name: "lightgbm_surname" - description: "Baseline LightGBM with surname features (GPU)" - model_type: "lightgbm" - features: [ "surname" ] - model_params: - n_estimators: 100 - max_depth: -1 - learning_rate: 0.1 - num_leaves: 31 - subsample: 0.8 - colsample_bytree: 0.8 - use_gpu: true - tags: [ "baseline", "lightgbm", "surname", "gpu" ] - - # Logistic Regression Models (CPU) - - name: "logistic_regression" - description: "Baseline logistic regression with full name" - model_type: "logistic_regression" - features: [ "full_name" ] - model_params: - max_features: 10000 - tags: [ "baseline", "logistic_regression", "fullname" ] - - - name: "logistic_regression_native" - description: "Logistic regression with native name only" - model_type: "logistic_regression" - features: [ "native_name" ] - model_params: - max_features: 5000 - tags: [ "baseline", "logistic_regression", "native" ] - - - name: "logistic_regression_surname" - description: "Logistic regression with surname name only" - model_type: "logistic_regression" - features: [ "surname" ] - model_params: - max_features: 5000 - tags: [ "baseline", "logistic_regression", "surname" ] - - # LSTM Models (GPU-enabled) - - name: "lstm" - description: "Baseline LSTM with full name features (GPU)" - model_type: "lstm" - features: [ "full_name" ] - model_params: - embedding_dim: 128 - lstm_units: 64 - epochs: 2 - batch_size: 64 - use_gpu: true - mixed_precision: true - tags: [ "baseline", "neural", "lstm", "gpu" ] - - - name: "lstm_native" - description: "Baseline LSTM with native name features (GPU)" - model_type: "lstm" - features: [ "native_name" ] - model_params: - embedding_dim: 128 - lstm_units: 64 - epochs: 2 - batch_size: 64 - use_gpu: true - mixed_precision: true - tags: [ "baseline", "neural", "lstm", "native", "gpu" ] - - - name: "lstm_surname" - description: "Baseline LSTM with surname features (GPU)" - model_type: "lstm" - features: [ "surname" ] - model_params: - embedding_dim: 128 - lstm_units: 64 - epochs: 2 - batch_size: 64 - use_gpu: true - mixed_precision: true - tags: [ "baseline", "neural", "lstm", "surname", "gpu" ] - - # Naive Bayes Models (CPU) - - name: "naive_bayes" - description: "Baseline Naive Bayes with full name features" - model_type: "naive_bayes" - features: [ "full_name" ] - model_params: - max_features: 5000 - tags: [ "baseline", "naive_bayes" ] - - - name: "naive_bayes_native" - description: "Baseline Naive Bayes with native name features" - model_type: "naive_bayes" - features: [ "native_name" ] - model_params: - max_features: 5000 - tags: [ "baseline", "naive_bayes", "native" ] - - - name: "naive_bayes_surname" - description: "Baseline Naive Bayes with surname features" - model_type: "naive_bayes" - features: [ "surname" ] - model_params: - max_features: 5000 - tags: [ "baseline", "naive_bayes", "surname" ] - - # Random Forest Models (CPU) - - name: "random_forest" - description: "Baseline Random Forest with engineered features" - model_type: "random_forest" - features: [ "full_name" ] - model_params: - n_estimators: 100 - max_depth: 10 - min_samples_split: 2 - min_samples_leaf: 1 - tags: [ "baseline", "random_forest", "engineered" ] - - - name: "random_forest_native" - description: "Baseline Random Forest with native name engineered features" - model_type: "random_forest" - features: [ "native_name" ] - model_params: - n_estimators: 100 - max_depth: 10 - min_samples_split: 2 - min_samples_leaf: 1 - tags: [ "baseline", "random_forest", "engineered", "native" ] - - - name: "random_forest_surname" - description: "Baseline Random Forest with surname engineered features" - model_type: "random_forest" - features: [ "surname" ] - model_params: - n_estimators: 100 - max_depth: 10 - min_samples_split: 2 - min_samples_leaf: 1 - tags: [ "baseline", "random_forest", "engineered", "surname" ] - - # SVM Models (CPU) - - name: "svm" - description: "Baseline SVM with full name features" - model_type: "svm" - features: [ "full_name" ] - model_params: - C: 1.0 - kernel: "rbf" - ngram_range: [ 2, 4 ] - max_features: 5000 - tags: [ "baseline", "svm" ] - - - name: "svm_native" - description: "Baseline SVM with native name features" - model_type: "svm" - features: [ "native_name" ] - model_params: - C: 1.0 - kernel: "rbf" - ngram_range: [ 2, 4 ] - max_features: 5000 - tags: [ "baseline", "svm", "native" ] - - - name: "svm_surname" - description: "Baseline SVM with surname features" - model_type: "svm" - features: [ "surname" ] - model_params: - C: 1.0 - kernel: "rbf" - ngram_range: [ 2, 4 ] - max_features: 5000 - tags: [ "baseline", "svm", "surname" ] - - # Transformer Models (GPU-enabled) - - name: "transformer" - description: "Baseline Transformer with attention mechanism (GPU)" - model_type: "transformer" - features: [ "full_name" ] - model_params: - embedding_dim: 128 - num_heads: 4 - num_layers: 2 - epochs: 2 - batch_size: 64 - use_gpu: true - mixed_precision: true - tags: [ "baseline", "neural", "transformer", "gpu" ] - - - name: "transformer_native" - description: "Baseline Transformer with native name attention mechanism (GPU)" - model_type: "transformer" - features: [ "native_name" ] - model_params: - embedding_dim: 128 - num_heads: 4 - num_layers: 2 - epochs: 2 - batch_size: 64 - use_gpu: true - mixed_precision: true - tags: [ "baseline", "neural", "transformer", "native", "gpu" ] - - - name: "transformer_surname" - description: "Baseline Transformer with surname attention mechanism (GPU)" - model_type: "transformer" - features: [ "surname" ] - model_params: - embedding_dim: 128 - num_heads: 4 - num_layers: 2 - epochs: 2 - batch_size: 64 - use_gpu: true - mixed_precision: true - tags: [ "baseline", "neural", "transformer", "surname", "gpu" ] - - # XGBoost Models (GPU-enabled) - - name: "xgboost" - description: "Baseline XGBoost with engineered features (GPU)" - model_type: "xgboost" - features: [ "full_name" ] - model_params: - n_estimators: 100 - max_depth: 6 - learning_rate: 0.1 - subsample: 0.8 - colsample_bytree: 0.8 - use_gpu: true - tags: [ "baseline", "xgboost", "gpu" ] - - - name: "xgboost_native" - description: "Baseline XGBoost with native name engineered features (GPU)" - model_type: "xgboost" - features: [ "native_name" ] - model_params: - n_estimators: 100 - max_depth: 6 - learning_rate: 0.1 - subsample: 0.8 - colsample_bytree: 0.8 - use_gpu: true - tags: [ "baseline", "xgboost", "native", "gpu" ] - - - name: "xgboost_surname" - description: "Baseline XGBoost with surname engineered features (GPU)" - model_type: "xgboost" - features: [ "surname" ] - model_params: - n_estimators: 100 - max_depth: 6 - learning_rate: 0.1 - subsample: 0.8 - colsample_bytree: 0.8 - use_gpu: true - tags: [ "baseline", "xgboost", "surname", "gpu" ] - - -# Advanced Experiments Configuration -advanced_experiments: - -# Feature Study Configurations -feature_studies: - -# Hyperparameter Tuning Configurations -hyperparameter_tuning: - diff --git a/config/research_templates.yaml b/config/research_templates.yaml index c436401..843af35 100644 --- a/config/research_templates.yaml +++ b/config/research_templates.yaml @@ -73,37 +73,6 @@ baseline_experiments: batch_size: 32 tags: [ "baseline", "neural", "cnn", "surname" ] - ## Ensemble Models - - name: "ensemble" - description: "Baseline Ensemble with multiple models" - model_type: "ensemble" - features: [ "full_name" ] - model_params: - base_models: [ "logistic_regression", "random_forest", "xgboost" ] - voting: "soft" - cv_folds: 5 - tags: [ "baseline", "ensemble" ] - - - name: "ensemble_native" - description: "Baseline Ensemble with native name" - model_type: "ensemble" - features: [ "native_name" ] - model_params: - base_models: [ "logistic_regression", "random_forest", "xgboost" ] - voting: "soft" - cv_folds: 5 - tags: [ "baseline", "ensemble", "native" ] - - - name: "ensemble_surname" - description: "Baseline Ensemble with surname" - model_type: "ensemble" - features: [ "surname" ] - model_params: - base_models: [ "logistic_regression", "random_forest", "xgboost" ] - voting: "soft" - cv_folds: 5 - tags: [ "baseline", "ensemble", "surname" ] - # LightGBM Models - name: "lightgbm" description: "Baseline LightGBM with engineered features" @@ -262,40 +231,6 @@ baseline_experiments: min_samples_leaf: 1 tags: [ "baseline", "random_forest", "engineered", "surname" ] - # SVM Models - - name: "svm" - description: "Baseline SVM with full name features" - model_type: "svm" - features: [ "full_name" ] - model_params: - C: 1.0 - kernel: "rbf" - ngram_range: [ 2, 4 ] - max_features: 5000 - tags: [ "baseline", "svm" ] - - - name: "svm_native" - description: "Baseline SVM with native name features" - model_type: "svm" - features: [ "native_name" ] - model_params: - C: 1.0 - kernel: "rbf" - ngram_range: [ 2, 4 ] - max_features: 5000 - tags: [ "baseline", "svm", "native" ] - - - name: "svm_surname" - description: "Baseline SVM with surname features" - model_type: "svm" - features: [ "surname" ] - model_params: - C: 1.0 - kernel: "rbf" - ngram_range: [ 2, 4 ] - max_features: 5000 - tags: [ "baseline", "svm", "surname" ] - # Transformer Models - name: "transformer" description: "Baseline Transformer with attention mechanism" diff --git a/pyproject.toml b/pyproject.toml index d51dd97..97b315e 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -24,6 +24,7 @@ dependencies = [ "typer>=0.19.2", "tensorflow==2.20.0; sys_platform == 'linux' and platform_machine == 'x86_64'", "xgboost>=3.0.5", + "networkx>=3.5", ] [project.scripts] @@ -35,5 +36,6 @@ build-backend = "uv_build" [dependency-groups] dev = [ + "ipykernel>=6.30.1", "ruff>=0.13.3", ] diff --git a/src/notebooks/eda.ipynb b/src/notebooks/eda.ipynb index 9f7e652..2328058 100644 --- a/src/notebooks/eda.ipynb +++ b/src/notebooks/eda.ipynb @@ -2,7 +2,22 @@ "cells": [ { "cell_type": "code", - "execution_count": null, + "execution_count": 1, + "id": "9a8891ca", + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import geopandas as gpd\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "import sys\n", + "import os" + ] + }, + { + "cell_type": "code", + "execution_count": 2, "id": "c93a55c8", "metadata": { "ExecuteTime": { @@ -12,21 +27,16 @@ }, "outputs": [], "source": [ - "import pandas as pd\n", - "import geopandas as gpd\n", - "import matplotlib.pyplot as plt\n", - "import seaborn as sns\n", - "import sys\n", - "import os\n", - "\n", "sys.path.append(os.path.abspath(\"..\"))\n", + "\n", + "from ners.core.config import setup_config\n", "from ners.core.utils.data_loader import DataLoader\n", "from ners.core.config.pipeline_config import PipelineConfig" ] }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 3, "id": "c0b00261", "metadata": { "ExecuteTime": { @@ -34,26 +44,27 @@ "start_time": "2025-09-21T12:37:00.288721Z" } }, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:root:Config file not found: config/pipeline.development.yaml. Using defaults.\n", + "2025-10-05 22:52:21,813 - root - INFO - Ensured all required directories exist\n", + "2025-10-05 22:52:21,821 - root - INFO - Loaded configuration: drc_names_pipeline v1.0.0\n", + "2025-10-05 22:52:21,829 - root - INFO - Environment: development\n", + "2025-10-05 22:52:21,834 - root - INFO - Config file: config/pipeline.development.yaml\n" + ] + } + ], "source": [ - "config = PipelineConfig(\n", - " paths={\n", - " \"root_dir\": \"../data\",\n", - " \"data_dir\": \"../data/dataset\",\n", - " \"models_dir\": \"../models\",\n", - " \"outputs_dir\": \"../data/processed\",\n", - " \"logs_dir\": \"../logs\",\n", - " \"configs_dir\": \"../configs\",\n", - " \"checkpoints_dir\": \"../checkpoints\",\n", - " }\n", - ")\n", - "\n", + "config = setup_config()\n", "loader = DataLoader(config)" ] }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 4, "id": "b38394ce38864379", "metadata": { "ExecuteTime": { @@ -61,9 +72,19 @@ "start_time": "2025-09-21T13:07:48.219021Z" } }, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-10-05 22:52:40,492 - root - INFO - Reading /Users/bernard-ng/dev/community/analysis/drc-ners-nlp/data/dataset/names_featured.csv with encoding: utf-8\n", + "2025-10-05 22:55:58,779 - root - INFO - Successfully read /Users/bernard-ng/dev/community/analysis/drc-ners-nlp/data/dataset/names_featured.csv with encoding: utf-8\n", + "2025-10-05 22:55:58,884 - root - INFO - Concatenating 65 optimized chunks\n" + ] + } + ], "source": [ - "gdf = gpd.read_file(\"../osm/provinces.shp\")\n", + "gdf = gpd.read_file(\"../../assets/osm/provinces.shp\")\n", "gdf_proj = gdf.to_crs(epsg=32732)\n", "gdf[\"centroid\"] = gdf_proj.geometry.centroid.to_crs(gdf.crs)\n", "\n", @@ -80,7 +101,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 5, "id": "dac785a7-1a32-4a1b-b35d-d8b85df60589", "metadata": { "ExecuteTime": { @@ -121,7 +142,7 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 6, "id": "c3f83d00-0606-44ea-a704-fc54d69263b4", "metadata": { "ExecuteTime": { @@ -167,7 +188,7 @@ " POLYGON ((16.03321 -4.98926, 16.02639 -4.98868...\n", " POINT (15.89714 -4.45276)\n", " KINSHASA\n", - " 1122773\n", + " 1140620\n", " \n", " \n", " 1\n", @@ -176,7 +197,7 @@ " POLYGON ((15.64766 -4.91155, 15.6477 -4.91174,...\n", " POINT (14.28812 -5.2961)\n", " BAS-CONGO\n", - " 268119\n", + " 295155\n", " \n", " \n", " 2\n", @@ -212,7 +233,7 @@ " POLYGON ((23.28516 -6.91736, 23.286 -6.91859, ...\n", " POINT (21.62853 -5.4419)\n", " KASAI-OCCIDENTAL\n", - " 362896\n", + " 367626\n", " \n", " \n", " 6\n", @@ -221,7 +242,7 @@ " POLYGON ((23.28042 -7.98622, 23.28018 -7.98616...\n", " POINT (23.94445 -4.54154)\n", " KASAI-ORIENTAL\n", - " 358138\n", + " 434497\n", " \n", " \n", " 7\n", @@ -239,7 +260,7 @@ " POLYGON ((23.08876 -0.40575, 23.08401 -0.40572...\n", " POINT (26.42917 2.12421)\n", " ORIENTALE\n", - " 317201\n", + " 322756\n", " \n", " \n", " 9\n", @@ -291,20 +312,20 @@ "10 POLYGON ((23.1898 -7.76858, 23.18972 -7.77019,... \n", "\n", " centroid province count \n", - "0 POINT (15.89714 -4.45276) KINSHASA 1122773 \n", - "1 POINT (14.28812 -5.2961) BAS-CONGO 268119 \n", + "0 POINT (15.89714 -4.45276) KINSHASA 1140620 \n", + "1 POINT (14.28812 -5.2961) BAS-CONGO 295155 \n", "2 POINT (28.26546 -3.22633) SUD-KIVU 346152 \n", "3 POINT (28.70741 -0.60502) NORD-KIVU 394999 \n", "4 POINT (26.39038 -3.06735) MANIEMA 127813 \n", - "5 POINT (21.62853 -5.4419) KASAI-OCCIDENTAL 362896 \n", - "6 POINT (23.94445 -4.54154) KASAI-ORIENTAL 358138 \n", + "5 POINT (21.62853 -5.4419) KASAI-OCCIDENTAL 367626 \n", + "6 POINT (23.94445 -4.54154) KASAI-ORIENTAL 434497 \n", "7 POINT (20.63056 1.02935) EQUATEUR 356404 \n", - "8 POINT (26.42917 2.12421) ORIENTALE 317201 \n", + "8 POINT (26.42917 2.12421) ORIENTALE 322756 \n", "9 POINT (18.35771 -4.37828) BANDUNDU 809949 \n", "10 POINT (26.4593 -8.73955) KATANGA 836220 " ] }, - "execution_count": 39, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -315,7 +336,7 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 7, "id": "2f9768a43d053cc7", "metadata": { "ExecuteTime": { @@ -326,7 +347,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -365,7 +386,7 @@ }, { "cell_type": "code", - "execution_count": 58, + "execution_count": 18, "id": "27f6bcd2-f1de-419a-8d56-e29064934e2f", "metadata": { "ExecuteTime": { @@ -376,7 +397,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -395,7 +416,7 @@ }, { "cell_type": "code", - "execution_count": 59, + "execution_count": 19, "id": "d51f3bee-d2a1-46a0-9e0b-af10c1ca7cb4", "metadata": { "ExecuteTime": { @@ -406,7 +427,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA90AAAHpCAYAAACful8UAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjYsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvq6yFwwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAkqlJREFUeJzs3XlcTfn/B/D3rSikUtoQWUOWiFT2Lfu+78tgLNnXbDGGMGQfhhn7zDDG8rUNYx1jGIYRQrJlr0SkaL2v3x/97pnuFCO63ZbX8/G4j+907rl5d773nnten+2oAECIiIiIiIiIKMMZ6LsAIiIiIiIiopyKoZuIiIiIiIhIRxi6iYiIiIiIiHSEoZuIiIiIiIhIRxi6iYiIiIiIiHSEoZuIiIiIiIhIRxi6iYiIiIiIiHSEoZuIiIiIiIhIRxi6iYiIiIiIiHSEoZuIiIiIiIhIR3J16D516pS0adNGihQpIiqVSvbs2ZPu3wFAFi1aJOXKlRNjY2MpWrSozJ07N+OLJSIiIiIiomzHSN8F6FNMTIxUrVpVBg4cKB07dvyo3zF69Gj59ddfZdGiRVK5cmV58eKFvHjxIoMrJSIiIiIiouxIBQD6LiIrUKlUsnv3bmnfvr2yLS4uTqZNmyY//vijvHz5UipVqiQLFiyQBg0aiIjIjRs3pEqVKhIYGChOTk76KZyIiIiIiIiyrFw9vPy/eHt7y9mzZ2Xbtm1y5coV6dKlizRv3lxu3bolIiL79u2TUqVKyf79+6VkyZLi6OgogwYNYk83ERERERERiQhD9zs9ePBANmzYIDt27JC6detK6dKlZcKECVKnTh3ZsGGDiIjcvXtX7t+/Lzt27JDNmzfLxo0b5eLFi9K5c2c9V09ERERERERZQa6e0/0+V69elaSkJClXrpzW9ri4OLGyshIREbVaLXFxcbJ582Zlv++++05cXV3l5s2bHHJORERERESUyzF0v0N0dLQYGhrKxYsXxdDQUOs5U1NTERGxt7cXIyMjrWBeoUIFEUnuKWfoJiIiIiIiyt0Yut+hWrVqkpSUJOHh4VK3bt0096ldu7YkJibKnTt3pHTp0iIiEhwcLCIiJUqUyLRaiYiIiIiIKGvK1auXR0dHy+3bt0UkOWT7+/tLw4YNxdLSUooXLy69e/eWP/74QxYvXizVqlWTZ8+eybFjx6RKlSrSqlUrUavVUrNmTTE1NZWlS5eKWq2WESNGiJmZmfz66696/uuIiIiIiIhI33J16D558qQ0bNgw1fZ+/frJxo0bJSEhQb788kvZvHmzPH78WAoXLizu7u4ye/ZsqVy5soiIPHnyREaOHCm//vqrFChQQFq0aCGLFy8WS0vLzP5ziIiIiIiIKIvJ1aGbiIiIiIiISJd4yzAiIiIiIiIiHcl1C6mp1Wp58uSJFCxYUFQqlb7LISIiIiIiomwIgLx+/VqKFCkiBgbv7s/OdaH7yZMn4uDgoO8yiIiIiIiIKAd4+PChFCtW7J3P57rQXbBgQRFJPjBmZmZ6roaIiIiIiIiyo6ioKHFwcFAy5rvkutCtGVJuZmbG0E1ERERERESf5L+mLXMhNSIiIiIiIiIdYegmIiIiIiIi0hGGbiIiIiIiIiIdYegmIiIiIiIi0hGGbiIiIiIiIiIdYegmIiIiIiIi0hGGbiIiIiIiIiIdYegmIiIiIiIi0hGGbiIiIiIiIiIdYegmIiIiIiIi0hGGbiIiIiIiIiIdYegmIiIiIiIi0hEjfReQ3TlOOaDvEt4pZH4rfZdARERERESUq7Gnm4iIiIiIiEhHGLqJiIiIiIiIdIShm4iIiIiIiEhHGLqJiIiIiIiIdIShm4iIiIiIiEhHGLqJiIiIiIiIdIShm4iIiIiIiEhHGLqJiIiIiIiIdIShm4iIiIiIiEhHGLqJiIiIiIiIdIShm4iIiIiIiEhHGLqJiIiIiIiIdIShm4iIiIiIiEhHGLqJiIiIiIiIdIShm4iIiIiIiEhHGLqJiIiIiIiIdIShm4iIiIiIiEhHGLqJiIiIiIiIdIShm4iIiIiIiEhHGLqJiIiIiIiIdIShm4iIiIiIiEhHGLqJiIiIiIiIdIShm4iIiIiIiEhHGLqJiIiIiIiIdIShm4iIiIiIiEhHGLqJiIiIiIiIdIShm4iIiIiIiEhHjPRdAOU+jlMO6LuENIXMb6XvEoiIiIiIKIdhTzcRERERERGRjjB0ExEREREREekIQzcRERERERGRjjB0ExEREREREekIQzcRERERERGRjjB0ExEREREREemIXkP3qVOnpE2bNlKkSBFRqVSyZ8+e/3zNyZMnpXr16mJsbCxlypSRjRs36rxOIiIiIiIioo+h19AdExMjVatWlVWrVn3Q/vfu3ZNWrVpJw4YNJSAgQMaMGSODBg2Sw4cP67hSIiIiIiIiovQz0uc/3qJFC2nRosUH779mzRopWbKkLF68WEREKlSoIKdPn5YlS5ZIs2bN0nxNXFycxMXFKT9HRUV9WtFEREREREREHyhbzek+e/asNGnSRGtbs2bN5OzZs+98jZ+fn5ibmysPBwcHXZdJREREREREJCLZLHSHhoaKra2t1jZbW1uJioqSt2/fpvkaHx8fefXqlfJ4+PBhZpRKREREREREpN/h5ZnB2NhYjI2N9V0GERERERER5ULZqqfbzs5OwsLCtLaFhYWJmZmZ5MuXT09VEREREREREaUtW4VuDw8POXbsmNa2I0eOiIeHh54qIiIiIiIiIno3vYbu6OhoCQgIkICAABFJviVYQECAPHjwQESS52P37dtX2X/o0KFy9+5dmTRpkgQFBcnXX38tP/30k4wdO1Yf5RMRERERERG9l15D94ULF6RatWpSrVo1EREZN26cVKtWTWbOnCkiIk+fPlUCuIhIyZIl5cCBA3LkyBGpWrWqLF68WL799tt33i6MiIiIiIiISJ/0upBagwYNBMA7n9+4cWOar7l06ZIOqyIiIiIiIiLKGNlqTjcRERERERFRdsLQTURERERERKQjDN1EREREREREOsLQTURERERERKQjDN1EREREREREOsLQTURERERERKQjDN1EREREREREOsLQTURERERERKQjDN1EREREREREOsLQTURERERERKQjDN1EREREREREOsLQTURERERERKQjDN1EREREREREOsLQTURERERERKQjDN1EREREREREOsLQTURERERERKQjDN1EREREREREOsLQTURERERERKQjDN1EREREREREOsLQTURERERERKQjDN1EREREREREOsLQTURERERERKQjDN1EREREREREOsLQTURERERERKQjDN1EREREREREOsLQTURERERERKQjDN1EREREREREOsLQTURERERERKQjDN1EREREREREOsLQTURERERERKQjDN1EREREREREOsLQTURERERERKQjDN1EREREREREOsLQTURERERERKQjDN1EREREREREOsLQTURERERERKQjRvougIj+m+OUA/ouIU0h81vpuwQiIiIioiyNPd1EREREREREOsLQTURERERERKQjDN1EREREREREOsLQTURERERERKQjDN1EREREREREOqL30L1q1SpxdHQUExMTqVWrlpw/f/69+y9dulScnJwkX7584uDgIGPHjpXY2NhMqpaIiIiIiIjow+n1lmHbt2+XcePGyZo1a6RWrVqydOlSadasmdy8eVNsbGxS7f/DDz/IlClTZP369eLp6SnBwcHSv39/UalU4u/vr4e/gIiyIt5ijYiIiIiyCr32dPv7+8vgwYNlwIABUrFiRVmzZo3kz59f1q9fn+b+Z86ckdq1a0vPnj3F0dFRvLy8pEePHv/ZO05ERERERESkD3oL3fHx8XLx4kVp0qTJP8UYGEiTJk3k7Nmzab7G09NTLl68qITsu3fvysGDB6Vly5bv/Hfi4uIkKipK60FERERERESUGfQ2vDwiIkKSkpLE1tZWa7utra0EBQWl+ZqePXtKRESE1KlTRwBIYmKiDB06VKZOnfrOf8fPz09mz56dobUTERERERERfQi9L6SWHidPnpR58+bJ119/LX///bfs2rVLDhw4IHPmzHnna3x8fOTVq1fK4+HDh5lYMREREREREeVmeuvpLly4sBgaGkpYWJjW9rCwMLGzs0vzNTNmzJA+ffrIoEGDRESkcuXKEhMTI0OGDJFp06aJgUHqNgRjY2MxNjbO+D+AiIiIiIiI6D/orac7b9684urqKseOHVO2qdVqOXbsmHh4eKT5mjdv3qQK1oaGhiIiAkB3xRIRERERERF9BL3eMmzcuHHSr18/qVGjhri5ucnSpUslJiZGBgwYICIiffv2laJFi4qfn5+IiLRp00b8/f2lWrVqUqtWLbl9+7bMmDFD2rRpo4RvIiIiIiIioqxCr6G7W7du8uzZM5k5c6aEhoaKi4uLHDp0SFlc7cGDB1o929OnTxeVSiXTp0+Xx48fi7W1tbRp00bmzp2rrz+BiIiIiIiI6J30GrpFRLy9vcXb2zvN506ePKn1s5GRkfj6+oqvr28mVEZERERERET0abLV6uVERERERERE2QlDNxEREREREZGOMHQTERERERER6QhDNxEREREREZGOMHQTERERERER6QhDNxEREREREZGOMHQTERERERER6QhDNxEREREREZGOMHQTERERERER6QhDNxEREREREZGOMHQTERERERER6QhDNxEREREREZGOMHQTERERERER6QhDNxEREREREZGOMHQTERERERER6QhDNxEREREREZGOMHQTERERERER6QhDNxEREREREZGOMHQTERERERER6QhDNxEREREREZGOMHQTERERERER6QhDNxEREREREZGOMHQTERERERER6QhDNxEREREREZGOMHQTERERERER6QhDNxEREREREZGOMHQTERERERER6QhDNxEREREREZGOMHQTERERERER6chHhe5SpUrJ8+fPU21/+fKllCpV6pOLIiIiIiIiIsoJPip0h4SESFJSUqrtcXFx8vjx408uioiIiIiIiCgnMErPznv37lX++/Dhw2Jubq78nJSUJMeOHRNHR8cMK46IiIiIiIgoO0tX6G7fvr2IiKhUKunXr5/Wc3ny5BFHR0dZvHhxhhVHRERERERElJ2lK3Sr1WoRESlZsqT89ddfUrhwYZ0URURERERERJQTpCt0a9y7dy+j6yAiIiIiIiLKcT4qdIuIHDt2TI4dOybh4eFKD7jG+vXrP7kwIiIiIiIiouzuo0L37Nmz5YsvvpAaNWqIvb29qFSqjK6LiIiIiIiIKNv7qNC9Zs0a2bhxo/Tp0yej6yEiIiIiIiLKMT7qPt3x8fHi6emZ0bUQERERERER5SgfFboHDRokP/zwQ0bXQkRERERERJSjfNTw8tjYWFm7dq0cPXpUqlSpInny5NF63t/fP0OKIyIiIiIiIsrOPip0X7lyRVxcXEREJDAwUOs5LqpGRERERERElOyjQveJEycyrIBVq1bJV199JaGhoVK1alVZsWKFuLm5vXP/ly9fyrRp02TXrl3y4sULKVGihCxdulRatmyZYTURERERERERZYSPvk93Rti+fbuMGzdO1qxZI7Vq1ZKlS5dKs2bN5ObNm2JjY5Nq//j4eGnatKnY2NjIzz//LEWLFpX79++LhYVF5hdPRERERERE9B8+KnQ3bNjwvcPIjx8//kG/x9/fXwYPHiwDBgwQkeRbkR04cEDWr18vU6ZMSbX/+vXr5cWLF3LmzBllHrmjo2P6/wAiIiIiIiKiTPBRq5e7uLhI1apVlUfFihUlPj5e/v77b6lcufIH/Y74+Hi5ePGiNGnS5J9iDAykSZMmcvbs2TRfs3fvXvHw8JARI0aIra2tVKpUSebNmydJSUnv/Hfi4uIkKipK60FERERERESUGT6qp3vJkiVpbp81a5ZER0d/0O+IiIiQpKQksbW11dpua2srQUFBab7m7t27cvz4cenVq5ccPHhQbt++LcOHD5eEhATx9fVN8zV+fn4ye/bsD6qJiIiIiIiIKCN9VE/3u/Tu3VvWr1+fkb9Si1qtFhsbG1m7dq24urpKt27dZNq0abJmzZp3vsbHx0devXqlPB4+fKiz+oiIiIiIiIhSytCF1M6ePSsmJiYftG/hwoXF0NBQwsLCtLaHhYWJnZ1dmq+xt7eXPHnyiKGhobKtQoUKEhoaKvHx8ZI3b95UrzE2NhZjY+N0/BVEREREREREGeOjQnfHjh21fgYgT58+lQsXLsiMGTM+6HfkzZtXXF1d5dixY9K+fXsRSe7JPnbsmHh7e6f5mtq1a8sPP/wgarVaDAySO+mDg4PF3t4+zcBNREREREREpE8fNbzc3Nxc62FpaSkNGjSQgwcPvnNudVrGjRsn69atk02bNsmNGzdk2LBhEhMTo6xm3rdvX/Hx8VH2HzZsmLx48UJGjx4twcHBcuDAAZk3b56MGDHiY/4MIiIiIiIiIp36qJ7uDRs2ZMg/3q1bN3n27JnMnDlTQkNDxcXFRQ4dOqQsrvbgwQOlR1tExMHBQQ4fPixjx46VKlWqSNGiRWX06NEyefLkDKmHiIiIiIiIKCN90pzuixcvyo0bN0RExNnZWapVq5bu3+Ht7f3O4eQnT55Mtc3Dw0P+/PPPdP87RERERERERJnto0J3eHi4dO/eXU6ePCkWFhYiIvLy5Utp2LChbNu2TaytrTOyRiIiIiIiIqJs6aPmdI8cOVJev34t165dkxcvXsiLFy8kMDBQoqKiZNSoURldIxEREREREVG29FE93YcOHZKjR49KhQoVlG0VK1aUVatWiZeXV4YVR0RERERERJSdfVRPt1qtljx58qTanidPHlGr1Z9cFBEREREREVFO8FGhu1GjRjJ69Gh58uSJsu3x48cyduxYady4cYYVR0RERERERJSdfVToXrlypURFRYmjo6OULl1aSpcuLSVLlpSoqChZsWJFRtdIRERERERElC191JxuBwcH+fvvv+Xo0aMSFBQkIiIVKlSQJk2aZGhxRERERERERNlZunq6jx8/LhUrVpSoqChRqVTStGlTGTlypIwcOVJq1qwpzs7O8vvvv+uqViIiIiIiIqJsJV2he+nSpTJ48GAxMzNL9Zy5ubl8/vnn4u/vn2HFEREREREREWVn6Qrdly9flubNm7/zeS8vL7l48eInF0VERERERESUE6QrdIeFhaV5qzANIyMjefbs2ScXRURERERERJQTpCt0Fy1aVAIDA9/5/JUrV8Te3v6TiyIiIiIiIiLKCdIVulu2bCkzZsyQ2NjYVM+9fftWfH19pXXr1hlWHBEREREREVF2lq5bhk2fPl127dol5cqVE29vb3FychIRkaCgIFm1apUkJSXJtGnTdFIoERERERERUXaTrtBta2srZ86ckWHDhomPj48AEBERlUolzZo1k1WrVomtra1OCiUiIiIiIiLKbtIVukVESpQoIQcPHpTIyEi5ffu2AJCyZctKoUKFdFEfERERERERUbaV7tCtUahQIalZs2ZG1kJERERERESUo6RrITUiIiIiIiIi+nAM3UREREREREQ6wtBNREREREREpCMM3UREREREREQ6wtBNREREREREpCMM3UREREREREQ6wtBNREREREREpCMM3UREREREREQ6wtBNREREREREpCMM3UREREREREQ6wtBNREREREREpCMM3UREREREREQ6wtBNREREREREpCMM3UREREREREQ6wtBNREREREREpCMM3UREREREREQ6wtBNREREREREpCMM3UREREREREQ6wtBNREREREREpCMM3UREREREREQ6YqTvAoiISP8cpxzQdwlpCpnfSt8lEBEREX0S9nQTERERERER6QhDNxEREREREZGOMHQTERERERER6QhDNxEREREREZGOMHQTERERERER6UiWCN2rVq0SR0dHMTExkVq1asn58+c/6HXbtm0TlUol7du3122BRERERERERB9B76F7+/btMm7cOPH19ZW///5bqlatKs2aNZPw8PD3vi4kJEQmTJggdevWzaRKiYiIiIiIiNJH76Hb399fBg8eLAMGDJCKFSvKmjVrJH/+/LJ+/fp3viYpKUl69eols2fPllKlSr3398fFxUlUVJTWg4iIiIiIiCgz6DV0x8fHy8WLF6VJkybKNgMDA2nSpImcPXv2na/74osvxMbGRj777LP//Df8/PzE3NxceTg4OGRI7URERERERET/Ra+hOyIiQpKSksTW1lZru62trYSGhqb5mtOnT8t3330n69at+6B/w8fHR169eqU8Hj58+Ml1ExEREREREX0II30XkB6vX7+WPn36yLp166Rw4cIf9BpjY2MxNjbWcWVERJSbOE45oO8S0hQyv5W+SyAiIqJ/0WvoLly4sBgaGkpYWJjW9rCwMLGzs0u1/507dyQkJETatGmjbFOr1SIiYmRkJDdv3pTSpUvrtmgiIiIiIiKiD6TX4eV58+YVV1dXOXbsmLJNrVbLsWPHxMPDI9X+5cuXl6tXr0pAQIDyaNu2rTRs2FACAgI4X5uIiIiIiIiyFL0PLx83bpz069dPatSoIW5ubrJ06VKJiYmRAQMGiIhI3759pWjRouLn5ycmJiZSqVIlrddbWFiIiKTaTkRERERERKRveg/d3bp1k2fPnsnMmTMlNDRUXFxc5NChQ8riag8ePBADA73f2YyIiIiIiIgo3fQeukVEvL29xdvbO83nTp48+d7Xbty4MeMLIiIiIiIiIsoA7EImIiIiIiIi0pEs0dNNREREORtvs0ZERLkVe7qJiIiIiIiIdIShm4iIiIiIiEhHOLyciIiIKIvJqsPxRTgkn4govdjTTURERERERKQjDN1EREREREREOsLh5URERESU7WXVIfkcjk9E7OkmIiIiIiIi0hGGbiIiIiIiIiIdYegmIiIiIiIi0hGGbiIiIiIiIiIdYegmIiIiIiIi0hGuXk5ERERElMtk1dXeRbjiO+U87OkmIiIiIiIi0hGGbiIiIiIiIiIdYegmIiIiIiIi0hGGbiIiIiIiIiIdYegmIiIiIiIi0hGGbiIiIiIiIiIdYegmIiIiIiIi0hHep5uIiIiIiOg/ZNV7m/O+5lkfe7qJiIiIiIiIdIShm4iIiIiIiEhHGLqJiIiIiIiIdIShm4iIiIiIiEhHGLqJiIiIiIiIdIShm4iIiIiIiEhHGLqJiIiIiIiIdIShm4iIiIiIiEhHGLqJiIiIiIiIdIShm4iIiIiIiEhHGLqJiIiIiIiIdIShm4iIiIiIiEhHGLqJiIiIiIiIdIShm4iIiIiIiEhHGLqJiIiIiIiIdIShm4iIiIiIiEhHGLqJiIiIiIiIdIShm4iIiIiIiEhHGLqJiIiIiIiIdIShm4iIiIiIiEhHskToXrVqlTg6OoqJiYnUqlVLzp8//859161bJ3Xr1pVChQpJoUKFpEmTJu/dn4iIiIiIiEhf9B66t2/fLuPGjRNfX1/5+++/pWrVqtKsWTMJDw9Pc/+TJ09Kjx495MSJE3L27FlxcHAQLy8vefz4cSZXTkRERERERPR+eg/d/v7+MnjwYBkwYIBUrFhR1qxZI/nz55f169enuf/3338vw4cPFxcXFylfvrx8++23olar5dixY5lcOREREREREdH76TV0x8fHy8WLF6VJkybKNgMDA2nSpImcPXv2g37HmzdvJCEhQSwtLdN8Pi4uTqKiorQeRERERERERJlBr6E7IiJCkpKSxNbWVmu7ra2thIaGftDvmDx5shQpUkQruKfk5+cn5ubmysPBweGT6yYiIiIiIiL6EHofXv4p5s+fL9u2bZPdu3eLiYlJmvv4+PjIq1evlMfDhw8zuUoiIiIiIiLKrYz0+Y8XLlxYDA0NJSwsTGt7WFiY2NnZvfe1ixYtkvnz58vRo0elSpUq79zP2NhYjI2NM6ReIiIiIiIiovTQa0933rx5xdXVVWsRNM2iaB4eHu983cKFC2XOnDly6NAhqVGjRmaUSkRERERERJRueu3pFhEZN26c9OvXT2rUqCFubm6ydOlSiYmJkQEDBoiISN++faVo0aLi5+cnIiILFiyQmTNnyg8//CCOjo7K3G9TU1MxNTXV299BRERERERE9G96D93dunWTZ8+eycyZMyU0NFRcXFzk0KFDyuJqDx48EAODfzrkV69eLfHx8dK5c2et3+Pr6yuzZs3KzNKJiIiIiIiI3kvvoVtExNvbW7y9vdN87uTJk1o/h4SE6L4gIiIiIiIiogyQrVcvJyIiIiIiIsrKGLqJiIiIiIiIdIShm4iIiIiIiEhHGLqJiIiIiIiIdIShm4iIiIiIiEhHGLqJiIiIiIiIdIShm4iIiIiIiEhHGLqJiIiIiIiIdIShm4iIiIiIiEhHGLqJiIiIiIiIdIShm4iIiIiIiEhHGLqJiIiIiIiIdMRI3wUQERERERFRzuM45YC+S0hTyPxWmfrvsaebiIiIiIiISEcYuomIiIiIiIh0hKGbiIiIiIiISEcYuomIiIiIiIh0hKGbiIiIiIiISEcYuomIiIiIiIh0hKGbiIiIiIiISEcYuomIiIiIiIh0hKGbiIiIiIiISEcYuomIiIiIiIh0hKGbiIiIiIiISEcYuomIiIiIiIh0hKGbiIiIiIiISEcYuomIiIiIiIh0hKGbiIiIiIiISEcYuomIiIiIiIh0hKGbiIiIiIiISEcYuomIiIiIiIh0hKGbiIiIiIiISEcYuomIiIiIiIh0hKGbiIiIiIiISEcYuomIiIiIiIh0hKGbiIiIiIiISEcYuomIiIiIiIh0hKGbiIiIiIiISEcYuomIiIiIiIh0hKGbiIiIiIiISEcYuomIiIiIiIh0hKGbiIiIiIiISEcYuomIiIiIiIh0JEuE7lWrVomjo6OYmJhIrVq15Pz58+/df8eOHVK+fHkxMTGRypUry8GDBzOpUiIiIiIiIqIPp/fQvX37dhk3bpz4+vrK33//LVWrVpVmzZpJeHh4mvufOXNGevToIZ999plcunRJ2rdvL+3bt5fAwMBMrpyIiIiIiIjo/Yz0XYC/v78MHjxYBgwYICIia9askQMHDsj69etlypQpqfZftmyZNG/eXCZOnCgiInPmzJEjR47IypUrZc2aNan2j4uLk7i4OOXnV69eiYhIVFRUhtSvjnuTIb9HFzLqb8xoWfWYZdXjJcJjll48XunHY5Y+PF7px2OWPln1eInwmKUXj1f68ZilT1Y9XiI5/5hpfg+A9+8IPYqLi4OhoSF2796ttb1v375o27Ztmq9xcHDAkiVLtLbNnDkTVapUSXN/X19fiAgffPDBBx988MEHH3zwwQcffGT44+HDh+/NvXrt6Y6IiJCkpCSxtbXV2m5raytBQUFpviY0NDTN/UNDQ9Pc38fHR8aNG6f8rFar5cWLF2JlZSUqleoT/4KMFRUVJQ4ODvLw4UMxMzPTdzlZHo9X+vGYpQ+PV/rxmKUPj1f68ZilD49X+vGYpR+PWfrweKVfVj1mAOT169dSpEiR9+6n9+HlumZsbCzGxsZa2ywsLPRTzAcyMzPLUm+mrI7HK/14zNKHxyv9eMzSh8cr/XjM0ofHK/14zNKPxyx9eLzSLyseM3Nz8//cR68LqRUuXFgMDQ0lLCxMa3tYWJjY2dml+Ro7O7t07U9ERERERESkL3oN3Xnz5hVXV1c5duyYsk2tVsuxY8fEw8Mjzdd4eHho7S8icuTIkXfuT0RERERERKQveh9ePm7cOOnXr5/UqFFD3NzcZOnSpRITE6OsZt63b18pWrSo+Pn5iYjI6NGjpX79+rJ48WJp1aqVbNu2TS5cuCBr167V55+RIYyNjcXX1zfVcHhKG49X+vGYpQ+PV/rxmKUPj1f68ZilD49X+vGYpR+PWfrweKVfdj9mKuC/1jfXvZUrV8pXX30loaGh4uLiIsuXL5datWqJiEiDBg3E0dFRNm7cqOy/Y8cOmT59uoSEhEjZsmVl4cKF0rJlSz1VT0RERERERJS2LBG6iYiIiIiIiHIivc7pJiIiIiIiIsrJGLqJiIiIiIiIdIShm4iIiIiIiEhHGLqJiIiIiIiIdIShm4iIiIhIh7huMVHuxtBNuU5cXJy+SyAiyjRqtVrfJRDlSrdu3ZLVq1eLiIhKpWLwTqeLFy/KjBkz9F0GUYZg6KZc5c6dOzJu3DjZs2ePvkshkpcvX0pkZKS+y6Ac6t69exIWFiYGBgYM3kSZTK1Wy969e2XEiBGybNkyEWHwTo/Lly9L7dq1JSYmRt+lEGUIhu4cjCd2bVevXpXGjRvL69evJTQ0VN/lZFtJSUn6LiFHePbsmTRs2FDWrFkjL1680Hc5lMPExcXJmDFjpFKlSvL06VMG70yW04+1Wq3md8F/MDAwkF69esmXX34pM2fOlCVLlogIg/eHuHz5snh4eMjEiRPF399f3+VkO8+fP5crV67Ivn375OTJk1rP8b2XTB/naIbuHObhw4dy5swZEUk+sYswJImIBAcHS9OmTaVnz56yevVqGTp0aJr78WT0bqGhofL27VsxNDRUtvF4fTxra2upVauWrF+/XjZv3izPnz/Xd0mUgxgbG8vEiRPFxcVFGjRowOCdSV6+fCkikqOP9Zo1a2Tw4MHSuHFj+eWXXyQ6OlrfJWU5mv/v7ezsZNCgQTJx4kSZNWuWVvCmtF29elU8PT1l/PjxMmfOHGX76tWr5fvvv9djZdlDYGCgNGvWTPr16yddunSRRo0aSe3atWXr1q2SlJSUqxt9wsLCJCQkRESSz9GZjaE7BwkPDxcnJyepU6eOjBkzRrZv3y4iohWSciO1Wi3r1q2TZs2ayRdffCEFChQQkeSWwBs3bsi+ffskNDRUAPCL8B3u3bsnRYoUEXd3d9m0aZOcPXtWRP65cMipF5e6omkIW7NmjbRt21aWLVsmW7ZsYfDOAHfv3pUrV67ouwy90nwe69SpI19++aUUKVJEGjZsyOCtYxEREdK8eXOZP3++iOTM4D1+/Hj58ssvxcjISBISEqRr165y6NAhEWEjrEhyo0tcXJwYGBgo53kbGxsZMmSITJw4UXx9fWXFihV6rjLrevnypXTv3l1KliypFbj9/Pxk+vTpUrx4cT1Wl/Vdv35d6tSpIw0aNJDNmzfLlStX5JdffpGIiAiZNGmSrF69WtRqda681n369Kk4OTmJt7e39OjRQ54+fSpRUVEi8s+5S9fnMIbuHMTY2Fi6dOkiy5YtE5VKJevWrZPKlSvLnj175ObNm1r75rQLgfcBIFeuXBEjIyMxMjISEZH//e9/MnbsWPHw8JAOHTpIixYt5NixY3quNGurXbu2VKxYUc6dOyddunSRyZMny4kTJ0REPy2G2ZmhoaFyQbZ48WLp2LGjErw1PWX0caZMmSLu7u5y6dIlfZeS6WJjY0VEtC74a9WqJX5+fmJvby8NGjSQ0NDQHBkGs4KYmBipXr26bN26VZnD+1/HOjsF1YkTJ8rGjRvl0KFDsnr1atm7d69YWFjI0qVLRSS5ETY3j6wLDw+Xzp07y+LFiyUuLk7rPK8J3mPHjpWvvvqK68q8Q1JSkvTu3VvCw8Nl1qxZIiKycOFCWbx4sfz4449St25d/RaYhb1580amTJkivXr1kkWLFknlypWlXLly0qxZM/njjz/ExsZGFi9eLH///beIZK9zT0Z4/PixiIj06tVLjIyMpFOnTjJo0CA5fvy4JCYmiojup37wSjkHMTc3lzx58sjZs2dlyZIlsmvXLmnVqpV8//330rJlS/nuu++UHqDcEJIiIiLkxYsXYmhoKB4eHnLt2jXZtGmTTJ06Vby9vSVv3rzy3XffSVhYmMTFxcmaNWv0XXKWBEAKFSokpUqVkkaNGsnXX38t69evl6CgIFmwYIG0a9dOzp8/L0+fPtV3qVlacHCwsoqtSOrg3alTJ1m8eLEcPHhQRHLfF2JG2bBhgzRq1Ejatm2rXFzkBg8ePJBhw4bJ8ePHRUT7/eXu7i7z58+XIkWKSOfOnSUyMjJXfAdkthIlSsikSZOkRYsWsnr1aq3gnTKMJiYmphotlNUdOHBAFi9eLCtWrJBKlSqJgYGBqFQqUalUkpCQIE+fPpWYmJhcO7Lu5cuXYm1tLba2tnLgwAFZvXp1msF7wIABUq1aNWUaIGmzsrKSzz//XHx8fGTp0qVSt25dWbx4sfz000/i5eWlte++ffvYeJjCmzdv5NatW1KnTh0R+ecaIikpSQoXLiwHDx6UiIgI2bJli4hkn3NPRqlRo4b06NFDfvnlF9myZYtMmzZNKlasKD169JDevXtr3WVAREedk6AcISkpCQAQGRmJihUrYv369cpzDRs2hJWVFcqUKYPatWujVatWePDggb5KzRQXL15ExYoVcebMGQDAmTNn0K1bNzg6OsLR0RHbtm3Do0ePlP1nzpyJWrVq4c2bN/oqOcv78ccfYW1tjcDAQGWbp6cnVCoV3Nzc4OHhgVWrViE8PFyPVWZdq1evhkqlwtKlS7W2JyYmKv89YMAA2NvbIzIyMpOry/7UarXy3zExMWjWrBmKFSuGixcvpto3Li4OX375JYKDgzOzRJ1JSEjApUuXUK5cOXTv3h2nTp1SntO8v5KSkrBv3z5Ur14dO3fu1FepOVbKz/Hdu3cxYcIEODk5aX3ek5KSEBcXB29vb1SoUAERERH6KPWjxMTEoEWLFihRogSCgoKgVqvh6uqKMmXKoEGDBmjbti3s7OwwYMAAbNmyBVevXtV3yZnm6dOncHd3x/nz5/HmzRv0798ftWrVwpIlSxAbGwsg9Xm+adOm+io3W3j+/DmWLFkCW1tbdO/eXdmuOY4zZsyASqXC/fv39VVilhMYGAgrKyvs27cPABAfH688p/nvAQMGoGHDhrnuWjchIQEAcPz4cTRr1gx37txRnqtduzZKliwJGxsbeHp6YsyYMQgLC9NJHQzd2Vh0dDRevnyp/Kz5Qh81ahQmT54MAOjbty/s7Ozw8OFD3L17Fxs2bED16tVx+/ZtfZWtcwEBAcifPz8mTJigtT0qKgrPnj3Dq1evUr2mb9+++Oyzz5QPJv0j5UV7jx49sHz5cgBA//794eDggBs3buDw4cMYOXIkrKys8OTJE32Wm2XFxMRg6dKlUKlUWLx4sdZzmvfdmzdvYG1tjR07duijxGwp5YUF8E8D5LuCt+YcqVKpcP369UytVRdCQkLQrVs3JCQk4Ndff4W7uzs6d+6cZvBWq9UoW7Yspk2bpq9yc5SQkBCcO3dO+R5O2fCTVvBWq9UYMWIEjI2N02wMyoqOHDmCp0+fAgBiY2PRrFkz2Nvbo3z58mjdujVevnypBMtNmzZh+PDhUKlU8PX11WPVmevevXuwsLDAzJkzASSfewYOHAg3NzcsWbIE0dHRAP45Vw0cOBATJ07Uer9QauHh4ViyZInWsQWAadOmoUCBArhw4YIeq8t6Xr16hWLFiqFPnz7KNs33ocbAgQNRv379TK5MP0JDQ/Hw4UOtbfHx8XB1dYW3tzeAfzLSpUuX8Pz5cwwYMAD169fH3bt3dVITQ3c2dfPmTfTq1QsrVqxQvhA1jh49ClNTU3h4eKBIkSKpTkw5OVgGBAQgX7588PHx0dr+5MmTNP/uN2/eYOrUqbC1tcWNGzcyq8ws7dGjR9ixYwcWLlyIFy9eaD03Z84ceHh4oHPnzihatCjOnTun9XxUVFRmlprtvH37FosWLdIK3poLL7VajeDgYLi4uCgjNOj9AgMD0bZtW2zduhWvX79Wtr8reCclJcHb2xv58+fH33//ra+yM9TmzZthZGSEy5cvAwAOHDgAd3d3dOnSBb///ruyX3x8PGJjY9G+fXts3LhRX+XmGBEREShcuDAaNGgANzc3/Prrr6ku8G7duqUEb39/f0yaNAn58uXLFu89tVqNoKAgqFQqjBw5Uun5iY2NRY8ePaBSqXDixIk0X/v48eNMrFS/NOfvJUuWwN7eHgEBAQCSry0GDhwId3d3TJkyBa9fv8bTp0/h6+sLW1vbHNHg96lu3ryJ1atXv3ef58+fw9/fHxYWFpg/fz4WL14MExMTBm4kj2y9fv261ujCGTNmwNTUFMuWLdPaV9Pw2qNHD0yZMiXHN/gEBQXB0NAQ3bp1SzUa4tSpU2jQoAE8PDxga2ur1QCqVqt1eh3L0J0NXb58GXZ2dujbty/27t2r9ZzmgzRo0CA4ODjg7Nmz+ihRL65fvw4zM7NUPdwzZ86El5dXqh7ujRs3onfv3ihWrFi2uAjKDFevXkWNGjXQv3//d/ZUVKxYEZaWlspFfko5/USeHs+fP8eFCxewYsUKrF27Fk+fPlUafr766iuoVCosWLBA6zW+vr6oXr16qoY0Stvnn38OKysrODg4oFevXhg9ejSioqIQFxen7BMTE4OmTZuiRIkS6NixI0xNTbNNL+OHqlu3Lpo3b678fOjQIdSqVQsdO3bEL7/8AiA5BMyaNQsODg5aQ+vo49y/fx8lS5bE/Pnz8c0336B69epo2rQp/Pz88OzZM6XhJzg4GJMnT4aJiQkMDQ2z3Xtvx44dyJMnj9aQyzdv3qBly5YoUqQIzp8/r7V/yu+Af/ey5WTnzp1DmTJlsGnTJmXb27dvMWnSJFSrVg158+ZFnTp1UL58eSWY53Zr1qyBSqVKFRD/7fnz58ooMZVKxcAN4MaNG2jevDkaNmyIUaNGKduvXbuGBg0awN7eHnPnzgWQ/DmMjo7GzJkzYWVlhaCgIH2VnWl27NihvF+6dOmi1SB69+5d1KhRQxkFrJEZ5yuG7mzm3r17cHBwwJQpU977Bvn2229RvHhxhISEAMgdX35jxoyBSqXC9u3blfkqfn5+sLKywv79+7X2vXbtGsaOHYvhw4fj5s2b+ig3ywkMDEShQoUwY8YMrZbTbdu24d69ewCSe8u++OILNG3aVOkFZ9BO7fr162jcuDFq1qwJMzMz5M+fH7a2tpg/f74yX1tzEdGzZ0+MGzcOw4cPh5WVFS5duqTX2rOTHTt2wNvbG8HBwdi5cydq1aqF6tWrY9y4cVoNaQkJCWjUqBFUKlWOOr6a8/rq1atRoUIFrYv5o0ePonnz5ihbtizc3d3Rpk0blChRIkf9/frw4MEDZTj5d999hzp16iA+Ph4BAQH4+eefUbFiRVSvXh0jRoxAaGgogORe8enTp2ebi121Wq08AODnn3+GSqXSCt6xsbFo0aIFihUrhr/++kuf5epVyrna/fv3R5kyZfD27VtlW0JCAu7du4ctW7bg1KlTWmvJELB8+XKoVCr4+/u/d78XL15g9erVvF4DcOXKFVhbW2PatGlaIyY0a5QEBASgffv2MDAwQPny5eHi4vLeNU5yolevXmHw4MGYPHkybG1t0bx5c63P3vr162FhYYFbt25lal0M3dnM0qVL0axZM61FEB4+fIijR49i6dKl+Pnnn5Xtbm5uaNOmjT7K1JuePXuiYsWK2Lt3L2bPng0rKyscPnw41X5qtRqJiYm5bjGJd4mIiICHhweGDBmitX3+/PlQqVQoVqyYcnIKCAhAwYIF8fXXX+uj1CwvICAAVlZWGDNmDP7880+8ePECISEhaNOmDSwtLTFt2jRl+JJmUY8WLVpg2LBhHHL4AS5duoRvv/0WQPK6Fo6Ojpg/f77y/M8//wwLCwsUKFAAI0eOxI8//gggucc7p603oAndz58/h52dXapRPteuXcOOHTswZMgQrFq1KtMvMHKaS5cuwcrKSllzITAwEE2bNsWxY8eUfTp37oySJUuiZs2asLW1Rbt27bJlKE1MTEwzeI8dO1ZpdHjz5g1atWoFAwMDnc2BzGqCgoIwZswYnDx5MtVzFy5cQMWKFbFhwwYAOXsq36f4dyeQpgE6reAdGxuLYcOGYdu2bWzgR3KjX5kyZTB+/Hit7QsWLEDhwoXx3XffAQCePXuGo0ePwtvbG8OGDcPatWuVzpPcYuTIkejSpQvu37+PIkWKoGXLlsoi0k+ePEHjxo3x5ZdfZurnlKE7m5kwYQKaNWumtK7++OOP6NChA2xsbODg4IB8+fIpi6gtXLgQHh4eqebl5nRdunRB4cKFYWpqqgy/T3mS9/Pzw4QJE/iFmMK5c+fg7OyMP/74Q9m2detWWFpaYsWKFWjdujUcHR2VnpqBAweiVq1aePv2Lb8IU7h69Sry58+vDM3/97Hp3r07zM3N8b///U/ZpukV+feCYJRaQEAAVCqVco4Dknu7mzZtqrRi9+vXD+XLl8fKlSvRtWtX5M+fH23bttXqkcqugoODcezYMa3GA817bMWKFXByckpz2gd9unetF9KvXz94enoCSO7ptLe3V0YTLFmyBJ06dco2q+SvWLFCa5pCWsHbwMAAS5YsUfaJiYnBokWLMrtUvdmxYwfMzc1Rrlw51K9fHydOnFDmsEdHR6Nx48Zo2bKlnqvMmlKuuwFofz+mFbzj4+OVRS9zSw/tf1m/fj08PT3x4MED5fh98cUXMDc3R8uWLWFiYoINGzZoTbHKDUJDQ/HkyROtv/vVq1dwcnLCvn37cPPmTRQuXBitW7dWvj979OiBypUra41M0TWG7mxm/fr1MDQ0xPjx49G9e3dYWlpi9OjR+O233/D69WvMmTMHpUuXRmhoKB4/fpyjb6fw+PFjHDhwAD///DOePXum9dzAgQPh4OCAH374QetEP3PmTKhUKs6p+n+ak/batWthZWWldauqgwcPKkN0L1++jJYtW8LS0hIvX77E8ePHc12r6X959uwZLC0tUa9ePSVAa45vysBXsWJFNG7cWPk55UJq9G6BgYHIly8f5syZo7X96tWrqFKlCk6dOoVhw4bBzs5OmfMXGRmJ8+fP54ghiYmJiejbty9UKhU8PT1T3Z7vzz//hIODg9LTkRMaGbKKoKAgmJubazX2aBptHz58CC8vL1SoUAH29vaperUz84LuU23ZsgX29vapbtGUMngvW7YMZmZmaTYk5ORpbDdv3lR6sF++fIkdO3agYcOGKFq0KGrUqIH169cjNjYWV65cgY2NDW/L9y/Xr1+Hk5MT+vXrh+DgYDx//hxA2sFbc6s1b2/vbLPwYGbp3bs33N3dlZ/fvn2LL774AkeOHAEAjB8/HsbGxli7di3i4+OVz2ROvr64ceMGVCoVPDw80K9fP9y5c0e5Y8D48eMxYsQIAMnXClZWVmjTpg0iIiIQFRWV6eubMHRnE//uqa1Tpw7q1KmDQ4cOKScvAFi3bh3Kly+f4++VfPnyZZQvXx7ly5eHpaUlKlSokGrF1K5du6JChQrKwiZz5szhqpfvsGfPHhgaGr534b0VK1bA1dWV95B+j88++0zpZf33CBNNC+yCBQtQvnx5nd0HMie6du0aLC0t4ebmppwLU4bK2bNnQ6VSwd7eHleuXNFXmToTEhKirM+xf/9+jBw5Ennz5kWtWrUwYsQI5X7PmoXSUn4n0KfRTKdRqVSYOXNmqhEpr1+/RqdOnVCgQAGtRXmy00XusWPH8OrVK7x9+xY7duxA8eLF0aVLF+X5lKPCLl68mKvmhmosWbIEKpUKK1eu1Nq+a9cueHt7w8TEBLVq1UKvXr1Qr169VMN/c7tNmzahcuXKqFOnDtq0aYOGDRvil19+SdVhsmTJEhgbG8PZ2RkFCxbMde+z90lKSsKgQYNQu3ZtxMbGKt+B/25grVOnDtq2bauPEvXiwIEDUKlUqFChApo3b47SpUtj+PDhOHDgAC5dugQLCwtlwcfr169DpVKha9euemkkZOjOwh4/fozw8HDlHpgpv/iio6PTHD4yfvx4tGrVKkffuklzH+7JkycjJCQEmzdvRp48edCnTx8kJCRoHZeuXbvCxcUFzZs3Z+BO4ebNm5g9e7by8/Xr1+Hs7AwvLy+tRdOAfxp8xowZg27duiktiJQsPDxca0TJsGHDUKpUKaxcuVJpoEh5AT569GjUrFmTPZEfSDOst0KFCvD09MTcuXOVOaWaY3jjxg24urpi1apVWttzgqSkJNSrVw9FixbVep/duHEDkydPhpOTE+zs7DBkyBD4+/vD09MTP/30kx4rzjkuXboEExMTzJo1C/v27YORkREmTpyYKnj//fffMDMz05o2kl0MGzYMxYoVUxoB3759i+3bt6cK3prvgXPnzsHNzQ2BgYF6qTez3blzR1kLYeHChTAwMMCqVatSnWMuXryImTNnokqVKlCpVChZsiRiYmL0UXKWonnfXLhwAa1atcL169dx+/Zt+Pj4oGTJkujevbvSs625xl28eDEsLCzYw43kW7im/Kz5+/vDwMBAuR1kymuLxMREvH37FgMGDMCcOXNy9MgTIPnaS3O9v3PnTqhUKixcuBAbN27EvHnzYGZmhkGDBsHExAQTJkxQRh0FBQXpbfQbQ3cW9fjxYxgbG6Nbt27o3r07bt26pYRvjZQfqBcvXmDy5MkoVKgQrl69mtnlZpqQkBCYmJhg7NixWttLliwJLy+vNF/Tpk0bmJqackh5Cps3b4ZKpdKanzh9+nRYWlqiV69eWkPHIyMjMXnyZFhZWeHatWt6qDbrioqKQokSJfD5559rHbOUwTvlKu+vXr1Cjx49MHPmzGzVE6YvV65cgUqlUoaUjxo1Cq6urpg7d26qWwB26dJFa9hdTqAJQqGhoXBzc0OlSpVw+/Zt5fmEhATExsbiiy++QOvWrWFgYACVSoXevXvz/fWJwsPDYWtrq3WO3L59e6rgrflc9+rVCwMHDsxWjZJjxoyBlZVVqnATExOjBG/NYqzR0dF4+PAhqlatioEDB+qj3EwXERGB4sWLY/fu3cq2+fPnw8DAQGsh0ZRThN68eQN/f/8cMaXlU124cAG9e/dWPit9+/ZF06ZNlWvZu3fvwtHRESqVCg0bNsTEiRNx48YNAEh1fs+N4uPjUblyZdSrV09ZJ+L58+dwd3eHtbV1mut3TJ06FSVKlND6nsiJ/v77b2VamcamTZuUEUmxsbEICQnBl19+iZo1ayoLquq7IYKhO4sKDAyEsbExvvzyS0ycOBGlSpXC559/jh9++EFrP7VajcmTJ6NTp04oW7Zsjr4dTGJiInbu3ImyZcuia9euylxtPz8/qFQquLi4KCs1nj9/Xmu4eU5btfhTRUdH49tvv0WePHm0hsF5e3vDxsYGjo6OmDNnDj7//HN06tQJtra2bHV+h2+//RaWlpYYN26c1gq+afV4T5s2DaVKlcrxX4gZIS4uDn5+fpg1a5ayTa1WvzN437p1C2ZmZli7dq0+ys1wISEhKFmypHJhFRYWhmrVqqFy5cppvn+io6Pxyy+/oHPnzrmmF1JXnj59CgBaI6M0wSqt4A0kfw/Z2tpmm7Awfvx4WFhYaF24JyYmKnPS37x5g/3796N48eJwdHSEp6cnatSogc6dOyv75/SGndevXyvz9FNerKcVvIGcNcLmU2lGKI0cOVLZFhgYiMaNG+PcuXMAktfeKV26NP744w/MmDED1apVQ/HixVMtuJabXb58GY6OjmjTpo3yWf31119RsWJFWFlZYcmSJTh9+jR+/PFHfPbZZzAzM8vx12oBAQEwNjZW1thIeR7SBO8JEyYojTv/7rDUJ4buLGzOnDlKi/KePXuUWwJ06NABS5cuVfbbuXMnpkyZkukLAmSmv/76Cz179sTLly+xZcsWuLu7o3v37vD19UXhwoWxZs0aBAQEYMmSJejRowdsbW1RrFixVCvN5mb/buGLiorC2rVrYWRkhHHjxinbN27ciJ49e6JUqVJwc3PDxIkT2WqfhpQX3N9//z0KFiyYKngPHz4cpUqVwvr16zFhwgQuCvOBbt68iW+++UarsSzl8U4reD99+hQ9e/bMMbcuOnnyJIoWLaq1GE7K4P3v873mwoOr4H+aqKgoeHp6omnTpu88pimDd8oLuuzSuOvj4wOVSoU///xT2ZaYmIgyZcqgS5cuWuHx2bNn+PLLL7Fs2TKltwjQf4+RriUlJeHevXuwsbFJ89rqXcGbktfgKFCggDJCSfM5evPmDby8vDB+/HgMHToU9vb2SgBXq9WIjIzkfcz/n+a2tkDy8SxatKgyPB9IXjizW7duMDIygpGREcqWLYuWLVvm6JGuwLvvIhESEqIcr61bt0KlUmHSpElZbn0Thu4sSHOC2rt3L9zc3LTm8Xl5eaFo0aJwdnZGmTJlMH36dNy5cydHtzhr5nAPHz4cQPKQys2bN8PNzQ0qlQq7du1K9ZozZ85g1apVHA79/27duoXZs2dj3759WvP94+PjsWbNGhgZGWHMmDFar9H0zrL1Xtvjx48RFhaW6qJz06ZNKFiwIMaOHasV/Ly9vaFSqWBqaspFYT7QN998A5VKhUWLFmmt/pxyXQtN8Pbz81OG8Oek26Ts3r0bJUqUSLX9XcGbq+BnjNjYWGzYsAHVq1dH27ZtleP571tMbt++Xfleyk7vu8TERCxevBgqlUpZ6R4AXF1d0apVK2W9hPe9j3Jy4H769CnevHkDALh9+zYsLCze2ZA3f/58GBsbY/HixZlZYpZ29epVWFpawtHRUauxXvP5OXfuXI5e9PJThYSE4Pz588p7UOPy5csoWrQoWrRooXVde/XqVZw/fx5PnjzJ8SMEgoKCUKBAASVwp7xlWteuXbUC9tatW5EnTx6MHDkyS902maE7i7h//36aLXwNGjRAv379ACTfD7RIkSI4f/48Xr58ic8//xx169ZVVrXNiTQtpl988QWAfwKgJnjXqlULHTt2VIJkdrr4ySyRkZGoXLkyVCoVVCoVmjRpgkaNGuF///sfrl27BrVajc2bN8PU1BSTJk1SXvfv214RcO/ePRgaGqJQoULo168f5s+fj8DAQOV9uXv3bpiammLcuHHK4jtA8qrSHPKbPqtWrVIWRnlX8B47dixKly6NRYsWISkpKdu/V1MuvLR3716ULFkS8fHxqRq+NMG7evXq2eYe0NlJbGwsfvjhB1SpUuW9wXvz5s2wtrbONnci8PHxwYQJEwAAM2bMgJGREVasWIEaNWqgRYsWyvdoyp7JlOexnO7NmzcoXrw4OnXqhPj4eDx8+BB2dna4d+/eO88tvr6+sLS0zFIX9vqi6YVs3rw5PD090a9fP62G5qSkJDx//hwtW7ZUhp2zUf8fjx8/hpGREVQqFdq1a4devXpp3Z71zp07cHR0ROvWrZXVuHOLpKQkDBkyBJaWltiyZYuy3c/PD+bm5jh48KCyn8batWthYWGRpc7PDN1ZQGJiIjw9PVGmTBk8ePAAwD9vnF9//RXt2rVD7dq1YWdnl+oeoNll/tjHuHLlCiwtLVG8eHGtITOaCx9N8HZ3d0e7du2UC4Z/Xxjldmq1GvPmzUPdunXRsmVLLFmyBAMGDICzszNMTEzQs2dPjBgxAhMnToRKpdKaQ0va/vjjD2Xhl4kTJ6J06dIoW7Ysypcvj3nz5uHatWv47rvvYGVlBV9fXwQFBem75Gwn5UXYsmXL/jN4T5kyJUcMKQ8NDdVatGnnzp1wdnaGWq1GQkJCqov+8PBwlCpVCh4eHhxS/okiIiJSvYeio6Px448/wtnZ+b3BO7vcKWTMmDHIly+f1oKiM2bMgEqlQrly5ZR57Jq/8/nz56hevXqqW2TldIcOHUKhQoXQv39/nDp1SllXITo6GpGRkXj69CkiIiLw+vVrXL58GW/fvmXgRvKUIJVKhWnTpgEAfvzxR7i6uqJfv36p1hpau3YtChQokKsadD7E7du30bx5c6hUKkyePBmtW7dGuXLlYGFhgYEDB2L79u04ceIErKysMHDgQK3pITmZ5pz75MkTdOvWDXXq1MHPP/+MefPmwcrKCocOHUr1Gs13ombkTlbB0J1FPHjwAFWqVEGNGjWU4A0kt3xVqVIl1T1Ac/LwLuCfIeVt2rRBnTp10KNHD617SP+7x7tOnTpo0KBBjh9ek16a94kmeDdu3BjDhg2DWq1GXFwc9u7diwkTJsDZ2RmlSpVSesMjIiKyfa9hRtL0QCYmJioXYl27dsWbN28QEBCA0aNHo0mTJsibNy+6d++uHMfZs2czEH2A4OBgjB49Gn/88YcyZFrz/vP394dKpcL8+fO1htzlxMa17t27w8LCAgcOHMCqVavg5uaWah/NuS86OhphYWFaq+ZT+t25cwfm5uawtbVFq1at8M0332itu/Dzzz8rQ6/fFbyzuhkzZsDS0lJpvP73AnAGBgZYs2aN0oj/4sULVKpUCfXr19dHuXp37Ngx5M+fH5UqVUK+fPlgbGyM4sWLo0iRIjA1NYWNjQ3s7e1RrFixVPeZzo3i4+Oxa9cu5ZaNGj/88IMSvFN+pmJjY+Hs7Axvb+8cfy2bHmq1GkFBQWjSpAnKly+PyMhIREREYP369ejfvz+srKzg5eUFExMTqFQqDBw4MEstEqYLISEh8PX1VRpFnz59qiwcnS9fPiVwp2ys9/Pzw/jx46FWq7Pc+4uhOwt5/PgxqlWrhvr162tdSO3evRuOjo65Zj7orVu3oFKpMHXqVADJf3/NmjXRo0ePVAu/AMkXQGvXrkXTpk21GiYoWcr7bS9YsAA1a9bE0KFDER4eruyjVqtx9uxZfPvttxwG/S+aHkjN2gFqtRonT56ElZUVOnTooOwXGxuLy5cvY926dejQoQPKlCmjLHpC7xYVFYXq1atDpVLB0dER1apVQ+fOnfH1118r79Ft27ZBpVLB398/xzesDRo0CBYWFujcuTOsra3h4uICd3d3NG3aFO7u7nB1dYW7uztat26dat4fpd/PP/8Mc3NzVKxYEZUrV0bz5s1hbGyMxo0bw8fHB7/99htWrFgBd3d39OzZM9s1Rk6ePBkqlSrVquMpL1KnT58OQ0NDfPfdd3j48CGcnZ21bsGZ1S5cM8Nvv/2GIkWKoGjRoti8eTP+97//Yf/+/di1axf279+Pw4cP5+jFaz/U7du30atXL61pLikbpVL2eKcM3nPmzGFPdwopP4937txBjRo1UKZMGeUuPImJiYiOjsb+/fsxffp0eHh45Io1ixYtWgRHR0dMmTJFWd8qNDQU3bt3R9WqVbFx40at89OMGTOQJ0+eLHuLYIZuPdHMPU5KStL6sGlWFa1du7byBrt58yZq166NRYsW6aXWzBQVFYVdu3Zh/fr1Wts1wbtnz57vDN45eah9ety4cQM///xzmuE5KSkJCxcuhIeHB4YMGZLlVnbMqrp166b0QGqcPHkStra2aNmyZZqv4fvxw8TExGDt2rWoXr06qlSpgt9//x0dO3aEs7MzLC0t0bhxY2zcuBFdunSBmZkZ/P39s9W9kD/GqFGjoFKp4OnpialTp2LSpEmYNWsWfHx8MGXKFMyZM4eLEH2ilCuNf//99/D09IS3tzfOnTuHCxcuYN68eShfvjyqV68Oc3NzlC9fHiqVCsOGDdNj1ekzZswYWFhYYMGCBTAzM1MWIwVSB++ZM2fC0NAQ+fLl0zqn5bbAnfKYHD9+HKamphg5cmS2G92QWe7cuQNDQ0O0atVKa5RmyuOoCd65aUj0h7h79y6WL1+OHj16YODAgdiwYYPScXT//n24u7vD0dExzbsi5PQG15Q9+HPnzkW1atUwceJEreDdqVMn1KlTB+vWrQOQ3JCTL18+rVs9ZjUM3Xrw6NEjNG7cWFkIQdNy7ufnB2tra/zwww+oVKkSatSooXwAP/vsM5QqVSpHDyV5+PAhWrRogc2bN6d5q5Y9e/a8t8ebkoOeo6MjXFxc0Lp1a4wYMQK3b9/WOo5JSUmYP38+PDw8MHz4cEREROix4uxj0KBBKFCgQJrBu02bNso2Dif/MIGBgdi7dy+A5Ma2zZs3o2jRoqluXzd9+nQ4OjrCw8NDWfU2p86h1AScpKQkeHt7o0CBAvj999/1XFXOExAQgIIFCyqL7wDAt99+qwSDlCPNAgMDsWzZMnTv3h1OTk7ZprFj7NixMDc3V4aUb9++Hfny5Xtv8J42bRratWun/JwbAnfKkQuaY/H48WPluB07dgympqYYOHBgtpm/n1k0DRG3bt2CnZ0dmjVr9s7gvX37dpQuXRrDhg3D27dvs92IkYx2+fJlFClSBG3atEG9evVQt25dqFQq1KtXTzkvhYSEwMPDA6VKlVLWXNAc85x8/O7du4fhw4fj9OnTyrYvvvgiVfDWDDVv3LgxGjduDGNj4ywduAGGbr04ceIE6tWrh1q1aikLTMybNw+WlpY4fPgwgOQAWrFiRdSsWRMPHjzAs2fPcvQq5QDw9u1b1KhRA7Vq1cLOnTuV8JLyxK0J3n369OHF6Dt07NgRDRs2REBAAOrWrQsvLy+0a9cOgYGBSlhJSkrCokWLUK5cOYwdOzZXXFx9jH836GiC9/79+5XnT548iWLFiqFevXr6KDFbCggIgEqlwrx585Rt0dHR2Lx5M2xsbNC/f3+t/cPDw3Hjxg3MnTs3xw7Z17zXUo4+GThwYKqGHiBnX3DpmmaFZc30pZTH8ttvv0W1atUwaNCgVIs/JSUlaS3ml9X5+fnh8uXLys+JiYn46aefkC9fPowYMULZ/u/grZHbvhM01xshISGwtbWFr6+v8tyJEyegUqm0jltultZdYoKDg2FjY/Pe4L1z584csejlp7pz5w7s7Owwbdo0rR7rgwcPolChQqhevTpOnToFILlBo379+rCwsEBoaKi+Ss5Uhw4dgp2dHQYMGKDVwfau4N28eXPY29unOmdnRQzdmSjliero0aNo06YNPD09MXz4cNjY2OCXX37R2v/Ro0ews7ND48aNc/zQJs2J+e3bt2jatClq1KiBXbt2pRm89+7di7Jly2LQoEHZ6iJIl+7cuYOTJ08CSL6obN26NR48eIDo6GicPn0aw4YNQ968edGpUyds3rxZed26dev4Jfgvd+/exYYNG5Sf/33xOXjwYJiZmSl3EkhISMCRI0fg5OSkdbFBadOEnunTp6d6LjIyEps3b4a9vb1W8M7p5z/Nd0NISAiKFCmCH3/8UXlu6NChUKlU+PXXX/VVXo5x6dIl5MuXD1OmTNHanrL3WnOP7kGDBmXLOZP/njKU8rvzfcE7ZeNDTm7UCQ8Px5EjRzBt2jTMmjUL586dU6YCPXjwAMWKFcPnn3+e6rx/6tQp3LhxQx8lZymahb4WLlyI48ePIykpSTlWQUFBsLe3R+PGjd8ZvAlYsGABOnbsiPj4eK278QDJDTz58+fHwIEDlf2DgoLQvHnzXDUHfv/+/ahYsSL69u37n8H72bNnytz3rI6hO5PcuXMH06ZNU4ZTAv8Eb0NDQ+W2HP8+0T958gS3b9/O1Fozm+YLXnNifvPmjRK8d+7cqZyMUh6bgwcPMiz+v0uXLsHMzEwJik+fPoWHhwdmz56t7DNkyBDY2dlh6NChyJcvH1xcXPDNN9/oqeKsKyEhAdOmTYO1tbXW8Un53ouPj0enTp1QokQJrXnbOX2OVUa4fPkyTE1NlV5Gja+//lppxdf0eNvb22PQoEH6KFNnXr16heDgYGzfvh0nT57Umtpx9+5dFClSBEOHDk31PTB69Ghe8H+i27dvw8jICHPmzAHwz2d63rx5aNiwIR49eqTsu2HDBri5uaFbt27Z6rjPnDkTXl5emDt3rtb93VM2WmmCt6mpaa7rub127Rpq166NOnXqoESJErC3t4eZmRkGDRqEx48f4/fff8e0adNyXS//h4qNjUXPnj2hUqmQL18+NGzYEEWLFoW3tzd27tyJ6OhoPH36FA4ODmjfvj3vrPAOnTp1QvPmzVNt11wLL1y4EEZGRrh586byXE6ftpZWQ9+ePXveGbxr1qyJ4cOHZ7vFkxm6M8GVK1dQsmRJ9O3bFxs3btR67ujRo2jbti3c3NyUlR1zywk/ODgY586dA5B28Pby8oKrq6syr+PfrfH0z63VJk6cCOCf4/jzzz+jdOnSePz4MQYMGAB7e3ulN+fq1asYMmRIrmo1TY8bN25g/PjxcHJywurVq5XtKT+X586dQ/HixZX3L/238PBwqFQqdOnSRWv7ggULoFKplOF0QHLw3rp1K/LmzZtjgkFQUBDatWuHKlWqwNTUFCqVCvXr11cay6ZNmwZvb2+e43QgMTER8+fPh7m5OebPn69snzdvHszMzJRpXSl75FatWoUGDRqkuYhRVvTs2TPUqlULgwYNgoeHBxo3bqzVG5RSQkICduzYAZVKhU2bNumh2swXEBCAQoUKYdy4cbh69SpiY2MRFxeHYcOGwcHBAT169Mhy9/TNSjTnpVOnTqFnz56wtrbG6dOn8c0336Br164oUKAAKlasiF69emmtmJ/W+y+3UqvViI+PR/v27ZXFClNeV2iO8cmTJ5EvXz5l3aecLjAwEI0bN8batWtTjfjdv38/KlSogD59+uDMmTPK9ilTpqBevXoICwvL7HI/CUO3jgUFBcHa2hpTpkx55+I/R44cQevWrVGjRg1lTkJOv/BKSkrCsGHDoFKplA9SWsG7atWqaNCggd7qzMpu3LgBKysrjB8/HkDyMdU0TDx58gSdOnVCqVKlUKpUKSUcak7wHO71ftevX8fo0aNRrlw5reCt6TEKCAiAs7NztllUKSuIi4tD586dYWdnp0yF8PPzg6WlJY4cOQJA+7z35s0bbNu2Tau1P7sKCAiAjY0NRowYgV9++QUhISHYu3cvKlSogLJly+aa4KNPDx8+xOzZs1G+fHksWbIES5YsgZWVVaqLvJQiIyMzr8AMMH78eKUHbfPmzejcuTNKlCiByZMn4+jRo1r7vn37Ntc0Gl67dg358uVTRjn8+/rKx8cHFhYW8Pf3Z+N+Gv7++29Mnz5duW44c+YMGjdujIoVKyqhJzAwEPv27UPr1q3RokULqFQqGBoaZpthv7r0+vVrPH/+XLmn+9dffw2VSqW1kKPm+g1IDt0VKlTIFSMFEhIS0Lx5c6hUKjg7O8PCwgL169dH9+7dcfbsWcTExODUqVOoUqUKhgwZotXjrTme2QlDtw4lJCRg6NChGDx4sNZJ/OXLl7h9+zYOHz6sNY+jffv2KF26tNbiJzlZWFgY+vfvjwIFCuCPP/4AgFSrll+/fh2mpqa8zcS/BAQEoECBAjAyMoKbm5uyqmrKMD137lyoVKpcc2H1sV6+fIm7d+9i+/btOHTokPLeu3v3LkaPHg0nJyesWLFC6zU+Pj5wd3fnyu8fICIiQnlfJiUloVu3brC2tsagQYNgbW2tzFVOeY48e/Zsjlkp+MqVK8iXLx98fX1TXcxfvnwZ9erVg5OTk1ZPP+nG/fv34evri5IlS0KlUimjqFIOvx4/frwynzK7hC/NOevly5fw8PDA7t27lb9JM5Ikf/786N27N7Zu3ZpqIaycPLouMjISlSpVgrOzszLfXfP/a8q/u3HjxqhSpUqOXz8ivTSLXmpG02n8+eefaNCgAcqUKZNqkd9Xr17h2LFjOX5q5IcICgpCly5d0KFDB8ycORNA8neCq6srKlasqDQ4pzR27FjUq1cv14y8uH37Njw8PFCxYkUcPXoU8+fPR5MmTeDo6Ahra2vMmDEDDRs2RKlSpdCxY0et+71nNwzdOla/fn2MHj1a+Xnfvn0YNGgQzMzMYGJiAnd3dwQFBQFIHkbRo0ePXDFXWfOlFxYWht69e2sFb80XoVqtxh9//IHKlSvniha/D3Xp0iXkz58fU6dOxd27d1GlShVUrVpVmV+suWiIiopC7dq18eWXX+qz3CwtKCgIbdq0QZUqVaBSqZA3b16ULVtWWZ08JCQEEyZMgLW1NUaOHIlVq1Zh5MiRsLKyQkBAgJ6rz/pevXoFa2trTJw4USt4DxgwACqVCgsXLkz1mkmTJsHe3h7h4eGZXW6Ge/z4Mezt7dG0aVNlm2bhIc05ULOw3OTJk/VVZo706tUr3L9/Hzt27MDp06eVC9jHjx/D19cXZcqUwdy5c7Ve4+vrCxMTk2zTyKu5dgCSG1xjY2Px+eefY8CAAQCSz1/29vbw9vbG77//jubNm8PKykprvY/cYNasWXBzc8O4ceNSDXfWNEDs2LEDNjY2CA4O1keJWZLm3DRt2rQ0n//zzz/RqFEjlClTRplby0aLf1y5cgWFCxfGhAkTcPToUa152T/++CMqVKgAW1tbLF++HJcuXcLp06cxfvx4mJqa5prON427d++iZMmSaNWqlTI64vr16/j+++/RtWtX5ZahhQsXztajJxi6dSg6OhpDhw5F27ZtsXv3bsyaNQuOjo7o378/Nm7ciODgYDg4OKBXr17Ka2JiYvRYsW7duHEDU6dORUhIiFaPbFhYGHr16oUCBQrgxIkTWq+ZMWMG6tatyx5FJDdCvH79WhkuqHH16lUleKfs8Y6Pj4e3tzdq1aqVY3oNM5JmyO/o0aNx6NAhPH/+HP/73//QsGFDmJub4/vvvweQvJjh+vXrUb58edSuXRtdu3bNlqsa68vXX38NY2NjzJo1S/ncx8XFoU+fPrC0tMTx48eVfWfOnIkCBQrkmNEZjx8/Rv369dGsWTNs3bpV2a5pWNRchA0bNgzu7u548+ZNtuldzcqCgoLQvn17ODs7K728pUqVUkYTPH36FL6+vihfvjxmzZoFIHlxHhMTE1y8eFGfpX+wH374AW5ubtixY4fW9kuXLqFIkSJYs2YN7O3t0bdvX+W6Ijo6OsvfxzajPHjwANu2bVN+njdvHqpVq4axY8cqwTvlZ+3LL79E5cqVeUeU/3f58mWYmZmlWvRy9uzZWsf13LlzaNSoESpUqJDjb2ubHo8ePYKTk5My/U8jZaPEvn370LVrVxgZGcHU1BROTk7w9PTM8Q36mu+/f//vvXv3ULp0abi7u2vdHi0+Ph7x8fHYvXt3tn+PMXRnsLt378LLy0v5ed++fWjYsCEcHR1hZ2eHzZs3a7W0jhkzBg0bNkzzvoc5SXx8PGrWrAmVSoWyZctiwoQJ2L59u/J8dHQ0evfuDUNDQ8yfPx8rVqzA+PHjUahQoVzX4vdfNKvpprxgCAwMTBW8geS5WEWKFMk2iwFllsuXL6NAgQLKBUXK0RWRkZFo2bIlrK2ttVYuTkhIQFJSEmJjY/VSc3aT8v25fv16GBgYaAVvzVDzQoUK4fz585g9ezaMjY1zTCjQvKdCQkLQunVrNGjQIM3gDQAdO3bU+t6gj6dpTBs1ahT279+PV69eYcuWLahbty7Mzc2xZ88eAMmhzNfXF5UrV4aLiwtMTEyy1XvvypUraNSoEZo3b46dO3cq29VqtXKbueHDhyuB+9+NOTl5SHlcXBwGDx4MZ2dnbNmyRdmuCd4pe7zVajViYmIwYMAAjB49OsevEv0hoqOjUaRIEVSoUEFr+4IFC2BiYqI1FxkAzp8/j+rVq8PV1RWJiYlsOETyyAk3NzfcuXMn1Wft33dDuXr1Kn799VfcuHHjnWs/5RTXrl3D0KFDce7cOa0GiJTBu0yZMqhdu7ZyR4mcdK5i6M5gf/75JwoVKgRPT09l2/379/Hw4cNU8zPUajW6d++OESNG5Kg31bssXLgQ/v7++PXXX+Hr64tChQqhV69eWL16tXKSXrJkCZydnVGzZk107doVV69e1XPVWcP9+/fx66+/ao0QUKvVWu+btIJ3UlKS1m2tKHkVbQMDA3Tq1Elre8oLhXv37sHR0VHZJ60VRilt0dHRePnyZarzXVrBOzExUbkFjbGxcbbpZXyftBYpvHfvXprBOzExEeHh4ejUqROWLl0KgO+vT6FZ60JzH+6UC0fevn0bLVu2hIWFhTLX9NGjR5gwYQLKly+vLGKaHWj+ruvXr6Np06Zo2rSpVvDevn078ufPryz0mBuuL/7twoUL6N27N+rUqaO1UGFaPd7Tp0+Hg4NDjli0MaNs2LABJiYmmDFjBoB/Fr3UrMEBaJ+rAgICsn0vZEYaNWoUnJyc0nxOc9xiYmK0enRzusTERLRo0QLGxsZwcHDA0KFDsWzZMgCpr79Kly6N+vXrZ7tbgv0Xhu4MlpSUhD/++ANlypRBjRo1tLan9PbtW0ybNg12dnZa87JyshMnTsDMzAx//fUXgORhu7NmzVLmtq9duxYRERGIjY1FbGxsjh5qnx4vXryAnZ0dypcvD1dXVxw6dOidC5RcvXoV1atXR/HixfH69etMrjR7iIuLQ7du3WBjY4Njx469c79+/fqhdu3anKOWDteuXUOrVq1Qvnx5NG/eXKuXCUg7eMfHx2PSpEk5YkTLzZs38dlnn6Ft27YYMmSI1nMpg3fK4+Lj4wMnJyeuW/GJwsPDkT9/fnTt2hVA6qGLQPLIHwcHB/Tp00fZ/vTp02y5Cq6m/mvXrinB++eff1aeb968Obp06ZLrzl//DoI9evRIFbz9/PxQrVo1TJ06FSNGjED+/Pmz9eJMGeXBgwd4+vSp8vOmTZtgYGCA2rVrw8bGJs1FL3fu3MnGijRMmzYN5cuXx/Pnz995t5hZs2bhiy++yOTK9Gv16tWYPXs2zp8/j+XLl8PBwQHNmzfHvHnzlIUOgeTvy0KFCqFZs2Y56m47DN0Z4N/DkRISEvD777+jdOnScHNzS7X/Dz/8gAEDBqBIkSK57kQ/YcIE9OrVS5k31a1bN5QvXx79+vVDnTp1kCdPHnz11Vd6rjJrefDgAdzc3LBx40YsWbIEXl5eqFq1KpYvX57qXttqtRqXLl1C7dq1cefOHT1VnDWlHLaVlJSEXr16wcLC4p3Bu3///mjUqFFmlZftBQQEwNzcHEOHDsXChQtRrVo1lCpVKtWiVBs2bICBgQG++OKLHBUIAgICYGVlhe7du6Nbt24oWLCgci9WjZTBe9euXfD19YWpqWm26mXNqh4/fozu3bujUKFCym0o0+rh7dq1K+rVq5fZ5X2yVatWpXqfpAzeTZo0QatWrZQFSVetWgU7O7tcM1rs7du3WtOENDTBu3bt2so6HUDyyDtra2sULFgwR4yw+VQJCQmoUaMGnJ2dtaaj/fDDDzA2Nka3bt1SvWbq1KlQqVTs4U7D7t27oVKp8MMPPwBAqlvRvX79Gv369cPmzZv1VaJeXL9+Hebm5vjf//4HIPkctmzZMhQoUAClSpXC/PnzlbtK3L9/P8etgM/Q/YmCgoLQp08fzJ49G7dv39ZqJfzzzz9RqlQpuLq6KtsuXLiAfv36YdCgQbmmhzulHTt2wMPDA0lJSfjss89ga2uLwMBAAMnHctmyZcrPuV3Kudn+/v6oXLky4uPjcffuXezYsQOurq6oWrUqhg8fjsePHysjA5KSknL8GgHpFRkZCWtra61Ve98XvJ89e4a2bdsqq2tzyO/7Xb9+Hfny5dM6vj/99BNUKhV+/PFHANrHcOPGjVCpVJg/f36m16oLV65cQf78+eHr6wsgeYj9iBEjYGRkhN9++y3V0Ll27dqhcOHCyJcvX7aaR5wVpVxkM+WinJrg/e/Pbt++fbVWk88O4uPj4eLiAgcHh1QhWhM0AwICULJkSYwcORJA8nGZNGlSpteqD/fv34erqytOnDiR5giHgIAAdOnSBc2aNdNqBFy7di17aVO4deuWsmBoyhWit27dCgMDA617dWsWvdSMXCRtUVFR6NSpE/LkyYN9+/alen7mzJlwdnbO8Q0W9+7dUwK2xldffYX27dsrU9B69eqFChUqYOLEifDy8oKBgQHGjRunj3J1jqH7E8TExCg3dVepVKhZsyYcHR0xc+ZM/PTTT4iPj8epU6dQo0YNuLu7K697/PgxoqOj9Vi5ftWrVw8GBgYoUqRIjl+l8WPduHEDTZo0UeazPH36FO3atcPu3buVfVq3bg0nJydUqFABFStWRP369XH+/Hk9VZz1LVy4EMbGxlojKVIG76NHjyrbp06dCicnp1xx+75P9fbtWzRp0gRFixbF2bNnle0zZ86ESqXCnDlzcPz4ca1F6YDkoYvXr1/P7HIz3KtXr1CzZk04ODhobR88eDBUKhV2796d6n10584d9O7dm6vgf6JXr17B1tYWY8eOVbaFhoamCt6aoBAeHo7WrVtj0aJFALJHY5omPL569QqNGzeGo6OjMldbQ/P3rVy5Ms3b7eWGOd3Ozs5wcnLC6dOn0wze58+fR4kSJbBmzRp9lZgt3L17F6VLl04VvDdt2gRDQ0P4+flh5syZOWrRy4ymed9pbqmWJ08ejB8/Hrt27cK3336Lfv36wcLCIsePcHr8+DEKFy6MChUqaK1lcvjwYVSrVg2hoaEYMmQI7OzslCzw8OFD/PTTTzn2u5Gh+xPt2rULrVu3Rrt27bBw4UJ89913aNSoEczNzVGzZk14eXlh0qRJUKlU8PDw0He5eqW5wDlw4ADKlSunBMjscOGT2TZs2JDq/dKvXz+lh6Z///6wtbVVQsuqVavQpUuXVMGG/qFWq7FixQoYGBi8M3j/+eefmD17NvLly5fjvxAz0pEjR1CvXj107NgRV65cgb+/P0xNTdG5c2fMmTMHxYsXh7OzM7y8vDBjxoxsfZ/Nf4uKisLXX3+NokWL4vPPPwcALFq0CCYmJmjbti3atWuHatWqoUaNGli4cCEOHz4MIO0F1yh94uPjsWzZMpiYmGD69OnK9pTBWzPcGkhuTKtQoUK2nT8fHR2NevXqpQremov8ZcuWoXXr1rkiZAPJvWgrV65UGrVq1aqF0qVL4/fff08zeLdp0wY9e/bUS61Z0fPnz3Ht2jXcvn1b664cmhWkPT09tc7VW7ZsUTqZOCQ/9dRS4J/zelhYGIKDg3Hjxg1MnjwZ5ubmKFCgAMqXL48OHTrkihGdJ06cgIGBAWrWrIl27dphw4YNynNdunSBSqWCvb19jljP5UMxdH+EBw8e4JtvvlF+/umnn9C6dWs0b95cmUf7+PFjrFq1Cn379kXZsmWVE9WDBw/0VXaWERoaijJlymhdJJG2efPmoUaNGlorlEdERMDV1RVlypSBra1tqi89DinX9vz5c63pHkBy8F66dClUKpUydBxIvjDr06dPjlpFOzOkvKD99ddf4enpicqVK8PU1FQr7Dx+/BhXr15Fhw4dULt27VRrEWR3L1++xPr162FtbY2qVavC2toaJ0+eRFJSEqKjo/H06VOMGDEC9evXh6WlpdaQaEq/mJgYREVFKes0rFu3DkZGRu8M3pcvX8ZXX32F/PnzZ5vGtOPHj2PNmjUYO3Ystm7dqoTst2/fom7dunB0dNQaWfLkyRO4ublh8uTJ+io5U125cgXlypVDhw4dtEaAaYL36dOnlVCUmJiI+Ph4tG/fHn5+fnqqOGu5evUq3Nzc4OjoiBIlSmDMmDFai6++K3jv3buXjftIHq00d+5craHjKW8TaWJiojXd6vHjx7h16xZevHiBN2/eZHq9+jJw4EC4uLigU6dOaNSoETZu3AgA+Ouvv+Dk5KTMec8tDYUM3en0/PlzjBw5EhUrVsTXX3+tbN+5cyeaNGmCFi1a4Pfff9d6TUhICM6fP5/jLjQ/xZYtW1CgQAGcO3dO36VkGZrF5QDgiy++QJMmTZSfNfcSHThwIOzs7LQWl+BIgdTu3LmD4sWLo1ixYpg3bx7WrVuH2NhYpRV6xYoVMDQ0xIIFC5TXJCQkwMfHJ1e1un6sV69e4dmzZzh//jzCw8OVBdGOHTsGNzc31KlTR1kMBdD+Qs0Jq+rHx8fjzZs3iIyMVBq7YmJisGHDBpQsWVJrznDKxeJiY2NTDf2l9NGso9KlSxf4+/sDSP7/413BW9OYZmRklG2Gw06ZMgVOTk6oWrUqqlatCgMDA1SqVEm5vU5sbCyaNm2KwoULY9iwYfDx8UG1atXQtm1b5Xfk5O+FGzduoFChQpgyZUqao2Y8PT1RsmRJ7N69G69evcKbN28wc+ZMFC9eHMHBwXqoOGsJCAhAwYIFMWbMGPz+++/o06cPTE1NlRXe/33P5Jx466ZPceXKFZQsWRLdu3fHnj17tJ4LCwuDnZ0dhg4dmqtHM2lGThw4cAD9+/fH4cOH0bFjR9StW1dZ58XT0xO9e/fWZ5mZjqE7HW7cuIFOnTrh+PHjGDJkCDw8PLBixQrl+V27dsHLywstWrRQ5pIBuacFJz0ePXqEBg0a8ET+/x49eoQuXboot+Tw9fVVVgtNSkpSLqBOnToFQ0NDHDp0SG+1ZnVqtRrr1q2DjY0NDA0N0aJFC5QrVw5ly5ZF06ZNsX37dly4cAHr16+HSqXSGrVC/y0wMBBNmzaFk5OTMjysbdu2Su/tsWPH4OnpiQ4dOuD48ePK63LKSuVBQUHo27evsjq7i4sLduzYgZcvXyI+Ph4bNmyAtbU1Bg8erLyGo1AyxpUrV2BjY4MJEybgf//7n9ZF7buC96NHj+Dj45NtVvGePXs2rK2tcfr0aeUWOr/++ivq168Pa2trrWuOadOmoX379ujZs6dWD25OvuZ4+/YtunTpghEjRmht1ywyqmnU6tmzJ8qUKYMSJUqgRYsWKFGiRLYZ5aBLN2/ehKmpqdaIiPv3779z8aqQkJAceeumjxUUFAQrKytMmTIlzRFLp06dwuLFi3N0o9e7PHjwALt27dLaFh4ejvLly2PlypUIDw9Hx44dUadOHfzyyy/4448/YG5unuZCczkVQ3c6rF+/HrVq1QIABAcHY+DAgXB3d08zeLdp0yZVjzdpS9mzm9vduXMHHh4eaNGiBS5evAgfHx/06dMnzX2HDBmCtm3bIjQ0NJOrzD6ioqKwcuVKNG7cGL1798bLly+xY8cODBgwAGXLloWNjQ28vLxgbW0NlUqlDHmi97t69SrMzMwwduxY7N27F4GBgRg1ahSKFCmC0qVLK9NrDh8+DE9PT3Tp0kWZw5wTXLlyBYUKFUL//v2xZMkSzJkzBw0aNIChoSHGjBmD0NBQJXjb2tpi6NCh+i45x3jw4AHKlCmD8ePHa21PGTBTBm/NSvJA9mnwuX37NlxdXVNduALAxYsX0bhxYzg7O2vdajQhIUHrAj8nB24g+e+tW7eu1nXXoUOHMGbMGJiZmaFYsWLo1KkTgOQGwEWLFmHbtm05fpXoD6FWqzFq1CgUKlQI3377rRKi58yZA5VKhb59+2LhwoU4cOCA1i0279+/z5GaSD6/DBkyBEOGDNHa/vr1a9y8eRN//PGHMqUhp38O/+3BgwewsrKCSqVCy5YtsX37duXOAHv37kXdunURHh6O69evo2PHjmjatCnGjx+PDh065Kpptwzd6TBv3jy4uroqJ6rbt2+nGbz37NmDWrVqoUuXLgyW9MFu3bqFZs2aoWPHjnB1dUX16tXRt29f9O/fHwMHDkTv3r0xZMgQ2NjYoGbNmkovCGnTfD5fvXqFZcuWwdnZGd7e3srzd+7cwYULFzB8+HA0a9YMRkZGOXalzIz04sUL1K5dGxMnTgTwz/DV2NhY7NmzB6VKlUKlSpWUXt3jx4+jYsWK6NOnj3I7u+zs6dOnqFChQqrbMKnVakycOBEqlUqZwxcZGYlNmzbByMgIo0eP1kO1Oc+WLVtQr1493Lt37729SImJiVi3bh1UKhXmzp2biRV+PM3f89tvv8HKykprCHTKv/XEiRMwNDR8ZyNhbuhde/XqFcqXL4/BgwcjKCgI8+bNg5OTEzp16oRly5bhu+++g6OjI3x8fPRdapb04sUL9OvXD25ubti6dSu+/PJLWFhYwMfHBzt27EDTpk1Rr149WFlZoX379tixY4e+S85SWrVqhQkTJig/79u3D0OGDEH+/PlhZWWF0qVL49mzZwByV/AOCQlBjRo14OHhgerVq2PQoEEoUaIEvvnmG2zfvh2tW7fGwYMHASSPlmvSpAn69euHR48e6bnyzMXQ/R/eNc9W82HSBO9/DzXft28f7t+/n7nFUrYXFBSEFi1awNTUFFZWVhg6dCi8vLzQrFkztG/fHp06dUKzZs1S3TImt4uJidFanETz+YyKisLy5ctRpUoVDBgwQOs1mgvUlC369G4hISGoUKECTp06lWpl4Pj4eGzcuBEFCxbE0qVLldecOnUq264U/W+//PILatSoobTKJyUlaV1UDR8+HAUKFFBWUn716hW+//573gc4gwwePBguLi5pPqf5LEdHRyvDi7PTLemCgoIAJIdqU1PTVGudpFxQs0GDBsrQ6uzSg5/Rjh07BiMjI5QoUQIFCxbEmjVrlJ7Y+Ph4eHl5oW/fvnquMut48+YNYmNjlZFIsbGxGDRoEBwdHZEvXz4cOHBA2TcpKQlv3rzB8uXL0atXLy6a9v/UajXevn2LVq1aoVWrVti/fz9mzJiBkiVLok+fPti4cSPOnDkDFxcXrbUVcpPg4GB07NgR7du3x65du7B79240aNAA7du3h0qlQq1atZRG+evXr+fK6aUM3e/xvnm2iYmJypfgzZs3MXDgQHh6emotzET0MW7duoVWrVqhadOmDNcf4NatW3BycsLQoUPx888/p3peE7yrVq2Kzz77TNmuOfnnht6hjHDkyBGoVCpl4SLNcUvZ4+3k5IRBgwbprUZd8vf3R7FixVItBKf5+69duwYLCwusXbs21XP0aRISEjBixAhlete7wubs2bOxcuXKzCztk40bNw4NGzbE27dvcePGDRgYGGDOnDlp7vv27Vu4u7tj+fLlmVxl1vPgwQNcuHBB6VXUSEpKQpcuXTB9+nSo1epc/xnUDOetVKkSjIyMUKlSJSxYsABv377F0KFD4ezsjG+++Ub5TKWct821KP6R8nq/VKlScHJygo2NDTZt2qTVwTZ48GC0bNlSX2XqnabjyMvLCzdv3kR0dDTOnj2L1q1bY8uWLQBy9/eigdA7xcXFyaNHj2TJkiXy999/S3x8vOTNm1dERAwNDcXAIPnwlStXTpYvXy7W1tZy+vRpiYyM1GfZlM2VKVNG/P39xcDAQCZOnCi///671vMA9FRZ1nT06FF5+vSpuLq6yuDBg2Xw4MGyaNEi5fmCBQtKnz595LPPPpNLly5Jt27dRESUz7JKpdJL3dlN8eLFxdTUVLZv3y4JCQnKcVOpVAJAjI2NpUyZMvLmzRs9V5px7t+/r3zezM3NJTw8XO7fvy8iImq1WkT+ef9UqFBBjIyM5MWLF8rr+d76eK9fv5YnT57IixcvxMjISOrWrSvnz5+XPXv2iJGRkQBQ/j8QEYmKipKgoCCxtrbWY9XpM27cOFm3bp0sXbpUTExMpHz58jJq1Cjx9fWV7du3p9o/LCxMIiIiZOvWrTJo0CA5ePCgJCYm6qFy/XNwcBBXV1cpXLiwsi0+Pl58fX3ljz/+kL59+4pKpcrVn8GrV6+Kh4eH2Nvby5gxY+Snn36S0qVLy9SpU2XQoEEye/Zs8fDwkHXr1snatWslMTFRDA0NJSkpSUT++Y7Mrd68eSNv374VEREDAwNJTEyUcuXKyYULF+Tw4cMSHBwsffv2leLFiyuviYuLk5IlS0pSUlKuvFZzcnKSZcuWiYjIyJEjJSAgQNzd3WXfvn3Su3dvEcnl34t6jfzZwH/Ns+3Vqxd69+6NwYMHo3Xr1rlyuATpRnBwMFq3bg13d3f8+eef+i4ny4qMjISjoyP27NmDhw8f4osvvoCHhwdq1KiBFStWKMN7Y2JisHjxYnh4eODJkyd6rjr7SUhIgJubm7KQk6a1WtMDEBsbCy8vLyxevBhA9m/Njo2Nhbu7O4oXLw61Wo2nT5+iePHi6NChA8LCwgBAWTQnISEBT548gaenJ+8skAFu3LiBtm3bonnz5hgzZgySkpLw8OFDNGnSBGZmZvjll19SvWbmzJmoVKlStlmUZ/To0bCwsEBAQIDW9j179qBDhw5QqVT46quvcO3aNbx48QJ//fUXKleujGrVqmHgwIHw8/PLNn9rZtiyZQtGjRoFW1tbrYXmcqvw8HBUq1YNU6ZMSbV95cqVMDY2VhZ6HDBgAOrUqYNFixZxhfL/974RdP8e5QUkT22ZOnUqbGxslOkiuVlwcDCaN2+OZs2acVHpFBi6P8D75tl26tRJuTjgYkyU0W7cuIHOnTtzfYB30ISexYsXY8CAAVpfghYWFihevDjMzc3h5+eHI0eOAEgO6ZQ+mmAdGBgIe3t7eHh44MSJE1rPT58+Hfb29sq8wexOrVbj999/R6VKlVCjRg0AyYtpmpmZYciQIanutz1jxgyUKVOGDa+f6MqVKyhcuDAmT56Ms2fPKp9xIHmV6lq1asHExARz5szBkSNH8MMPP6B///6wsLDINreEmj17NgwNDbXO6wkJCWjQoAHWrVuHixcvYujQoVCpVLCwsIClpSVcXFzQvXt3PVaddQUFBaFBgwbo0KFDtpnHr2t///03KlWqhKtXrypBWnMef/nyJb788kvkzZsXJ0+exKtXr9CmTRt4eXlxjZP/t3r1apiZmWHdunUoVKgQBg0ahK+++irNfVetWoWhQ4eiSJEibPBJIWXH0dmzZ/VdTpbA0P2BOM+W9IXzqrSlNU/v5MmTsLGxUS66P/vsM9jZ2eHMmTNYvXo1nJycULlyZa74/pFSzqE9cuQIihYtikKFCqFevXro168f2rZtC2tra1y8eFGPVWa8pKQknD17FmXLlkXdunUBABMnToS5uTmcnJywfPlyfPHFFxgyZAjMzc15wfWJnjx5Amdn51T3C075/vv9998xbNgwmJiYwNTUFOXKlUPr1q0RGBiY2eV+lMjISLi6usLd3R0XLlwAkDyPtmbNmqhXr57WSv8XL17ETz/9hK1bt+Kvv/5StrM3MrWwsDC8fPlS32VkGRs2bICJiYny87+/M+/evas0SAPJCz9q1uug/x5Bd/v2bQBAREQE2rVrh169erGHOw3sONKmAnLhpIOPFBwcLKNGjRIRkWnTpkndunWV5wDk7nkKRJkgODhYVqxYIY8fP5batWvL+PHjledGjx4tEREREhcXJ6dPn5ZffvlFqlWrJiIit2/fFjMzM7GxsdFX6dlCZGSkABBLS0tlW1JSkhgaGkpISIhcv35dWrZsKc+fP5d58+bJrVu3JDExUWrWrCm9e/eWsmXL6rH6TxcaGiohISHi7u6ubEtISFDWAihevLj89ttvsmvXLlm3bp1cuXJFrK2tpVq1ajJx4kSpWLGiHqvP/g4cOCDTpk2T7du3S9myZZV1U0RSf8feuXNHXr9+LXZ2dlKwYEEpUKCAPkr+KMHBwTJu3DhRqVQyYcIEmTJlipibm8v27dvF3Nz8vdcTvNagD3H69Glp2rSpbN26VTp16pTmPtWrV5f69evLkiVLMrm6rC0hIUHy5Mkj/v7+EhgYKN99953ymStUqJCYmZnJq1evZPLkyVK3bl2pU6eOxMTEZKtzUGZKuR5WrqfHwJ8tcZ4tkX4EBATA2toa7du3R/fu3ZEnTx6t4V779++HpaUlKlSooAwxzO7zijPTs2fP4OLigjlz5iAiIgLAPz1qISEhsLS0xMCBA3NsL9uDBw9gZWUFlUqFBg0awMfHB8eOHcOrV68AAOfPn0flypXh5uam9Rq1Wo3Y2Fh9lZ2j+Pj4oESJEmk+p/ksx8TEpFqxOjvSzHksVKgQXF1dle2az9fz589Ru3Zt/Pbbb/oqkbKxhw8fwsbGBm3btkVISIiyXTPE/MWLF/D09FRWlM7tPmUEneb7kui/cPXydCpbtqx89dVXUqxYMbG3t9d3OUS5wpUrV8TDw0MGDx4su3fvlu+//14+//xzefz4sbK6aKtWraRevXpib28vFSpUEJFcvkpmOhUuXFg8PT1l48aNsmnTJomIiBBDQ0MJDw+XRo0aSZcuXWTdunViaGiY6rXIAQOm1Gq1ODg4SLly5SQ6OlqePHkirVq1kvr160vfvn3l3r17MmPGDImMjJSGDRsKAHFwcBCVSsVW/AxiY2Mj8fHxcvfu3VTPaT7Lfn5+Mnfu3MwuLcOVLVtWVqxYIdWrV5dChQrJ2bNnRST5zijPnz+XunXrSv78+aVevXp6rpSyo2LFisnq1avl0KFDMmPGDLl27ZqIiDJ6xN/fX548eaI1YjO30oxi7dSpkyxevFjZXr9+fenevbt89dVX0rlzZ9m/f78cPHhQPDw8ZOjQobJ//345evSoWFlZ6bF6yk44vPwjcbgEUeZ4+PChVK9eXRo2bCg//fSTsr179+5y8+ZNiY2NlWLFismQIUPEzMxMpk6dKgsWLJAmTZrosersRa1WKxdjkydPlu3bt8uoUaOkf//+8uLFCzl69KgMGTJEa7hvTnT79m2ZNGmSqNVq8fHxEXt7ezlz5oysXLlSEhISJDAwUEqXLi2BgYHSvn172bVrl75LzlEOHjworVu3lqVLlypTuUT+GVIdGxsro0ePFldXVxkyZIgeK804t27dklGjRolarZZ58+aJq6urODs7i4ODgxw6dEhEtD+fRB8qKSlJvv32W/H29pbSpUtL7dq1xd7eXu7duye//PKLHDt2TJmClVtdvnxZmjZtKrVr1xYTExPZuXOnzJs3TyZMmCAiyVNe+vbtK7a2trJz506pUKECp3jQR+NZ/CMxcBNljqSkJClZsqTExcXJH3/8ISIi8+fPl3379kmnTp1kwoQJ8ujRI/H19ZWkpCR5+vSp/PLLLzmi9zWzGBgYSEJCgoiILFiwQLp16ybLly+XjRs3ir29vQwdOjRXXPSXKVNG/Pz8JDY2VmbMmCFhYWHSvXt3OX36tBw+fFjWrFkjbdq0ERcXF5kxY4a+y83WoqKiJCIiQs6fPy/Pnj2TxMREadmypQwcOFAmTpwoGzduVEaxaO4FP3fuXDl16pQ0bdpUz9VnnLJly8ry5cvFyMhIpkyZIra2tlKsWDEGbvpkhoaG8vnnn8vp06fF2dlZzp07JydPnhQLCws5c+ZMrg/cHEFHmY093USU5Wl6g/LmzSs2Njayd+9e2bJli3h5eYmIyP3796VkyZKyY8cOMTIykjJlyoizs7Oeq87abt68KcHBwdKgQQMpWLCgiGiP4Jk8ebJs27ZNRo8eLX379pXChQvrs9xMdevWLRk5cqSIiPj4+Ej9+vW1nk9MTBQjIyN9lJYjXLt2TcaOHSsPHjyQ4OBgsbOzEzc3N9mwYYO8fftWRo8eLbt375ZevXpJw4YNJSoqSi5evCj79u2T48ePi4uLi77/hAx369Yt6dq1q1SsWFG+//57EWHgpoyTlJQkBgYGolKp+L4SjqAj/cjdnzoiyhbKli0ry5Ytk7dv38r3338vkyZNEi8vLwEgCQkJYmRkJJUrVxa1Wi3t2rVj4P4PL1++FBcXF+ncubNMmzZNJkyYIG/fvtWar71gwQLp2rWrLF++XLZu3SrPnj3TY8WZSzPfVqVSiZ+fn5w5c0breQbujxcYGCienp5SqVIl+eqrr+Tq1avSpUsXOXfunHh6ekpCQoJ8//334uvrKydPnpRRo0bJN998IwkJCXL69OkcGbhFkt9zhw8fZuAmndAEbhH21IpwBB3pB3u6iSjbuHPnjgwfPlwMDQ3Fx8dHWQRm5syZsnXrVvntt9/EwcFBz1VmD6NHj5Znz55Jy5YtZd26dRIZGSnNmzeXrl27So0aNZT9Jk2aJF9//bUsWLBAhg0blquCwK1bt2TcuHESEREhS5Ys0bqVGKVfZGSktGnTRjw9PWXhwoXK3Mi4uDg5dOiQjBkzRszNzeWvv/6SPHnyyPPnzyU+Pl4sLCzEwMBAjI2N9f0nZArOGSXSPY6go8yWe66eiCjbK126tKxcuVKZ33np0iVZuHChfPXVV7Jz504G7g+gVqtFRMTFxUUASK9eveS3336T8ePHS1JSknh4eMiUKVNky5YtIiKycOFCmTZtmnh5eeWqwC2ifbeKIkWK6LucbC8qKkpevHghbdq0EbVarQx1NTY2lpYtW8qsWbPk7t278vXXX4uIiIWFhdjb20u+fPlyTeAWYU8kUWbgCDrKbOzpJqJsR9MDef78eYmMjJSzZ8+Kq6urvsvKFjS9aNHR0VKlShXp3LmzLFy4UEREunXrJseOHZMGDRrIhQsXpGDBgrJgwQJp2bKlnqvWL96tImMcPXpUvLy85NGjR1KkSBHlvZiyx7tq1apSt25dWbdunb7LJaJcgCPoKLPkrm4LIsoRypYtK4sWLRJ3d3e5dOkSA/d/ePnypTx48EBEknvRkpKSxNTUVPz8/OTu3bvy5s0b6d+/v5w6dUr+/PNPWb9+vezdu1dKlCghZcuW1XP1+sfAnTGKFy8upqamsn37dklISNCaYwpAjI2NpUyZMvLmzRs9V0pEuQVH0FFmYU83EWVbCQkJkidPHn2XkaUFBQXJpEmTpFSpUjJixAitEH358mXp0qWLGBkZSWxsrPz0009a87mJMlJiYqLUrl1bYmJiZMuWLeLi4qK1mnJcXJy0bdtWmjVrJuPGjePcZiLKNBxBR7rGnm4iyrYYuN/v6tWrUr9+fbG3t5cOHToogVvT1lq1alUZMGCAPHz4UNauXZsqcLNNljKKWq0WIyMjWb9+vbx48UJGjBghv/32m4gkr6ysVqvlyy+/lKtXr0r79u1FhHObiSjzcAQd6Rp7uomIcqBHjx5JvXr1pGvXrjJv3rx3LoJ24cIFGT16tIwZM0a6dOkiSUlJWrcOI8oIKe9tfvToUenfv7+8efNGKleuLCVLllR6lg4dOiTVq1fXc7VElFtxBB3pCkM3EVEOtG3bNlm9erXs379fChYsKCIiN2/elEuXLsnx48elYsWKMnr0aFGpVNK5c2e5efOmXL16Vc9VU3YXGRkpAMTS0lLZpmnICQkJkevXr0vLli3l+fPnMm/ePLl165YkJiZKzZo1pXfv3lxDgIiIciQjfRdAREQZLzo6WsLDwyUsLEwKFiwomzdvlm3btsnNmzfF1tZW1q9fLxcuXJCtW7fKhAkTpG/fvvL06VOxt7fXd+mUTUVEREjTpk2lU6dOMmzYMLGyslIC9/3798XV1VXat28vzZo1EysrK1m8eLG+SyYiIsoUnNNNRJQDOTo6ilqtljFjxkjz5s1lxIgRUrlyZdm6daucOXNG9u7dKz/++KOcP39eKlSoIGfOnGHgpk9SuHBh8fT0lI0bN8qmTZskIiJCDA0NJTw8XBo1aiRdunSRdevWpTl9gYPuiIgoJ2NPNxFRDqKZO9ukSRPx8fGRc+fOSXh4uBw8eFCqV68uBQoUEJHkReicnJzE0tJSzM3N9Vw1ZXeaFchXrVolkydPluXLl4uISP/+/SUqKkomTpwoQ4YMeefaAlw0jYiIcjLO6SYiyuYePHggt27dkoYNG6YZatK69dLUqVPl9OnTsnv3brGyssqsUikHS7kA0eTJk2X79u0yatQo+fzzz5XGHiIiotyIPd1ERNlYZGSk1KpVSywsLKRAgQIyd+5cKVOmjJQuXVrZJzExUQlDDx48kJUrV8o333wjv//+OwM3fbSbN29KcHCwNGjQQAoWLCh58uSR+Ph4yZs3ryxYsEBERJYtWyYiIn379pXChQvrs1wiIiK9YegmIsrGoqOjpXjx4jJ8+HCJjIwUf39/CQsLk88++0xatGghZcqUUQL3zJkz5dq1axIcHCynTp2SKlWq6Ll6yq5evnwpLi4uolar5fPPP5e8efPKnDlzJG/evMo+CxYsELVaLcuXLxcDAwPp1auXWFtb67FqIiIi/eDwciKibOj169fKrcCWLFkiGzZskIsXL8qjR4/k4sWLMn/+fElMTJTatWvLtGnTpEiRInL69Gn5+++/pV27dlKiRAk9/wWU3Y0ePVqePXsmLVu2lHXr1klkZKQ0b95cunbtKjVq1FD2mzRpknz99deyYMECGTZs2DvndRMREeVU/OYjIspmgoKCpGPHjvLo0SMREenRo4eUKlVKDhw4ICVLlpTOnTuLvb29xMbGyokTJ6Rx48bSqFEjMTc3l1GjRjFw0ydRq9UiIuLi4iIApFevXvLb/7V37zFV138cx1/nWyjnHJQTWoojsTykNJG0zDlzTjEvcw4zSptTYbQ2L6jlLXI418Y0nZqLwSoNhuF0rXBGqCl5QRbmpKVmoscKPejUvDQOCXjg/P5wfn+SXbx0djyc5+Ovw76fcz7vc/5hr+/78/189u7VvHnz1NzcrEGDBuntt9/Whg0bJEkrVqzQ4sWLNXLkSAI3ACAk8d8PAIJMZWWl6uvrFRMTI0nq2rWrHA6HcnNzJUlpaWk6ePCgiouLdezYMWVkZKhTp07mMnPgftzclO+VV17RgQMHtGjRIknStGnT5Ha7FRkZKZfLpaysLCUkJKi0tFSZmZmKi4sLZNkAAAQMoRsAgsy5c+d0/fp1+Xw+s+u4atUqXb58WXFxcdq2bZtKS0sVHx8vSZoxY4aKiorUu3fvQJaNIHb16lWdPn1a0o3Q3dzcrIiICC1btkw///yz/vjjD6Wmpmrfvn2qrKzUJ598oq1btyo2NpawDQAIeYRuAAgCDQ0N5muv1yuHwyGLxSLDMOTz+WS1WpWYmCiPx6OKigr1799f0o3jwiS12uAKuBvHjx/X1KlTtXr1ap08eVKS9NBDD0mSevfurcOHD+u5557Tvn379OWXX8rpdKpjx47q27evSkpKCN0AgJBH6AaAB1xtba2mTp2qnTt3SpKam5vNo75udrptNptSU1N18eJFuVwu871/Pp8buBtHjhzR0KFDFR0drZdeeskM0Ddv5iQmJiotLU1nzpzRRx991GoDtVvHAQAQygjdAPCAa2xslNvt1po1a1RVVWWehSxJhmGYwXrIkCFKT09Xbm6uzp8/H8iS0Qa43W4lJycrLS1NeXl5Gjp0qHnt1ps5L774ovr27asrV65IunFT6K/GAQAQqjgyDACCgMvl0qxZs2S321VTUyOfz6c+ffrIMAwZhqGmpibZbDZt2bJFsbGx2r59u6KiogJdNoLYpk2blJeXp5KSEvN4uurqan3//ff65ptv9PTTT2vOnDmyWCxKSUlRdXW1jhw5EuCqAQB48NDpBoAg4HQ6tXbtWl27dk3V1dWqqamRzWbT2bNnVVtbK4/Ho0uXLqlfv35av349gRv3zePx6MKFC+aqicLCQr355ptavHixjh49qvnz52vKlCmSpPnz56uxsVHnzp0LZMkAADyQ6HQDQBBxuVyaO3eumpqatGrVKiUkJAS6JLRRu3bt0syZMxUXFyev16uKigrNmDFD48eP16BBg1RaWqpx48bp22+/Va9evXT9+nV17tw50GUDAPDAodMNAEHE6XRq9erVMgxDCxYsUHl5eavr3EfF/fJ6vZKkESNGKDMzU48//rjsdrtKS0u1ZMkSDRo0SJIUFhamXr16KSoqSpGRkQRuAAD+Bp1uAAhCJ0+e1FtvvaXffvtN77//vgYOHBjokhDETp8+rZMnT2rYsGEyjNvvx/t8vts2RXvnnXe0f/9+FRcXm7vpAwCA2z0c6AIAAHcvLi5OK1euVFZWlqKjowNdDoLYlStXNHDgQDkcDtntdmVnZ8vpdKpnz57mGK/Xq7CwMEk3AnpOTo4+/PBDlZeXE7gBAPgXdLoBIIjdenwYcC/OnDmjlJQUzZgxQ1euXNG2bdt0/vx5paena8yYMXI6nebYJUuW6Mcff9SJEyf06aefKjExMYCVAwAQHAjdAACEoLq6OvMosDVr1ig/P1+HDh2S2+3WoUOHtHz5cnm9Xg0ePFiLFy9Wt27dtH//flVVVSk5OVmxsbEB/gYAAAQHNlIDACDEHD9+XBMmTJDb7ZYkvfbaa3ryySf11Vdf6YknnlBKSoqio6PV0NCg3bt3KykpScOHD1dkZKRmz55N4AYA4C4QugEACDGVlZWqr69XTEyMJKlr165yOBzKzc2VJKWlpengwYMqLi7WsWPHlJGRoU6dOpnPdQMAgDvH8nIAAELMsmXL9MUXX+i7776Tz+eTYRi6dOmSRo0apd9//111dXUqLS1V//79zfewfwAAAPeGTjcAACGgoaHBfO31euVwOGSxWGQYhnw+n6xWqxITE+XxeFRRUWEG7pv35gncAADcG0I3AABtXG1traZOnaqdO3dKkpqbm82jvlpaWiRJNptNqampunjxolwul/neP5/PDQAA7g6hGwCANq6xsVFut1tr1qxRVVVVq6XihmGYwXrIkCFKT09Xbm6uzp8/H8iSAQBoM3imGwCAEOByuTRr1izZ7XbV1NTI5/OpT58+MgxDhmGoqalJNptNW7ZsUWxsrLZv366oqKhAlw0AQNCj0w0AQAhwOp1au3atrl27purqatXU1Mhms+ns2bOqra2Vx+PRpUuX1K9fP61fv57ADQDAf4RONwAAIcTlcmnu3LlqamrSqlWrlJCQEOiSAABo0+h0AwAQQpxOp1avXi3DMLRgwQKVl5e3us69eAAA/luEbgAAQsxTTz2lDz74QGFhYVq4cKEOHDhgXmO3cgAA/luEbgAAQlBcXJxWrlypmJgYRUdHB7ocAADaLJ7pBgAghN16fBgAAPjvEboBAAAAAPATlpcDAAAAAOAnhG4AAAAAAPyE0A0AAAAAgJ8QugEAAAAA8BNCNwAAAAAAfkLoBgAAAADATwjdAADgLxUUFMjhcAS6DAAAghqhGwCAIJCamiqLxSKLxaJ27drJ6XTq3Xffldfr9ducEydO1IkTJ/z2+QAAhIKHA10AAAC4M6NHj1Z+fr4aGxtVWlqqmTNnKiwsTJmZma3GNTU1qV27dvc9n9VqldVqve/PAQAglNHpBgAgSLRv315du3ZVbGyspk+frhEjRmjr1q1KTU3V+PHjlZ2drW7duqlXr16SpCNHjmj48OGyWq3q1KmT3njjDXk8HknS119/rfDwcF29erXVHHPmzNHw4cMl3b68fOnSpXrmmWe0YcMG9ejRQ5GRkZo0aZLq6urMMS0tLVqxYoWcTqfat2+v7t27Kzs727x+5swZvfrqq3I4HIqKilJycrJ+/fVX//xgAAA8AAjdAAAEKavVqqamJklSWVmZqqurtXPnTpWUlKi+vl6jRo3SI488ooMHD+qzzz7Trl27NGvWLElSUlKSHA6HPv/8c/PzmpubtXnzZk2ePPlv5zx16pS2bNmikpISlZSUaO/evVq+fLl5PTMzU8uXL1dWVpaOHTumjRs3qkuXLpKk69eva9SoUerQoYPKy8tVUVGhiIgIjR492vweAAC0NSwvBwAgyPh8PpWVlWnHjh3KyMjQxYsXZbfbtW7dOnNZ+ccff6yGhgYVFhbKbrdLknJycjRu3Di999576tKliyZNmqSNGzcqPT1d0o3gfvXqVb388st/O3dLS4sKCgrUoUMHSdKUKVNUVlam7Oxs1dXVae3atcrJydG0adMkST179tQLL7wgSdq8ebNaWlq0bt06WSwWSVJ+fr4cDof27NmjkSNH+ucHAwAggOh0AwAQJEpKShQREaHw8HCNGTNGEydO1NKlSyVJCQkJrZ7j/umnn5SYmGgGbkkaPHiwWlpaVF1dLUmaPHmy9uzZo7Nnz0qSioqKNHbs2H/csbxHjx5m4Jak6OhoXbhwwZyzsbFRSUlJf/neH374QS6XSx06dFBERIQiIiIUFRWlhoYGnTp16p5+EwAAHnR0ugEACBLDhg1TXl6e2rVrp27duunhh///b/zWcH2nBgwYoJ49e2rTpk2aPn26iouLVVBQ8I/vCQsLa/W3xWJRS0uLJP3rpmsej0fPPvusioqKbrv26KOP3l3xAAAECUI3AABBwm63y+l03tHY+Ph4FRQUqL6+3gzkFRUVMgzD3GhNutHtLioqUkxMjAzD0NixY++5vri4OFmtVpWVlen111+/7Xr//v21efNmPfbYY+rYseM9zwMAQDBheTkAAG3Q5MmTFR4ermnTpuno0aPavXu3MjIyNGXKFHNjs5vjqqqqlJ2drZSUFLVv3/6e5wwPD9eiRYu0cOFCFRYW6tSpU6qsrNT69evNuTp37qzk5GSVl5frl19+0Z49ezR79my53e77/s4AADyICN0AALRBNptNO3bs0OXLlzVgwAClpKQoKSlJOTk5rcY5nU49//zzOnz48D/uWn6nsrKyNG/ePC1ZskTx8fGaOHGi+cy3zWbTvn371L17d02YMEHx8fFKT09XQ0MDnW8AQJtl8fl8vkAXAQAAAABAW0SnGwAAAAAAPyF0AwAAAADgJ4RuAAAAAAD8hNANAAAAAICfELoBAAAAAPATQjcAAAAAAH5C6AYAAAAAwE8I3QAAAAAA+AmhGwAAAAAAPyF0AwAAAADgJ4RuAAAAAAD85H+b9ZMO+b1s4AAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -417,7 +438,7 @@ ], "source": [ "plt.figure(figsize=(10, 5))\n", - "provinces.plot(kind=\"bar\", color=\"skyblue\")\n", + "provinces.plot(kind=\"bar\")\n", "plt.xlabel(\"Province\")\n", "plt.ylabel(\"Count\")\n", "plt.xticks(rotation=45)\n", @@ -427,7 +448,7 @@ }, { "cell_type": "code", - "execution_count": 60, + "execution_count": 10, "id": "9fb8c5ef88904668", "metadata": { "ExecuteTime": { @@ -438,7 +459,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -465,7 +486,7 @@ }, { "cell_type": "code", - "execution_count": 53, + "execution_count": 11, "id": "8accaa686b4dad31", "metadata": { "ExecuteTime": { @@ -476,7 +497,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -495,7 +516,7 @@ }, { "cell_type": "code", - "execution_count": 56, + "execution_count": 12, "id": "23b3a22f99657c57", "metadata": { "ExecuteTime": { @@ -506,7 +527,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -545,7 +566,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 13, "id": "0374f8ee", "metadata": { "ExecuteTime": { @@ -584,53 +605,53 @@ " \n", " \n", " 0\n", + " dikoko pamitshefu fabrice\n", + " dikoko\n", + " pamitshefu\n", + " fabrice\n", + " \n", + " \n", + " 1\n", " epenge djongesongo jonas\n", " epenge\n", " djongesongo\n", " jonas\n", " \n", " \n", - " 1\n", + " 2\n", " eyongoyongo shako michel\n", " eyongoyongo\n", " shako\n", " michel\n", " \n", " \n", - " 2\n", + " 3\n", + " kassongo osango israel\n", + " kassongo\n", + " osango\n", + " israel\n", + " \n", + " \n", + " 4\n", " okawonga ongondjo alphonse\n", " okawonga\n", " ongondjo\n", " alphonse\n", " \n", - " \n", - " 3\n", - " ombala lokolo nathals\n", - " ombala\n", - " lokolo\n", - " nathals\n", - " \n", - " \n", - " 4\n", - " shongo matete albert\n", - " shongo\n", - " matete\n", - " albert\n", - " \n", " \n", "\n", "" ], "text/plain": [ " name surname middle_name first_name\n", - "0 epenge djongesongo jonas epenge djongesongo jonas\n", - "1 eyongoyongo shako michel eyongoyongo shako michel\n", - "2 okawonga ongondjo alphonse okawonga ongondjo alphonse\n", - "3 ombala lokolo nathals ombala lokolo nathals\n", - "4 shongo matete albert shongo matete albert" + "0 dikoko pamitshefu fabrice dikoko pamitshefu fabrice\n", + "1 epenge djongesongo jonas epenge djongesongo jonas\n", + "2 eyongoyongo shako michel eyongoyongo shako michel\n", + "3 kassongo osango israel kassongo osango israel\n", + "4 okawonga ongondjo alphonse okawonga ongondjo alphonse" ] }, - "execution_count": 8, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -652,7 +673,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 14, "id": "f2924f79", "metadata": { "ExecuteTime": { @@ -663,7 +684,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -687,7 +708,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 15, "id": "76979895", "metadata": { "ExecuteTime": { @@ -725,52 +746,52 @@ " \n", " 0\n", " jean\n", - " 62143\n", + " 89561\n", " \n", " \n", " 1\n", " joseph\n", - " 26678\n", + " 39365\n", " \n", " \n", " 2\n", " esther\n", - " 24639\n", + " 36778\n", " \n", " \n", " 3\n", " marie\n", - " 23330\n", + " 34401\n", " \n", " \n", " 4\n", - " grace\n", - " 20964\n", + " dorcas\n", + " 31094\n", " \n", " \n", " 5\n", - " david\n", - " 20909\n", + " grace\n", + " 31052\n", " \n", " \n", " 6\n", - " dorcas\n", - " 20840\n", + " david\n", + " 30970\n", " \n", " \n", " 7\n", " ruth\n", - " 20633\n", + " 30733\n", " \n", " \n", " 8\n", - " patrick\n", - " 20209\n", + " sarah\n", + " 30188\n", " \n", " \n", " 9\n", - " sarah\n", - " 20190\n", + " moise\n", + " 29789\n", " \n", " \n", "\n", @@ -778,19 +799,19 @@ ], "text/plain": [ " First name quantity\n", - "0 jean 62143\n", - "1 joseph 26678\n", - "2 esther 24639\n", - "3 marie 23330\n", - "4 grace 20964\n", - "5 david 20909\n", - "6 dorcas 20840\n", - "7 ruth 20633\n", - "8 patrick 20209\n", - "9 sarah 20190" + "0 jean 89561\n", + "1 joseph 39365\n", + "2 esther 36778\n", + "3 marie 34401\n", + "4 dorcas 31094\n", + "5 grace 31052\n", + "6 david 30970\n", + "7 ruth 30733\n", + "8 sarah 30188\n", + "9 moise 29789" ] }, - "execution_count": 10, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -804,19 +825,23 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 16, "id": "61e35f38-96da-4d04-9779-9b3409adeae6", "metadata": {}, "outputs": [ { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" + "ename": "KeyError", + "evalue": "'province_clean'", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mKeyError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[16]\u001b[39m\u001b[32m, line 3\u001b[39m\n\u001b[32m 1\u001b[39m \u001b[38;5;66;03m# Most common first name by province\u001b[39;00m\n\u001b[32m 2\u001b[39m top_names = (\n\u001b[32m----> \u001b[39m\u001b[32m3\u001b[39m \u001b[43mdf_simple\u001b[49m\u001b[43m.\u001b[49m\u001b[43mgroupby\u001b[49m\u001b[43m(\u001b[49m\u001b[43m[\u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mprovince_clean\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mfirst_name\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m.size().reset_index(name=\u001b[33m\"\u001b[39m\u001b[33mcount\u001b[39m\u001b[33m\"\u001b[39m)\n\u001b[32m 4\u001b[39m )\n\u001b[32m 5\u001b[39m top_names = top_names.sort_values([\u001b[33m\"\u001b[39m\u001b[33mprovince_clean\u001b[39m\u001b[33m\"\u001b[39m, \u001b[33m\"\u001b[39m\u001b[33mcount\u001b[39m\u001b[33m\"\u001b[39m], ascending=[\u001b[38;5;28;01mTrue\u001b[39;00m, \u001b[38;5;28;01mFalse\u001b[39;00m])\n\u001b[32m 6\u001b[39m top_names = top_names.drop_duplicates(subset=\u001b[33m\"\u001b[39m\u001b[33mprovince_clean\u001b[39m\u001b[33m\"\u001b[39m, keep=\u001b[33m\"\u001b[39m\u001b[33mfirst\u001b[39m\u001b[33m\"\u001b[39m)\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/dev/community/analysis/drc-ners-nlp/.venv/lib/python3.11/site-packages/pandas/core/frame.py:9210\u001b[39m, in \u001b[36mDataFrame.groupby\u001b[39m\u001b[34m(self, by, axis, level, as_index, sort, group_keys, observed, dropna)\u001b[39m\n\u001b[32m 9207\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m level \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;129;01mand\u001b[39;00m by \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[32m 9208\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\u001b[33m\"\u001b[39m\u001b[33mYou have to supply one of \u001b[39m\u001b[33m'\u001b[39m\u001b[33mby\u001b[39m\u001b[33m'\u001b[39m\u001b[33m and \u001b[39m\u001b[33m'\u001b[39m\u001b[33mlevel\u001b[39m\u001b[33m'\u001b[39m\u001b[33m\"\u001b[39m)\n\u001b[32m-> \u001b[39m\u001b[32m9210\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mDataFrameGroupBy\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 9211\u001b[39m \u001b[43m \u001b[49m\u001b[43mobj\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[32m 9212\u001b[39m \u001b[43m \u001b[49m\u001b[43mkeys\u001b[49m\u001b[43m=\u001b[49m\u001b[43mby\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 9213\u001b[39m \u001b[43m \u001b[49m\u001b[43maxis\u001b[49m\u001b[43m=\u001b[49m\u001b[43maxis\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 9214\u001b[39m \u001b[43m \u001b[49m\u001b[43mlevel\u001b[49m\u001b[43m=\u001b[49m\u001b[43mlevel\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 9215\u001b[39m \u001b[43m \u001b[49m\u001b[43mas_index\u001b[49m\u001b[43m=\u001b[49m\u001b[43mas_index\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 9216\u001b[39m \u001b[43m \u001b[49m\u001b[43msort\u001b[49m\u001b[43m=\u001b[49m\u001b[43msort\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 9217\u001b[39m \u001b[43m \u001b[49m\u001b[43mgroup_keys\u001b[49m\u001b[43m=\u001b[49m\u001b[43mgroup_keys\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 9218\u001b[39m \u001b[43m \u001b[49m\u001b[43mobserved\u001b[49m\u001b[43m=\u001b[49m\u001b[43mobserved\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 9219\u001b[39m \u001b[43m \u001b[49m\u001b[43mdropna\u001b[49m\u001b[43m=\u001b[49m\u001b[43mdropna\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 9220\u001b[39m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/dev/community/analysis/drc-ners-nlp/.venv/lib/python3.11/site-packages/pandas/core/groupby/groupby.py:1331\u001b[39m, in \u001b[36mGroupBy.__init__\u001b[39m\u001b[34m(self, obj, keys, axis, level, grouper, exclusions, selection, as_index, sort, group_keys, observed, dropna)\u001b[39m\n\u001b[32m 1328\u001b[39m \u001b[38;5;28mself\u001b[39m.dropna = dropna\n\u001b[32m 1330\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m grouper \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[32m-> \u001b[39m\u001b[32m1331\u001b[39m grouper, exclusions, obj = \u001b[43mget_grouper\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 1332\u001b[39m \u001b[43m \u001b[49m\u001b[43mobj\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1333\u001b[39m \u001b[43m \u001b[49m\u001b[43mkeys\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1334\u001b[39m \u001b[43m \u001b[49m\u001b[43maxis\u001b[49m\u001b[43m=\u001b[49m\u001b[43maxis\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1335\u001b[39m \u001b[43m \u001b[49m\u001b[43mlevel\u001b[49m\u001b[43m=\u001b[49m\u001b[43mlevel\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1336\u001b[39m \u001b[43m \u001b[49m\u001b[43msort\u001b[49m\u001b[43m=\u001b[49m\u001b[43msort\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1337\u001b[39m \u001b[43m \u001b[49m\u001b[43mobserved\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mif\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mobserved\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01mis\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mlib\u001b[49m\u001b[43m.\u001b[49m\u001b[43mno_default\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01melse\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mobserved\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1338\u001b[39m \u001b[43m \u001b[49m\u001b[43mdropna\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mdropna\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1339\u001b[39m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 1341\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m observed \u001b[38;5;129;01mis\u001b[39;00m lib.no_default:\n\u001b[32m 1342\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28many\u001b[39m(ping._passed_categorical \u001b[38;5;28;01mfor\u001b[39;00m ping \u001b[38;5;129;01min\u001b[39;00m grouper.groupings):\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/dev/community/analysis/drc-ners-nlp/.venv/lib/python3.11/site-packages/pandas/core/groupby/grouper.py:1043\u001b[39m, in \u001b[36mget_grouper\u001b[39m\u001b[34m(obj, key, axis, level, sort, observed, validate, dropna)\u001b[39m\n\u001b[32m 1041\u001b[39m in_axis, level, gpr = \u001b[38;5;28;01mFalse\u001b[39;00m, gpr, \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[32m 1042\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m-> \u001b[39m\u001b[32m1043\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mKeyError\u001b[39;00m(gpr)\n\u001b[32m 1044\u001b[39m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(gpr, Grouper) \u001b[38;5;129;01mand\u001b[39;00m gpr.key \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[32m 1045\u001b[39m \u001b[38;5;66;03m# Add key to exclusions\u001b[39;00m\n\u001b[32m 1046\u001b[39m exclusions.add(gpr.key)\n", + "\u001b[31mKeyError\u001b[39m: 'province_clean'" + ] } ], "source": [ @@ -856,7 +881,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "id": "5022f136-3174-406d-acf0-dee379969213", "metadata": { "ExecuteTime": { @@ -901,7 +926,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "id": "cfeec858-ad7e-4173-9262-a7d6e08a31d9", "metadata": { "ExecuteTime": { @@ -942,7 +967,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "id": "cc1489c8-904f-4116-9872-8ba79f72eb94", "metadata": {}, "outputs": [ @@ -999,7 +1024,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": null, "id": "f94818e6-7c91-4f33-8070-0ec2cb8c0063", "metadata": {}, "outputs": [ @@ -1025,7 +1050,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": null, "id": "66e7aa9c-34ee-4a3b-aa6e-806eee980df4", "metadata": {}, "outputs": [ @@ -1164,7 +1189,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": null, "id": "26d227c3-b32a-4cf9-843f-fb6959090a48", "metadata": {}, "outputs": [ @@ -1222,1202 +1247,7 @@ }, { "cell_type": "code", - "execution_count": 23, - "id": "b4a18bad-bd59-4909-81ac-705767675dd8", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "AUTRES\n", - " jean 3626\n", - " patrick 2202\n", - " tresor 1965\n", - "\n", - "BANDUNDU\n", - " jean 4946\n", - " joel 1583\n", - " marie 1163\n", - "\n", - "BAS-CONGO\n", - " jean 3380\n", - " joseph 2090\n", - " marie 1803\n", - "\n", - "EQUATEUR\n", - " jean 8194\n", - " joseph 3095\n", - " marie 2318\n", - "\n", - "KASAÏ-OCCIDENTAL\n", - " jean 10390\n", - " andre 4787\n", - " marie 3589\n", - "\n", - "KASAÏ-ORIENTAL\n", - " jean 14205\n", - " joseph 5192\n", - " marie 4772\n", - "\n", - "KATANGA\n", - " jean 5300\n", - " ruth 3185\n", - " esther 3018\n", - "\n", - "KINSHASA\n", - " ruth 9823\n", - " dorcas 9801\n", - " sarah 9696\n", - "\n", - "MANIEMA\n", - " jean 1200\n", - " joseph 649\n", - " marie 528\n", - "\n", - "NORD-KIVU\n", - " justin 3301\n", - " grace 2991\n", - " moise 2790\n", - "\n", - "ORIENTALE\n", - " jean 4447\n", - " joseph 2755\n", - " moise 2566\n", - "\n", - "SUD-KIVU\n", - " justin 2244\n", - " christian 1835\n", - " jean 1762\n", - "\n" - ] - } - ], - "source": [ - "# top 3 most popular first names by region\n", - "grouped = df_simple.groupby([\"province\", \"first_name\"]).size().reset_index(name=\"count\")\n", - "grouped = grouped.sort_values([\"province\", \"count\"], ascending=[True, False])\n", - "top3_by_region = grouped.groupby(\"province\").head(3)\n", - "\n", - "for province, group in top3_by_region.groupby(\"province\"):\n", - " print(f\"{province.upper()}\")\n", - " for _, row in group.iterrows():\n", - " print(f\" {row['first_name']:<15} {row['count']}\")\n", - " print()" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "id": "18744cca-72f1-4830-affc-e64af824225a", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "AUTRES - Neutral\n", - " m 26\n", - " f 4\n", - "\n", - "AUTRES - f\n", - " gracia 1257\n", - " marie 1031\n", - " sarah 892\n", - "\n", - "AUTRES - m\n", - " jean 3617\n", - " patrick 2189\n", - " tresor 1948\n", - "\n", - "BANDUNDU - Neutral\n", - " m 68\n", - " f 27\n", - "\n", - "BANDUNDU - f\n", - " marie 1126\n", - " ruth 1059\n", - " esther 1053\n", - "\n", - "BANDUNDU - m\n", - " jean 4917\n", - " joel 1539\n", - " dieu 1118\n", - "\n", - "BAS-CONGO - Neutral\n", - " f 3\n", - " m 2\n", - "\n", - "BAS-CONGO - f\n", - " marie 1790\n", - " dorcas 1377\n", - " esther 1166\n", - "\n", - "BAS-CONGO - m\n", - " jean 3369\n", - " joseph 2082\n", - " andre 1169\n", - "\n", - "EQUATEUR - Neutral\n", - " m 8\n", - " f 2\n", - "\n", - "EQUATEUR - f\n", - " marie 2277\n", - " esther 1807\n", - " ruth 1371\n", - "\n", - "EQUATEUR - m\n", - " jean 8161\n", - " joseph 3083\n", - " jeremie 2243\n", - "\n", - "KASAÏ-OCCIDENTAL - Neutral\n", - " m 17\n", - " f 9\n", - "\n", - "KASAÏ-OCCIDENTAL - f\n", - " marie 3517\n", - " therese 1594\n", - " esther 1456\n", - "\n", - "KASAÏ-OCCIDENTAL - m\n", - " jean 10374\n", - " andre 4782\n", - " francois 3332\n", - "\n", - "KASAÏ-ORIENTAL - Neutral\n", - " m 14\n", - " f 1\n", - "\n", - "KASAÏ-ORIENTAL - f\n", - " marie 4713\n", - " therese 2506\n", - " rachel 1599\n", - "\n", - "KASAÏ-ORIENTAL - m\n", - " jean 14179\n", - " joseph 5178\n", - " andre 4469\n", - "\n", - "KATANGA - Neutral\n", - " m 3\n", - "\n", - "KATANGA - f\n", - " ruth 3171\n", - " esther 3005\n", - " sarah 2889\n", - "\n", - "KATANGA - m\n", - " jean 5282\n", - " daniel 2679\n", - " gloire 2676\n", - "\n", - "KINSHASA - Neutral\n", - " m 26\n", - " f 5\n", - "\n", - "KINSHASA - f\n", - " ruth 9756\n", - " dorcas 9737\n", - " sarah 9626\n", - "\n", - "KINSHASA - m\n", - " jonathan 8574\n", - " christian 7770\n", - " exauce 5838\n", - "\n", - "MANIEMA - Neutral\n", - " f 3\n", - " m 2\n", - "\n", - "MANIEMA - f\n", - " marie 496\n", - " esther 217\n", - " jeanne 216\n", - "\n", - "MANIEMA - m\n", - " jean 1198\n", - " joseph 646\n", - " pierre 432\n", - "\n", - "NORD-KIVU - Neutral\n", - " m 15\n", - " f 4\n", - "\n", - "NORD-KIVU - f\n", - " esther 2681\n", - " rachel 2384\n", - " neema 1764\n", - "\n", - "NORD-KIVU - m\n", - " justin 3255\n", - " moise 2777\n", - " jean 2098\n", - "\n", - "ORIENTALE - Neutral\n", - " m 7\n", - " f 3\n", - "\n", - "ORIENTALE - f\n", - " esther 2383\n", - " marie 1963\n", - " sarah 1401\n", - "\n", - "ORIENTALE - m\n", - " jean 4430\n", - " joseph 2736\n", - " moise 2557\n", - "\n", - "SUD-KIVU - Neutral\n", - " m 25\n", - " f 9\n", - "\n", - "SUD-KIVU - f\n", - " esther 1174\n", - " francine 906\n", - " esperance 839\n", - "\n", - "SUD-KIVU - m\n", - " justin 2205\n", - " christian 1817\n", - " jean 1748\n", - "\n" - ] - } - ], - "source": [ - "# Group by region, gender and first name, then count\n", - "def determine_sex_category(row):\n", - " if row[\"first_name\"] in neutral_firstnames:\n", - " return \"Neutral\"\n", - " return row[\"sex\"]\n", - "\n", - "\n", - "df_simple[\"sex_category\"] = df_simple.apply(determine_sex_category, axis=1)\n", - "\n", - "# Groupement\n", - "grouped = (\n", - " df_simple.groupby([\"province\", \"sex_category\", \"first_name\"])\n", - " .size()\n", - " .reset_index(name=\"count\")\n", - ")\n", - "grouped = grouped.sort_values(\n", - " [\"province\", \"sex_category\", \"count\"], ascending=[True, True, False]\n", - ")\n", - "top3_by_region_sex = grouped.groupby([\"province\", \"sex_category\"]).head(3)\n", - "\n", - "for (province, sex), group in top3_by_region_sex.groupby([\"province\", \"sex_category\"]):\n", - " print(f\"{province.upper()} - {sex}\")\n", - " for _, row in group.iterrows():\n", - " print(f\" {row['first_name']:<15} {row['count']}\")\n", - " print()" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "id": "abbaa917-a6ba-45e7-b84d-d27bc104485b", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Top 10 surnames for sex: f\n", - " kavira 18323\n", - " kavugho 10909\n", - " kahindo 10821\n", - " ntumba 9216\n", - " ilunga 8672\n", - " ngalula 8446\n", - " mbuyi 8437\n", - " masika 8290\n", - " mujinga 8017\n", - " kapinga 7920\n", - "\n", - "Top 10 surnames for sex: m\n", - " ilunga 24581\n", - " kambale 18604\n", - " ngoy 16610\n", - " kasongo 16420\n", - " kasereka 12842\n", - " muhindo 11467\n", - " kazadi 9761\n", - " mutombo 9262\n", - " kakule 9179\n", - " mumbere 8871\n", - "\n" - ] - } - ], - "source": [ - "# Grouping surnames by sex\n", - "surnames_by_sex = df_simple.groupby([\"surname\", \"sex\"]).size().reset_index(name=\"count\")\n", - "surnames_by_sex = surnames_by_sex.sort_values([\"sex\", \"count\"], ascending=[True, False])\n", - "top10_per_sex = surnames_by_sex.groupby(\"sex\").head(10)\n", - "\n", - "for sex, group in top10_per_sex.groupby(\"sex\"):\n", - " print(f\"Top 10 surnames for sex: {sex}\")\n", - " for _, row in group.iterrows():\n", - " print(f\" {row['surname']:<15} {row['count']}\")\n", - " print()" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "id": "5823f6ff-b4bb-44df-803c-724bf244e885", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "AUTRES\n", - " ilunga 7135\n", - " ngoy 5776\n", - " kasongo 4363\n", - "\n", - "BANDUNDU\n", - " mbo 3479\n", - " mpia 2408\n", - " mputu 1777\n", - "\n", - "BAS-CONGO\n", - " nzuzi 3836\n", - " nlandu 3292\n", - " matondo 2796\n", - "\n", - "EQUATEUR\n", - " mboyo 1676\n", - " lokuli 902\n", - " bolumbu 816\n", - "\n", - "KASAÏ-OCCIDENTAL\n", - " ntumba 4999\n", - " mbuyi 4114\n", - " kanku 2805\n", - "\n", - "KASAÏ-ORIENTAL\n", - " ngoyi 7899\n", - " ilunga 5223\n", - " mbuyi 4719\n", - "\n", - "KATANGA\n", - " ilunga 15911\n", - " ngoy 13243\n", - " kasongo 9776\n", - "\n", - "KINSHASA\n", - " ntumba 4741\n", - " nsimba 4470\n", - " matondo 4382\n", - "\n", - "MANIEMA\n", - " amisi 964\n", - " ramazani 843\n", - " assani 596\n", - "\n", - "NORD-KIVU\n", - " kambale 17178\n", - " kavira 17001\n", - " kasereka 11931\n", - "\n", - "ORIENTALE\n", - " bahati 1059\n", - " baraka 867\n", - " kambale 849\n", - "\n", - "SUD-KIVU\n", - " bahati 2353\n", - " furaha 1964\n", - " mugisho 1876\n", - "\n" - ] - } - ], - "source": [ - "# Grouping surnames by region\n", - "surnames_by_region = (\n", - " df_simple.groupby([\"province\", \"surname\"]).size().reset_index(name=\"count\")\n", - ")\n", - "surnames_by_region = surnames_by_region.sort_values(\n", - " [\"province\", \"count\"], ascending=[True, False]\n", - ")\n", - "top3_surnames_per_region = surnames_by_region.groupby(\"province\").head(3)\n", - "\n", - "for province, group in top3_surnames_per_region.groupby(\"province\"):\n", - " print(f\"{province.upper()}\")\n", - " for _, row in group.iterrows():\n", - " print(f\" {row['surname']:<15} {row['count']}\")\n", - " print()" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "id": "a15ba0c5-9a4f-4876-93ac-5f4a5a5d50ba", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "AUTRES - f\n", - " ilunga 1753\n", - " ngoy 982\n", - " ngoie 960\n", - "\n", - "AUTRES - m\n", - " ilunga 5382\n", - " ngoy 4794\n", - " kasongo 3406\n", - "\n", - "BANDUNDU - f\n", - " mbo 1207\n", - " mpia 875\n", - " mputu 658\n", - "\n", - "BANDUNDU - m\n", - " mbo 2272\n", - " mpia 1533\n", - " mputu 1119\n", - "\n", - "BAS-CONGO - f\n", - " nzuzi 2054\n", - " nlandu 1529\n", - " tsimba 1463\n", - "\n", - "BAS-CONGO - m\n", - " nzuzi 1782\n", - " nlandu 1763\n", - " ngoma 1669\n", - "\n", - "EQUATEUR - f\n", - " mboyo 796\n", - " bolumbu 633\n", - " amba 466\n", - "\n", - "EQUATEUR - m\n", - " mboyo 880\n", - " lokuli 715\n", - " lokwa 456\n", - "\n", - "KASAÏ-OCCIDENTAL - f\n", - " ngalula 2629\n", - " kapinga 1597\n", - " ntumba 1536\n", - "\n", - "KASAÏ-OCCIDENTAL - m\n", - " ntumba 3463\n", - " ngalamulume 2735\n", - " mbuyi 2666\n", - "\n", - "KASAÏ-ORIENTAL - f\n", - " ntumba 2074\n", - " mbuyi 2023\n", - " ngoyi 1705\n", - "\n", - "KASAÏ-ORIENTAL - m\n", - " ngoyi 6194\n", - " ilunga 4742\n", - " kazadi 3876\n", - "\n", - "KATANGA - f\n", - " ilunga 5360\n", - " ngoy 3603\n", - " kasongo 2886\n", - "\n", - "KATANGA - m\n", - " ilunga 10551\n", - " ngoy 9640\n", - " kasongo 6890\n", - "\n", - "KINSHASA - f\n", - " ntumba 3245\n", - " ngalula 2831\n", - " kapinga 2663\n", - "\n", - "KINSHASA - m\n", - " ilunga 2030\n", - " nsimba 1848\n", - " matondo 1832\n", - "\n", - "MANIEMA - f\n", - " fatuma 206\n", - " feza 185\n", - " mangaza 140\n", - "\n", - "MANIEMA - m\n", - " amisi 829\n", - " ramazani 719\n", - " assani 511\n", - "\n", - "NORD-KIVU - f\n", - " kavira 16945\n", - " kavugho 10351\n", - " kahindo 10016\n", - "\n", - "NORD-KIVU - m\n", - " kambale 17137\n", - " kasereka 11889\n", - " muhindo 10482\n", - "\n", - "ORIENTALE - f\n", - " kavira 817\n", - " mave 669\n", - " sifa 568\n", - "\n", - "ORIENTALE - m\n", - " bahati 851\n", - " kambale 840\n", - " baraka 836\n", - "\n", - "SUD-KIVU - f\n", - " furaha 1920\n", - " neema 1827\n", - " nabintu 1557\n", - "\n", - "SUD-KIVU - m\n", - " mugisho 1851\n", - " bahati 1757\n", - " murhula 1678\n", - "\n" - ] - } - ], - "source": [ - "# Grouping surnames by region and sex\n", - "grouped = (\n", - " df_simple.groupby([\"province\", \"sex\", \"surname\"]).size().reset_index(name=\"count\")\n", - ")\n", - "grouped = grouped.sort_values(\n", - " [\"province\", \"sex\", \"count\"], ascending=[True, True, False]\n", - ")\n", - "top3_surnames_by_region_sex = grouped.groupby([\"province\", \"sex\"]).head(3)\n", - "\n", - "for (province, sex), group in top3_surnames_by_region_sex.groupby([\"province\", \"sex\"]):\n", - " print(f\"{province.upper()} - {sex}\")\n", - " for _, row in group.iterrows():\n", - " print(f\" {row['surname']:<15} {row['count']}\")\n", - " print()" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "id": "0c216ab9-6db0-4b15-82c0-a5f3f0dc641f", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "AUTRES → ilunga (5382 M / 1753 F) - Total: 7135\n", - "BANDUNDU → mbo (2272 M / 1207 F) - Total: 3479\n", - "BAS-CONGO → nzuzi (1782 M / 2054 F) - Total: 3836\n", - "EQUATEUR → mboyo (880 M / 796 F) - Total: 1676\n", - "KASAÏ-OCCIDENTAL → ntumba (3463 M / 1536 F) - Total: 4999\n", - "KASAÏ-ORIENTAL → ngoyi (6194 M / 1705 F) - Total: 7899\n", - "KATANGA → ilunga (10551 M / 5360 F) - Total: 15911\n", - "KINSHASA → ntumba (1496 M / 3245 F) - Total: 4741\n", - "MANIEMA → amisi (829 M / 135 F) - Total: 964\n", - "NORD-KIVU → kambale (17137 M / 41 F) - Total: 17178\n", - "ORIENTALE → bahati (851 M / 208 F) - Total: 1059\n", - "SUD-KIVU → bahati (1757 M / 596 F) - Total: 2353\n" - ] - } - ], - "source": [ - "# Find surnames common to both sexes per region - the most popular per region\n", - "\n", - "common_surnames = (\n", - " df_simple.groupby([\"province\", \"surname\", \"sex\"]).size().unstack(fill_value=0)\n", - ")\n", - "common_surnames = common_surnames[\n", - " (common_surnames.get(\"m\", 0) > 0) & (common_surnames.get(\"f\", 0) > 0)\n", - "]\n", - "common_surnames[\"total\"] = common_surnames[\"m\"] + common_surnames[\"f\"]\n", - "common_surnames = common_surnames.reset_index()\n", - "top_common_surnames = common_surnames.sort_values(\n", - " [\"province\", \"total\"], ascending=[True, False]\n", - ")\n", - "top_common_surnames = top_common_surnames.groupby(\"province\").first().reset_index()\n", - "\n", - "for _, row in top_common_surnames.iterrows():\n", - " print(\n", - " f\"{row['province'].upper()} → {row['surname']} ({row['m']} M / {row['f']} F) - Total: {row['total']}\"\n", - " )" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "id": "497dd072-b4ee-4b2a-8887-db7543969855", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Top 10 middle names for sex: f\n", - " ilunga 8881\n", - " kasongo 6670\n", - " kazadi 5320\n", - " ngoy 5118\n", - " ntumba 4987\n", - " mutombo 4785\n", - " kabeya 3752\n", - " mukendi 3704\n", - " matondo 3666\n", - " ngoyi 3588\n", - "\n", - "Top 10 middle names for sex: m\n", - " ilunga 15062\n", - " kasongo 11344\n", - " ngoy 10703\n", - " mutombo 8881\n", - " kazadi 8790\n", - " ntumba 7446\n", - " ngoyi 7445\n", - " kabeya 6425\n", - " mukendi 6333\n", - " kalala 6214\n", - "\n" - ] - } - ], - "source": [ - "# Grouping middle names by sex\n", - "middlenames_by_sex = (\n", - " df_simple.groupby([\"middle_name\", \"sex\"]).size().reset_index(name=\"count\")\n", - ")\n", - "middlenames_by_sex = middlenames_by_sex.sort_values(\n", - " [\"sex\", \"count\"], ascending=[True, False]\n", - ")\n", - "top10_middlenames_per_sex = middlenames_by_sex.groupby(\"sex\").head(10)\n", - "\n", - "for sex, group in top10_middlenames_per_sex.groupby(\"sex\"):\n", - " print(f\"Top 10 middle names for sex: {sex}\")\n", - " for _, row in group.iterrows():\n", - " print(f\" {row['middle_name']:<15} {row['count']}\")\n", - " print()" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "id": "78253678-8bcd-4c29-9412-b0b4a5d5268c", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "AUTRES\n", - " ngoy 3646\n", - " ilunga 3591\n", - " kasongo 2761\n", - "\n", - "BANDUNDU\n", - " moke 3243\n", - " mbo 1634\n", - " mpia 1444\n", - "\n", - "BAS-CONGO\n", - " ngoma 3570\n", - " nlandu 2066\n", - " khonde 1787\n", - "\n", - "EQUATEUR\n", - " mboyo 1226\n", - " lokuli 1071\n", - " nkoy 724\n", - "\n", - "KASAÏ-OCCIDENTAL\n", - " ntumba 4552\n", - " muamba 2830\n", - " ngalamulume 2329\n", - "\n", - "KASAÏ-ORIENTAL\n", - " ngoyi 8302\n", - " ilunga 6402\n", - " kazadi 5260\n", - "\n", - "KATANGA\n", - " ilunga 8185\n", - " ngoy 8108\n", - " kasongo 6136\n", - "\n", - "KINSHASA\n", - " matondo 3989\n", - " ntumba 3289\n", - " ilunga 3232\n", - "\n", - "MANIEMA\n", - " ramazani 835\n", - " amisi 625\n", - " shabani 525\n", - "\n", - "NORD-KIVU\n", - " tsongo 1678\n", - " bahati 1212\n", - " mahamba 946\n", - "\n", - "ORIENTALE\n", - " ramazani 549\n", - " bahati 476\n", - " yenga 432\n", - "\n", - "SUD-KIVU\n", - " bisimwa 1658\n", - " bahati 1633\n", - " mirindi 1049\n", - "\n" - ] - } - ], - "source": [ - "# Grouping middle names by region\n", - "middlenames_by_region = (\n", - " df_simple.groupby([\"province\", \"middle_name\"]).size().reset_index(name=\"count\")\n", - ")\n", - "middlenames_by_region = middlenames_by_region.sort_values(\n", - " [\"province\", \"count\"], ascending=[True, False]\n", - ")\n", - "top3_middlenames_per_region = middlenames_by_region.groupby(\"province\").head(3)\n", - "\n", - "for province, group in top3_middlenames_per_region.groupby(\"province\"):\n", - " print(f\"{province.upper()}\")\n", - " for _, row in group.iterrows():\n", - " print(f\" {row['middle_name']:<20} {row['count']}\")\n", - " print()" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "id": "1e8697a3-edcb-4d15-a33f-0f3b8a8adcd0", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "AUTRES - f\n", - " ilunga 1196\n", - " kasongo 917\n", - " ngoy 824\n", - "\n", - "AUTRES - m\n", - " ngoy 2822\n", - " ilunga 2395\n", - " kasongo 1844\n", - "\n", - "BANDUNDU - f\n", - " mbo 669\n", - " mpia 590\n", - " modiri 580\n", - "\n", - "BANDUNDU - m\n", - " moke 2829\n", - " mbo 965\n", - " n 894\n", - "\n", - "BAS-CONGO - f\n", - " ngoma 1574\n", - " nlandu 920\n", - " khonde 797\n", - "\n", - "BAS-CONGO - m\n", - " ngoma 1996\n", - " nlandu 1146\n", - " muanda 999\n", - "\n", - "EQUATEUR - f\n", - " mboyo 462\n", - " lokuli 362\n", - " lokwa 219\n", - "\n", - "EQUATEUR - m\n", - " mboyo 764\n", - " lokuli 709\n", - " nkoy 509\n", - "\n", - "KASAÏ-OCCIDENTAL - f\n", - " ntumba 1136\n", - " muamba 679\n", - " mulumba 597\n", - "\n", - "KASAÏ-OCCIDENTAL - m\n", - " ntumba 3416\n", - " muamba 2151\n", - " ngalamulume 1790\n", - "\n", - "KASAÏ-ORIENTAL - f\n", - " ngoyi 2488\n", - " ilunga 1817\n", - " kazadi 1522\n", - "\n", - "KASAÏ-ORIENTAL - m\n", - " ngoyi 5814\n", - " ilunga 4585\n", - " kazadi 3738\n", - "\n", - "KATANGA - f\n", - " ilunga 3504\n", - " ngoy 2664\n", - " kasongo 2578\n", - "\n", - "KATANGA - m\n", - " ngoy 5444\n", - " ilunga 4681\n", - " kasongo 3558\n", - "\n", - "KINSHASA - f\n", - " matondo 2325\n", - " ntumba 1947\n", - " ilunga 1606\n", - "\n", - "KINSHASA - m\n", - " matondo 1664\n", - " ilunga 1626\n", - " kasongo 1539\n", - "\n", - "MANIEMA - f\n", - " fatuma 162\n", - " feza 153\n", - " sifa 123\n", - "\n", - "MANIEMA - m\n", - " ramazani 713\n", - " amisi 523\n", - " shabani 421\n", - "\n", - "NORD-KIVU - f\n", - " tsongo 739\n", - " furaha 525\n", - " bahati 522\n", - "\n", - "NORD-KIVU - m\n", - " tsongo 939\n", - " bahati 690\n", - " muhindo 578\n", - "\n", - "ORIENTALE - f\n", - " mave 406\n", - " neema 320\n", - " furaha 265\n", - "\n", - "ORIENTALE - m\n", - " ramazani 409\n", - " baraka 300\n", - " kombozi 290\n", - "\n", - "SUD-KIVU - f\n", - " bisimwa 726\n", - " bahati 717\n", - " mirindi 456\n", - "\n", - "SUD-KIVU - m\n", - " bisimwa 932\n", - " bahati 916\n", - " mirindi 593\n", - "\n" - ] - } - ], - "source": [ - "# Grouping middle names by province and sex\n", - "middlenames_by_province_sex = (\n", - " df_simple.groupby([\"province\", \"sex\", \"middle_name\"])\n", - " .size()\n", - " .reset_index(name=\"count\")\n", - ")\n", - "middlenames_by_province_sex = middlenames_by_province_sex.sort_values(\n", - " [\"province\", \"sex\", \"count\"], ascending=[True, True, False]\n", - ")\n", - "top3_middlenames_by_province_sex = middlenames_by_province_sex.groupby(\n", - " [\"province\", \"sex\"]\n", - ").head(3)\n", - "\n", - "for (province, sex), group in top3_middlenames_by_province_sex.groupby(\n", - " [\"province\", \"sex\"]\n", - "):\n", - " print(f\"{province.upper()} - {sex}\")\n", - " for _, row in group.iterrows():\n", - " print(f\" {row['middle_name']:<20} {row['count']}\")\n", - " print()" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "id": "38a99578-e224-472b-95ac-e2f2510f8347", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "AUTRES\n", - " ngoy 3646\n", - " ilunga 3591\n", - " kasongo 2761\n", - "\n", - "BANDUNDU\n", - " moke 3243\n", - " mbo 1634\n", - " mpia 1444\n", - "\n", - "BAS-CONGO\n", - " ngoma 3570\n", - " nlandu 2066\n", - " khonde 1787\n", - "\n", - "EQUATEUR\n", - " mboyo 1226\n", - " lokuli 1071\n", - " nkoy 724\n", - "\n", - "KASAÏ-OCCIDENTAL\n", - " ntumba 4552\n", - " muamba 2830\n", - " ngalamulume 2329\n", - "\n", - "KASAÏ-ORIENTAL\n", - " ngoyi 8302\n", - " ilunga 6402\n", - " kazadi 5260\n", - "\n", - "KATANGA\n", - " ilunga 8185\n", - " ngoy 8108\n", - " kasongo 6136\n", - "\n", - "KINSHASA\n", - " matondo 3989\n", - " ntumba 3289\n", - " ilunga 3232\n", - "\n", - "MANIEMA\n", - " ramazani 835\n", - " amisi 625\n", - " shabani 525\n", - "\n", - "NORD-KIVU\n", - " tsongo 1678\n", - " bahati 1212\n", - " mahamba 946\n", - "\n", - "ORIENTALE\n", - " ramazani 549\n", - " bahati 476\n", - " yenga 432\n", - "\n", - "SUD-KIVU\n", - " bisimwa 1658\n", - " bahati 1633\n", - " mirindi 1049\n", - "\n" - ] - } - ], - "source": [ - "# Find middle names common to both sexes per region\n", - "common_middlenames = (\n", - " df_simple.groupby([\"province\", \"middle_name\", \"sex\"]).size().unstack(fill_value=0)\n", - ")\n", - "common_middlenames = common_middlenames[\n", - " (common_middlenames.get(\"m\", 0) > 0) & (common_middlenames.get(\"f\", 0) > 0)\n", - "]\n", - "common_middlenames[\"total\"] = common_middlenames[\"m\"] + common_middlenames[\"f\"]\n", - "common_middlenames = common_middlenames.reset_index()\n", - "common_middlenames = common_middlenames.sort_values(\n", - " [\"province\", \"total\"], ascending=[True, False]\n", - ")\n", - "top3_common_middlenames = common_middlenames.groupby(\"province\").head(3)\n", - "\n", - "for province, group in top3_common_middlenames.groupby(\"province\"):\n", - " print(f\"{province.upper()}\")\n", - " for _, row in group.iterrows():\n", - " print(f\" {row['middle_name']:<20} {row['total']}\")\n", - " print()" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "bdd0845d-c1e5-45db-97cb-6070190ba177", - "metadata": { - "ExecuteTime": { - "end_time": "2025-09-01T05:52:21.323756Z", - "start_time": "2025-08-31T19:32:48.031344Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Pie chart of surnames by sex\n", - "sex = df[\"sex\"].value_counts()\n", - "plt.figure(figsize=(7, 7))\n", - "plt.pie(sex, labels=sex.index, autopct=\"%1.1f%%\", startangle=140)\n", - "plt.axis(\"equal\")\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "3fc8b2bc8909a9e5", - "metadata": { - "ExecuteTime": { - "end_time": "2025-09-01T05:52:21.324445Z", - "start_time": "2025-08-31T19:51:35.709345Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "sex f m\n", - "year \n", - "2008 58638 105354\n", - "2009 80481 164149\n", - "2010 83388 181810\n", - "2011 102442 204793\n", - "2012 103701 209747\n", - "2013 89274 167704\n", - "2015 129413 218168\n", - "2016 142784 225395\n", - "2017 156652 244894\n", - "2018 192679 290022\n", - "2019 204459 313307\n", - "2020 961 3624\n", - "2021 190157 271851\n", - "2022 251812 352788\n", - "2023 322046 439867\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/bw/q877f1m179b8c_66m6m6x7wr0000gn/T/ipykernel_90642/1279743048.py:1: FutureWarning: The default of observed=False is deprecated and will be changed to True in a future version of pandas. Pass observed=False to retain current behavior or observed=True to adopt the future default and silence this warning.\n", - " table = df.groupby([\"year\", \"sex\"]).size().unstack(fill_value=0)\n" - ] - } - ], - "source": [ - "table = df.groupby([\"year\", \"sex\"]).size().unstack(fill_value=0)\n", - "print(table)" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "86b4e3845a2d85c2", - "metadata": { - "ExecuteTime": { - "end_time": "2025-09-01T05:52:21.324970Z", - "start_time": "2025-09-01T05:47:10.457368Z" - } - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/bw/q877f1m179b8c_66m6m6x7wr0000gn/T/ipykernel_90642/286407675.py:3: FutureWarning: The default of observed=False is deprecated and will be changed to True in a future version of pandas. Pass observed=False to retain current behavior or observed=True to adopt the future default and silence this warning.\n", - " data = df.groupby(['province', 'sex']).size().reset_index(name='count')\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.show()\n", - "# Bar chart middle name by region and sex\n", - "data = df.groupby([\"province\", \"sex\"]).size().reset_index(name=\"count\")\n", - "dataa = data.sort_values(\"count\", ascending=False).drop_duplicates([\"province\", \"sex\"])\n", - "\n", - "# Bar chart\n", - "plt.figure(figsize=(12, 6))\n", - "sns.barplot(data=dataa, x=\"province\", y=\"count\", hue=\"sex\")\n", - "plt.xlabel(\"Region\")\n", - "plt.ylabel(\"Count\")\n", - "plt.xticks(rotation=45)\n", - "plt.legend(title=\"Sex\")\n", - "plt.tight_layout()\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "id": "154b6421-a719-4574-8fcd-50bd8acd0d5c", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Pie chart of surnames by sex and region\n", - "prov_sex_counts = (\n", - " df_simple.groupby([\"province\", \"sex\"]).size().reset_index(name=\"count\")\n", - ")\n", - "provinces = prov_sex_counts[\"province\"].unique()\n", - "cols = 3\n", - "rows = (len(provinces) + cols - 1) // cols\n", - "\n", - "plt.figure(figsize=(cols * 5, rows * 5))\n", - "for i, prov in enumerate(provinces, 1):\n", - " data = prov_sex_counts[prov_sex_counts[\"province\"] == prov]\n", - " plt.subplot(rows, cols, i)\n", - " plt.pie(\n", - " data[\"count\"],\n", - " labels=data[\"sex\"],\n", - " autopct=\"%1.1f%%\",\n", - " colors=[\"lightpink\", \"skyblue\"],\n", - " )\n", - " plt.title(f\"Distribution of Surnames by Sex\\nin {prov}\")\n", - " plt.axis(\"equal\")\n", - "\n", - "plt.tight_layout()\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 36, + "execution_count": null, "id": "b8ffcff1-7457-4a97-a1b0-629121a157f5", "metadata": {}, "outputs": [ @@ -2452,7 +1282,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": null, "id": "13e9e7a6-40d4-4c72-b12c-e39a81b80617", "metadata": {}, "outputs": [ @@ -2509,69 +1339,7 @@ }, { "cell_type": "code", - "execution_count": 38, - "id": "af71df02-7694-4da4-b60d-02bf73a20b71", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Bar chart surnames by region and sex\n", - "top10_regions = df_simple[\"province\"].value_counts().head(12).index.tolist()\n", - "df_top10 = df_simple[df_simple[\"province\"].isin(top10_regions)]\n", - "plt.figure(figsize=(12, 6))\n", - "sns.countplot(data=df_top10, y=\"province\", hue=\"sex\", order=top10_regions)\n", - "plt.title(\"Surnames Distribution by Region and Sex\")\n", - "plt.xlabel(\"Number of entries\")\n", - "plt.ylabel(\"Region\")\n", - "plt.legend(title=\"Sex\")\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "id": "df7a7ce3-37c8-4ec5-9c03-6bd0f1c0a91b", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Pie chart of middle names by sex\n", - "middlenames_sex_count = middlenames_by_province_sex.groupby(\"sex\")[\"count\"].sum()\n", - "plt.figure(figsize=(6, 6))\n", - "plt.pie(\n", - " middlenames_sex_count,\n", - " labels=middlenames_sex_count.index,\n", - " autopct=\"%1.1f%%\",\n", - " colors=[\"lightpink\", \"skyblue\"],\n", - ")\n", - "plt.title(\"Distribution of Middle Names by Sex\")\n", - "plt.axis(\"equal\")\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 40, + "execution_count": null, "id": "7f713203-b498-4147-8a86-921f32dc5358", "metadata": {}, "outputs": [ @@ -2606,7 +1374,7 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": null, "id": "141b6d40-7397-4ce0-a104-cc06404c17bf", "metadata": {}, "outputs": [ @@ -2660,472 +1428,11 @@ "plt.axis(\"off\")\n", "plt.show()" ] - }, - { - "cell_type": "code", - "execution_count": 42, - "id": "a2124712-e13b-403c-96ec-e6d6f1fc15a7", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Bar chart middle name by region and sex\n", - "middlenames_by_sex_region = (\n", - " df_simple.groupby([\"province\", \"sex\", \"middle_name\"])\n", - " .size()\n", - " .reset_index(name=\"count\")\n", - ")\n", - "top_middlename_sex_region = middlenames_by_sex_region.sort_values(\n", - " \"count\", ascending=False\n", - ").drop_duplicates([\"province\", \"sex\"])\n", - "\n", - "# Bar chart\n", - "plt.figure(figsize=(12, 6))\n", - "sns.barplot(data=top_middlename_sex_region, x=\"province\", y=\"count\", hue=\"sex\")\n", - "plt.title(\"Most Common Middle Name Count by Region and Sex\")\n", - "plt.xlabel(\"Region\")\n", - "plt.ylabel(\"Count\")\n", - "plt.xticks(rotation=45)\n", - "plt.legend(title=\"Sex\")\n", - "plt.tight_layout()\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 43, - "id": "554a486f-6159-44af-a364-3dfb02dab33f", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Top 10 Firstname vs Surname Crossovers ---\n", - "first_name surname\n", - "jean ilunga 708\n", - " ngoyi 521\n", - " kasongo 514\n", - "rachel kavira 430\n", - "jean mbuyi 424\n", - "justin kambale 396\n", - "jean ntumba 393\n", - " ngoy 391\n", - "neema kavira 382\n", - "esther kavira 382\n", - "dtype: int64\n", - "\n", - "\n" - ] - } - ], - "source": [ - "# Crossover 1: Firstname vs Surname\n", - "crossover_firstname_surname = (\n", - " df_simple.groupby([\"first_name\", \"surname\"])\n", - " .size()\n", - " .sort_values(ascending=False)\n", - " .head(10)\n", - ")\n", - "print(\"--- Top 10 Firstname vs Surname Crossovers ---\")\n", - "print(crossover_firstname_surname)\n", - "print(\"\\n\")" - ] - }, - { - "cell_type": "code", - "execution_count": 44, - "id": "b850b301-6073-45f2-a015-e76d915a138f", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Top 10 Firstname vs Surname Crossovers by Sex ---\n", - "\n", - "SEX: f\n", - " rachel kavira — 428\n", - " neema kavira — 382\n", - " esther kavira — 381\n", - "\n", - "SEX: m\n", - " jean ilunga — 707\n", - " jean ngoyi — 521\n", - " jean kasongo — 513\n", - " jean mbuyi — 424\n", - " justin kambale — 396\n", - " jean ntumba — 393\n", - " jean ngoy — 388\n" - ] - } - ], - "source": [ - "# Crossover: Firstname vs Surname vs Sex\n", - "crossover_fname_sname_sex = (\n", - " df_simple.groupby([\"sex\", \"first_name\", \"surname\"]).size().reset_index(name=\"count\")\n", - ")\n", - "crossover_fname_sname_sex = crossover_fname_sname_sex.sort_values(\n", - " \"count\", ascending=False\n", - ").head(10)\n", - "\n", - "print(\"--- Top 10 Firstname vs Surname Crossovers by Sex ---\")\n", - "for sex, group in crossover_fname_sname_sex.groupby(\"sex\"):\n", - " print(f\"\\nSEX: {sex}\")\n", - " for _, row in group.iterrows():\n", - " print(f\" {row['first_name']} {row['surname']} — {row['count']}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 45, - "id": "ffb67b85-4877-450e-9585-dd0d5fe6a0f3", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# frequency of joint appearance\n", - "top_firstnames = df_simple[\"first_name\"].value_counts().head(10).index\n", - "top_surnames = df_simple[\"surname\"].value_counts().head(10).index\n", - "\n", - "filtered_df = df_simple[\n", - " df_simple[\"first_name\"].isin(top_firstnames)\n", - " & df_simple[\"surname\"].isin(top_surnames)\n", - "]\n", - "\n", - "cooccurrence = (\n", - " filtered_df.groupby([\"first_name\", \"surname\"]).size().unstack(fill_value=0)\n", - ")\n", - "\n", - "# heatmap\n", - "plt.figure(figsize=(12, 10))\n", - "sns.heatmap(cooccurrence, annot=True, fmt=\"d\", cmap=\"Blues\")\n", - "plt.title(\"Heatmap of First Name vs Surname Cooccurrence\")\n", - "plt.xlabel(\"Surname\")\n", - "plt.ylabel(\"First Name\")\n", - "plt.tight_layout()\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 46, - "id": "6b9549ca-4c4e-4e9a-b1fd-2c49d96bdd2a", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Top 10 Firstname vs Middle Name Crossovers ---\n", - "first_name middle_name\n", - "jean ilunga 493\n", - " ngoyi 474\n", - "kasongo wa 459\n", - "ilunga wa 449\n", - "jean kasongo 397\n", - "ngoy ngoy 365\n", - "jean ntumba 361\n", - "pierre jean 341\n", - "paul jean 329\n", - "ngoy wa 322\n", - "dtype: int64\n", - "\n", - "\n" - ] - } - ], - "source": [ - "# Crossover 2: Firstname vs Middle Name\n", - "crossover_firstname_middlename = (\n", - " df_simple.groupby([\"first_name\", \"middle_name\"])\n", - " .size()\n", - " .sort_values(ascending=False)\n", - " .head(10)\n", - ")\n", - "print(\"--- Top 10 Firstname vs Middle Name Crossovers ---\")\n", - "print(crossover_firstname_middlename)\n", - "print(\"\\n\")" - ] - }, - { - "cell_type": "code", - "execution_count": 47, - "id": "f3bd5598-4f9e-4c95-a725-a1fd65f363b6", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# frequency of joint appearance\n", - "top_middlenames = df_simple[\"middle_name\"].value_counts().head(10).index\n", - "\n", - "filtered_df = df_simple[\n", - " df_simple[\"first_name\"].isin(top_firstnames)\n", - " & df_simple[\"middle_name\"].isin(top_middlenames)\n", - "]\n", - "\n", - "cooccurrence = (\n", - " filtered_df.groupby([\"first_name\", \"middle_name\"]).size().unstack(fill_value=0)\n", - ")\n", - "\n", - "plt.figure(figsize=(12, 10))\n", - "sns.heatmap(cooccurrence, annot=True, fmt=\"d\", cmap=\"Greens\")\n", - "plt.title(\"Heatmap of First Name vs Middle Name Cooccurrence\")\n", - "plt.xlabel(\"Middle Name\")\n", - "plt.ylabel(\"First Name\")\n", - "plt.tight_layout()\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 48, - "id": "392da663-488c-4844-99ae-0f995d323824", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Top 10 Firstname vs Middle Name Crossovers by Sex ---\n", - "\n", - "SEX: m\n", - " jean ilunga — 491\n", - " jean ngoyi — 474\n", - " jean kasongo — 396\n", - " jean ntumba — 357\n", - " pierre jean — 337\n", - " kasongo wa — 337\n", - " paul jean — 328\n", - " jean mutombo — 321\n", - " jean kazadi — 312\n", - " ilunga wa — 295\n" - ] - } - ], - "source": [ - "# Crossover: Firstname vs Middle Name vs Sex\n", - "crossover_fname_middlename_sex = (\n", - " df_simple.groupby([\"sex\", \"first_name\", \"middle_name\"])\n", - " .size()\n", - " .reset_index(name=\"count\")\n", - ")\n", - "crossover_fname_middlename_sex = crossover_fname_middlename_sex.sort_values(\n", - " \"count\", ascending=False\n", - ").head(10)\n", - "\n", - "print(\"--- Top 10 Firstname vs Middle Name Crossovers by Sex ---\")\n", - "for sex, group in crossover_fname_middlename_sex.groupby(\"sex\"):\n", - " print(f\"\\nSEX: {sex}\")\n", - " for _, row in group.iterrows():\n", - " print(f\" {row['first_name']} {row['middle_name']} — {row['count']}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 49, - "id": "a94a4b97-e62e-443c-8557-9136f4efc991", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Top 10 Surname vs Middle Name Crossovers ---\n", - "surname middle_name\n", - "ilunga ilunga 1173\n", - " ngoy 964\n", - "ngoyi ngoyi 885\n", - "kabange numbi 830\n", - "ngoy mwilambwe 707\n", - "kazadi kazadi 663\n", - "ilunga kasongo 633\n", - "kasongo ilunga 597\n", - "ntumba ntumba 585\n", - "kasongo ngoy 575\n", - "dtype: int64\n", - "\n", - "\n" - ] - } - ], - "source": [ - "# Crossover 3: Surname vs Middle Name\n", - "print(\"--- Top 10 Surname vs Middle Name Crossovers ---\")\n", - "crossover_surname_middlename = (\n", - " df_simple.groupby([\"surname\", \"middle_name\"])\n", - " .size()\n", - " .sort_values(ascending=False)\n", - " .head(10)\n", - ")\n", - "print(crossover_surname_middlename)\n", - "print(\"\\n\")" - ] - }, - { - "cell_type": "code", - "execution_count": 50, - "id": "a9f9cec3-8285-48c4-b493-44c30f9200ad", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# frequency of joint appearance\n", - "top_surnames = df_simple[\"surname\"].value_counts().head(10).index\n", - "top_middlenames = df_simple[\"middle_name\"].value_counts().head(10).index\n", - "filtered_df = df_simple[\n", - " df_simple[\"surname\"].isin(top_surnames)\n", - " & df_simple[\"middle_name\"].isin(top_middlenames)\n", - "]\n", - "\n", - "cooccurrence = (\n", - " filtered_df.groupby([\"surname\", \"middle_name\"]).size().unstack(fill_value=0)\n", - ")\n", - "\n", - "plt.figure(figsize=(12, 10))\n", - "sns.heatmap(cooccurrence, annot=True, fmt=\"d\", cmap=\"Oranges\")\n", - "plt.title(\"Heatmap of Surname vs Middle Name Cooccurrence\")\n", - "plt.xlabel(\"Middle Name\")\n", - "plt.ylabel(\"Surname\")\n", - "plt.tight_layout()\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 51, - "id": "131a63b8-7ed7-462a-976c-9f19c8e6c03a", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Top 10 Surname vs Middle Name Crossovers by Sex ---\n", - "\n", - "SEX: m\n", - " ilunga ilunga — 1095\n", - " ngoyi ngoyi — 752\n", - " kazadi kazadi — 626\n", - " kabange numbi — 587\n", - " ilunga ngoy — 583\n", - " mutombo mutombo — 538\n", - " ngoy mwilambwe — 528\n", - " mukendi mukendi — 512\n", - " kasongo kasongo — 492\n", - " kabeya kabeya — 489\n" - ] - } - ], - "source": [ - "# Crossover: Surname vs Middle Name vs Sex\n", - "crossover_surname_middlename_sex = (\n", - " df_simple.groupby([\"sex\", \"surname\", \"middle_name\"])\n", - " .size()\n", - " .reset_index(name=\"count\")\n", - ")\n", - "crossover_surname_middlename_sex = crossover_surname_middlename_sex.sort_values(\n", - " \"count\", ascending=False\n", - ").head(10)\n", - "\n", - "print(\"--- Top 10 Surname vs Middle Name Crossovers by Sex ---\")\n", - "for sex, group in crossover_surname_middlename_sex.groupby(\"sex\"):\n", - " print(f\"\\nSEX: {sex}\")\n", - " for _, row in group.iterrows():\n", - " print(f\" {row['surname']} {row['middle_name']} — {row['count']}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 52, - "id": "7f2d51ad-5a73-409f-8c74-8b47c5adbdd0", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Calculate the length of first names, surnames, and middle names\n", - "df[\"firstname_length\"] = df_simple[\"first_name\"].str.len()\n", - "df[\"surname_length\"] = df_simple[\"surname\"].str.len()\n", - "df[\"middlename_length\"] = df_simple[\"middle_name\"].str.len()\n", - "\n", - "fig, axes = plt.subplots(1, 3, figsize=(18, 6))\n", - "\n", - "# Histogram for firstname length\n", - "sns.histplot(df[\"firstname_length\"], kde=True, ax=axes[0], color=\"skyblue\")\n", - "axes[0].set_title(\"Distribution of First Name Length\")\n", - "axes[0].set_xlabel(\"Number of Letters\")\n", - "axes[0].set_ylabel(\"Frequency\")\n", - "\n", - "# Histogram for surname length\n", - "sns.histplot(df[\"surname_length\"], kde=True, ax=axes[1], color=\"lightgreen\")\n", - "axes[1].set_title(\"Distribution of Surname Length\")\n", - "axes[1].set_xlabel(\"Number of Letters\")\n", - "axes[1].set_ylabel(\"Frequency\")\n", - "\n", - "# Histogram for middle name length\n", - "sns.histplot(df[\"middlename_length\"], kde=True, ax=axes[2], color=\"salmon\")\n", - "axes[2].set_title(\"Distribution of Middle Name Length\")\n", - "axes[2].set_xlabel(\"Number of Letters\")\n", - "axes[2].set_ylabel(\"Frequency\")\n", - "\n", - "plt.tight_layout()\n", - "plt.show()" - ] } ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": ".venv", "language": "python", "name": "python3" }, @@ -3139,7 +1446,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.3" + "version": "3.11.13" } }, "nbformat": 4, diff --git a/src/notebooks/experiments.ipynb b/src/notebooks/experiments.ipynb new file mode 100644 index 0000000..546c924 --- /dev/null +++ b/src/notebooks/experiments.ipynb @@ -0,0 +1,1231 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "95dcf546dfd256ab", + "metadata": {}, + "source": [ + "# Overview" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "80feb4d5", + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "import os\n", + "import json\n", + "import json\n", + "from pathlib import Path\n", + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "from math import sqrt" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "initial_id", + "metadata": { + "ExecuteTime": { + "end_time": "2025-10-03T09:49:28.626603Z", + "start_time": "2025-10-03T09:49:28.450965Z" + }, + "collapsed": true + }, + "outputs": [], + "source": [ + "sys.path.append(os.path.abspath(\"..\"))" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "136812ec", + "metadata": {}, + "outputs": [], + "source": [ + "p = Path(\"../../data/outputs/experiments/experiments.json\")\n", + "with p.open(\"r\", encoding=\"utf-8\") as f:\n", + " experiments = json.load(f)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "601c8bc2", + "metadata": {}, + "outputs": [], + "source": [ + "rows = []\n", + "for exp_id, exp in experiments.items():\n", + " cfg = exp.get(\"config\", {})\n", + " name = cfg.get(\"name\")\n", + " model_type = cfg.get(\"model_type\")\n", + " features = \",\".join(cfg.get(\"features\", []))\n", + " # metrics\n", + " tr = exp.get(\"train_metrics\", {}) or {}\n", + " te = exp.get(\"test_metrics\", {}) or {}\n", + " cv = exp.get(\"cv_metrics\", {}) or {}\n", + "\n", + " cm = exp.get(\"confusion_matrix\")\n", + " tn=fp=fn=tp=np.nan\n", + " if isinstance(cm, list) and len(cm)==2 and all(isinstance(r, list) and len(r)==2 for r in cm):\n", + " # By inspection of the provided metrics, mapping is:\n", + " # rows = true [f, m]; cols = pred [f, m]\n", + " tn, fp = cm[0][0], cm[0][1] # true negatives and false positives for positive class 'm'\n", + " fn, tp = cm[1][0], cm[1][1]\n", + "\n", + " # Derived metrics from confusion matrix (where present)\n", + " def safe_div(a,b): \n", + " return float(a)/float(b) if (b not in (0, None) and not pd.isna(b)) else np.nan\n", + "\n", + " sensitivity = safe_div(tp, tp+fn) # TPR for 'm'\n", + " specificity = safe_div(tn, tn+fp) # TNR for 'm'\n", + " balanced_acc = np.nanmean([sensitivity, specificity])\n", + " mcc_num = (tp*tn - fp*fn)\n", + " mcc_den = sqrt((tp+fp)*(tp+fn)*(tn+fp)*(tn+fn)) if all(x==x for x in [tp+fp, tp+fn, tn+fp, tn+fn]) else np.nan\n", + " mcc = safe_div(mcc_num, mcc_den)\n", + "\n", + " n_test = exp.get(\"test_size\") or np.nansum([tn, fp, fn, tp])\n", + " test_acc = te.get(\"accuracy\", np.nan)\n", + " # 95% CI for accuracy via normal approximation (ok for n=2000)\n", + " if pd.notna(test_acc) and pd.notna(n_test) and n_test>0:\n", + " se = np.sqrt(test_acc*(1-test_acc)/n_test)\n", + " acc_ci_lo = test_acc - 1.96*se\n", + " acc_ci_hi = test_acc + 1.96*se\n", + " else:\n", + " acc_ci_lo = acc_ci_hi = np.nan\n", + "\n", + " rows.append({\n", + " \"experiment_id\": exp_id,\n", + " \"model\": name or model_type,\n", + " \"model_family\": (model_type or \"\").upper(),\n", + " \"feature_set\": features,\n", + " \"train_accuracy\": tr.get(\"accuracy\", np.nan),\n", + " \"test_accuracy\": test_acc,\n", + " \"cv_accuracy_mean\": cv.get(\"accuracy\", np.nan),\n", + " \"cv_accuracy_std\": cv.get(\"accuracy_std\", np.nan),\n", + " \"train_f1\": tr.get(\"f1\", np.nan),\n", + " \"test_f1\": te.get(\"f1\", np.nan),\n", + " \"cv_f1_mean\": cv.get(\"f1\", np.nan),\n", + " \"cv_f1_std\": cv.get(\"f1_std\", np.nan),\n", + " \"TP\": tp, \"FP\": fp, \"TN\": tn, \"FN\": fn,\n", + " \"sensitivity_TPR_m\": sensitivity,\n", + " \"specificity_TNR_m\": specificity,\n", + " \"balanced_accuracy\": balanced_acc,\n", + " \"MCC\": mcc,\n", + " \"n_test\": n_test,\n", + " \"acc_95ci_lo\": acc_ci_lo,\n", + " \"acc_95ci_hi\": acc_ci_hi,\n", + " \"train_minus_test_gap\": (tr.get(\"accuracy\", np.nan) - test_acc) if pd.notna(tr.get(\"accuracy\", np.nan)) and pd.notna(test_acc) else np.nan,\n", + " \"test_minus_cv_gap\": (test_acc - cv.get(\"accuracy\", np.nan)) if pd.notna(test_acc) and pd.notna(cv.get(\"accuracy\", np.nan)) else np.nan,\n", + " \"start_time\": exp.get(\"start_time\"),\n", + " \"end_time\": exp.get(\"end_time\")\n", + " })\n", + "\n", + "df = pd.DataFrame(rows)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "9859c4d8", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
experiment_idmodel_familyfeature_settrain_accuracytest_accuracycv_accuracy_meancv_accuracy_stdacc_95ci_loacc_95ci_hibalanced_accuracyMCCtrain_minus_test_gaptest_minus_cv_gapn_test
0logistic_regression_20251005_180145_a42e919bLOGISTIC_REGRESSIONFull name0.9940000.81900.8052500.0069660.8021260.8358740.81900.6380050.1750000.0137502000
1logistic_regression_surname_20251005_180545_dc...LOGISTIC_REGRESSIONSurname0.9237500.83550.8361250.0083890.8192520.8517480.83550.6711480.088250-0.0006252000
2logistic_regression_native_20251005_180415_77b...LOGISTIC_REGRESSIONNative0.8547500.62600.5893750.0107600.6047940.6472060.62600.2520020.2287500.0366252000
3lightgbm_20251005_184952_5b57c798LIGHTGBMFull name0.7615000.64350.6322500.0078020.6225080.6644920.64350.2921540.1180000.0112502000
4lightgbm_surname_20251005_185153_33fe6152LIGHTGBMSurname0.8141250.78800.7881250.0055340.7700870.8059130.78800.5785620.026125-0.0001252000
5lightgbm_native_20251005_185100_e574fd07LIGHTGBMNative0.7146250.56500.5580000.0080180.5432720.5867280.56500.1300010.1496250.0070002000
6lstm_20251005_185313_d023c949LSTMFull name0.9752500.80550.807250NaN0.7881530.8228470.80550.6125460.169750-0.0017502000
7lstm_surname_20251005_185727_f525f7b1LSTMSurname0.9523750.77100.776625NaN0.7525840.7894160.77100.5814340.181375-0.0056252000
8lstm_native_20251005_185524_3790128fLSTMNative0.9041250.59350.596125NaN0.5719730.6150270.59350.2008580.310625-0.0026252000
9cnn_20251005_183522_ad291858CNNFull name0.8062500.79550.782000NaN0.7778230.8131770.79550.5925810.0107500.0135002000
10cnn_surname_20251005_183801_f39cdf79CNNSurname0.8196250.81000.788125NaN0.7928070.8271930.81000.6204480.0096250.0218752000
11cnn_native_20251005_183645_b21190b7CNNNative0.5702500.54200.538875NaN0.5201640.5638360.54200.1002640.0282500.0031252000
12bigru_20251005_182256_b8a9ba80BIGRUFull name0.9770000.81100.810000NaN0.7938410.8281590.81100.6283670.1660000.0010002000
13bigru_surname_20251005_183007_23ecad51BIGRUSurname0.9515000.79650.779500NaN0.7788550.8141450.79650.6243730.1550000.0170002000
14bigru_native_20251005_182514_8e6e7766BIGRUNative0.9130000.59950.596875NaN0.5780250.6209750.59950.2085400.3135000.0026252000
15random_forest_20251005_190017_a06fdee3RANDOM_FORESTFull name0.7163750.50050.5703750.0113920.4785870.5224130.50050.0223660.215875-0.0698752000
16random_forest_surname_20251005_190332_192524dbRANDOM_FORESTSurname0.8410000.76450.7722500.0062570.7459040.7830960.76450.5508750.076500-0.0077502000
17random_forest_native_20251005_190133_39134811RANDOM_FORESTNative0.7126250.50150.5736250.0099170.4795870.5234130.50150.0091720.211125-0.0721252000
18transformer_20251005_193241_4c4948bcTRANSFORMERFull name0.9776250.80950.801125NaN0.7922890.8267110.80950.6250680.1681250.0083752000
19transformer_surname_20251005_193642_188567deTRANSFORMERSurname0.9523750.80250.775000NaN0.7850520.8199480.80250.6352690.1498750.0275002000
20transformer_native_20251005_193435_d0d6ededTRANSFORMERNative0.8912500.60400.594125NaN0.5825660.6254340.60400.2231330.2872500.0098752000
21naive_bayes_20251005_192701_b7cc679bNAIVE_BAYESFull name0.8250000.78100.7685000.0082030.7628750.7991250.78100.5620100.0440000.0125002000
22naive_bayes_surname_20251005_192845_7e8c95f5NAIVE_BAYESSurname0.8415000.79400.7902500.0056540.7762750.8117250.79400.5881690.0475000.0037502000
23naive_bayes_native_20251005_192759_7b51fe31NAIVE_BAYESNative0.7052500.59550.5823750.0074200.5739900.6170100.59550.1917610.1097500.0131252000
24xgboost_20251005_193953_d80bd7a2XGBOOSTFull name0.8280000.73200.7116250.0055000.7125880.7514120.73200.4678480.0960000.0203752000
25xgboost_surname_20251005_194339_4839fab8XGBOOSTSurname0.8220000.80200.7933750.0050400.7845350.8194650.80200.6086980.0200000.0086252000
26xgboost_native_20251005_194241_3f486d85XGBOOSTNative0.7253750.56500.5637500.0043840.5432720.5867280.56500.1300370.1603750.0012502000
\n", + "
" + ], + "text/plain": [ + " experiment_id model_family \\\n", + "0 logistic_regression_20251005_180145_a42e919b LOGISTIC_REGRESSION \n", + "1 logistic_regression_surname_20251005_180545_dc... LOGISTIC_REGRESSION \n", + "2 logistic_regression_native_20251005_180415_77b... LOGISTIC_REGRESSION \n", + "3 lightgbm_20251005_184952_5b57c798 LIGHTGBM \n", + "4 lightgbm_surname_20251005_185153_33fe6152 LIGHTGBM \n", + "5 lightgbm_native_20251005_185100_e574fd07 LIGHTGBM \n", + "6 lstm_20251005_185313_d023c949 LSTM \n", + "7 lstm_surname_20251005_185727_f525f7b1 LSTM \n", + "8 lstm_native_20251005_185524_3790128f LSTM \n", + "9 cnn_20251005_183522_ad291858 CNN \n", + "10 cnn_surname_20251005_183801_f39cdf79 CNN \n", + "11 cnn_native_20251005_183645_b21190b7 CNN \n", + "12 bigru_20251005_182256_b8a9ba80 BIGRU \n", + "13 bigru_surname_20251005_183007_23ecad51 BIGRU \n", + "14 bigru_native_20251005_182514_8e6e7766 BIGRU \n", + "15 random_forest_20251005_190017_a06fdee3 RANDOM_FOREST \n", + "16 random_forest_surname_20251005_190332_192524db RANDOM_FOREST \n", + "17 random_forest_native_20251005_190133_39134811 RANDOM_FOREST \n", + "18 transformer_20251005_193241_4c4948bc TRANSFORMER \n", + "19 transformer_surname_20251005_193642_188567de TRANSFORMER \n", + "20 transformer_native_20251005_193435_d0d6eded TRANSFORMER \n", + "21 naive_bayes_20251005_192701_b7cc679b NAIVE_BAYES \n", + "22 naive_bayes_surname_20251005_192845_7e8c95f5 NAIVE_BAYES \n", + "23 naive_bayes_native_20251005_192759_7b51fe31 NAIVE_BAYES \n", + "24 xgboost_20251005_193953_d80bd7a2 XGBOOST \n", + "25 xgboost_surname_20251005_194339_4839fab8 XGBOOST \n", + "26 xgboost_native_20251005_194241_3f486d85 XGBOOST \n", + "\n", + " feature_set train_accuracy test_accuracy cv_accuracy_mean \\\n", + "0 Full name 0.994000 0.8190 0.805250 \n", + "1 Surname 0.923750 0.8355 0.836125 \n", + "2 Native 0.854750 0.6260 0.589375 \n", + "3 Full name 0.761500 0.6435 0.632250 \n", + "4 Surname 0.814125 0.7880 0.788125 \n", + "5 Native 0.714625 0.5650 0.558000 \n", + "6 Full name 0.975250 0.8055 0.807250 \n", + "7 Surname 0.952375 0.7710 0.776625 \n", + "8 Native 0.904125 0.5935 0.596125 \n", + "9 Full name 0.806250 0.7955 0.782000 \n", + "10 Surname 0.819625 0.8100 0.788125 \n", + "11 Native 0.570250 0.5420 0.538875 \n", + "12 Full name 0.977000 0.8110 0.810000 \n", + "13 Surname 0.951500 0.7965 0.779500 \n", + "14 Native 0.913000 0.5995 0.596875 \n", + "15 Full name 0.716375 0.5005 0.570375 \n", + "16 Surname 0.841000 0.7645 0.772250 \n", + "17 Native 0.712625 0.5015 0.573625 \n", + "18 Full name 0.977625 0.8095 0.801125 \n", + "19 Surname 0.952375 0.8025 0.775000 \n", + "20 Native 0.891250 0.6040 0.594125 \n", + "21 Full name 0.825000 0.7810 0.768500 \n", + "22 Surname 0.841500 0.7940 0.790250 \n", + "23 Native 0.705250 0.5955 0.582375 \n", + "24 Full name 0.828000 0.7320 0.711625 \n", + "25 Surname 0.822000 0.8020 0.793375 \n", + "26 Native 0.725375 0.5650 0.563750 \n", + "\n", + " cv_accuracy_std acc_95ci_lo acc_95ci_hi balanced_accuracy MCC \\\n", + "0 0.006966 0.802126 0.835874 0.8190 0.638005 \n", + "1 0.008389 0.819252 0.851748 0.8355 0.671148 \n", + "2 0.010760 0.604794 0.647206 0.6260 0.252002 \n", + "3 0.007802 0.622508 0.664492 0.6435 0.292154 \n", + "4 0.005534 0.770087 0.805913 0.7880 0.578562 \n", + "5 0.008018 0.543272 0.586728 0.5650 0.130001 \n", + "6 NaN 0.788153 0.822847 0.8055 0.612546 \n", + "7 NaN 0.752584 0.789416 0.7710 0.581434 \n", + "8 NaN 0.571973 0.615027 0.5935 0.200858 \n", + "9 NaN 0.777823 0.813177 0.7955 0.592581 \n", + "10 NaN 0.792807 0.827193 0.8100 0.620448 \n", + "11 NaN 0.520164 0.563836 0.5420 0.100264 \n", + "12 NaN 0.793841 0.828159 0.8110 0.628367 \n", + "13 NaN 0.778855 0.814145 0.7965 0.624373 \n", + "14 NaN 0.578025 0.620975 0.5995 0.208540 \n", + "15 0.011392 0.478587 0.522413 0.5005 0.022366 \n", + "16 0.006257 0.745904 0.783096 0.7645 0.550875 \n", + "17 0.009917 0.479587 0.523413 0.5015 0.009172 \n", + "18 NaN 0.792289 0.826711 0.8095 0.625068 \n", + "19 NaN 0.785052 0.819948 0.8025 0.635269 \n", + "20 NaN 0.582566 0.625434 0.6040 0.223133 \n", + "21 0.008203 0.762875 0.799125 0.7810 0.562010 \n", + "22 0.005654 0.776275 0.811725 0.7940 0.588169 \n", + "23 0.007420 0.573990 0.617010 0.5955 0.191761 \n", + "24 0.005500 0.712588 0.751412 0.7320 0.467848 \n", + "25 0.005040 0.784535 0.819465 0.8020 0.608698 \n", + "26 0.004384 0.543272 0.586728 0.5650 0.130037 \n", + "\n", + " train_minus_test_gap test_minus_cv_gap n_test \n", + "0 0.175000 0.013750 2000 \n", + "1 0.088250 -0.000625 2000 \n", + "2 0.228750 0.036625 2000 \n", + "3 0.118000 0.011250 2000 \n", + "4 0.026125 -0.000125 2000 \n", + "5 0.149625 0.007000 2000 \n", + "6 0.169750 -0.001750 2000 \n", + "7 0.181375 -0.005625 2000 \n", + "8 0.310625 -0.002625 2000 \n", + "9 0.010750 0.013500 2000 \n", + "10 0.009625 0.021875 2000 \n", + "11 0.028250 0.003125 2000 \n", + "12 0.166000 0.001000 2000 \n", + "13 0.155000 0.017000 2000 \n", + "14 0.313500 0.002625 2000 \n", + "15 0.215875 -0.069875 2000 \n", + "16 0.076500 -0.007750 2000 \n", + "17 0.211125 -0.072125 2000 \n", + "18 0.168125 0.008375 2000 \n", + "19 0.149875 0.027500 2000 \n", + "20 0.287250 0.009875 2000 \n", + "21 0.044000 0.012500 2000 \n", + "22 0.047500 0.003750 2000 \n", + "23 0.109750 0.013125 2000 \n", + "24 0.096000 0.020375 2000 \n", + "25 0.020000 0.008625 2000 \n", + "26 0.160375 0.001250 2000 " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Clean and order categorical fields\n", + "df[\"feature_set\"] = df[\"feature_set\"].replace({\"full_name\":\"Full name\",\"native_name\":\"Native\",\"surname\":\"Surname\"})\n", + "order_features = [\"Full name\",\"Surname\",\"Native\"]\n", + "df[\"feature_set\"] = pd.Categorical(df[\"feature_set\"], categories=order_features, ordered=True)\n", + "\n", + "order_family = [\"LOGISTIC_REGRESSION\",\"LIGHTGBM\",\"LSTM\",\"CNN\",\"BIGRU\", \"RANDOM_FOREST\", \"TRANSFORMER\", \"NAIVE_BAYES\", \"XGBOOST\"]\n", + "df[\"model_family\"] = pd.Categorical(df[\"model_family\"], categories=order_family, ordered=True)\n", + "\n", + "# Summary table (subset of most relevant columns)\n", + "summary_cols = [\n", + " \"experiment_id\",\"model_family\",\"feature_set\",\n", + " \"train_accuracy\",\"test_accuracy\",\"cv_accuracy_mean\",\"cv_accuracy_std\",\n", + " \"acc_95ci_lo\",\"acc_95ci_hi\",\n", + " \"balanced_accuracy\",\"MCC\",\n", + " \"train_minus_test_gap\",\"test_minus_cv_gap\",\n", + " \"n_test\"\n", + "]\n", + "summary = df[summary_cols].sort_values([\"model_family\",\"feature_set\",\"test_accuracy\"], ascending=[True, True, False]).reset_index(drop=True)\n", + "\n", + "# Display the master summary table\n", + "display(summary)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "8189c6e1", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Build a pivot for plotting\n", + "plot_df = df.dropna(subset=[\"test_accuracy\"]).copy()\n", + "# Prepare positions\n", + "families = [f for f in order_family if f in plot_df[\"model_family\"].astype(str).unique()]\n", + "features = [f for f in order_features if f in plot_df[\"feature_set\"].astype(str).unique()]\n", + "\n", + "# Bar positions\n", + "x = np.arange(len(families))\n", + "width = 0.8 / max(1,len(features)) # total width split by features\n", + "\n", + "fig1 = plt.figure(figsize=(10,6))\n", + "for i, feat in enumerate(features):\n", + " sub = plot_df[plot_df[\"feature_set\"].astype(str)==feat]\n", + " # Align to families\n", + " y = []\n", + " yerr = [[], []] # lower and upper errors for asymmetric CI\n", + " for fam in families:\n", + " row = sub[sub[\"model_family\"].astype(str)==fam]\n", + " if len(row):\n", + " val = float(row.iloc[0][\"test_accuracy\"])\n", + " lo = float(row.iloc[0][\"acc_95ci_lo\"]) if pd.notna(row.iloc[0][\"acc_95ci_lo\"]) else np.nan\n", + " hi = float(row.iloc[0][\"acc_95ci_hi\"]) if pd.notna(row.iloc[0][\"acc_95ci_hi\"]) else np.nan\n", + " else:\n", + " val, lo, hi = np.nan, np.nan, np.nan\n", + " y.append(val)\n", + " # symmetric error bars about the mean\n", + " if not np.isnan(lo) and not np.isnan(hi) and not np.isnan(val):\n", + " yerr[0].append(val - lo)\n", + " yerr[1].append(hi - val)\n", + " else:\n", + " yerr[0].append(np.nan)\n", + " yerr[1].append(np.nan)\n", + "\n", + " plt.bar(x + i*width - (len(features)-1)*width/2, y, width, label=feat, yerr=yerr, capsize=4)\n", + "\n", + "plt.xticks(x, families, rotation=0)\n", + "plt.ylabel(\"Test accuracy\")\n", + "plt.title(\"Test accuracy by model family and feature set (95% CI)\")\n", + "plt.ylim(0.45, 1.0)\n", + "plt.legend(title=\"Feature set\")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "e5200154", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig2 = plt.figure(figsize=(10,6))\n", + "for i, feat in enumerate(features):\n", + " sub = plot_df[plot_df[\"feature_set\"].astype(str)==feat]\n", + " y = []\n", + " for fam in families:\n", + " row = sub[sub[\"model_family\"].astype(str)==fam]\n", + " val = float(row.iloc[0][\"test_f1\"]) if len(row) else np.nan\n", + " y.append(val)\n", + " plt.bar(x + i*width - (len(features)-1)*width/2, y, width, label=feat)\n", + "\n", + "plt.xticks(x, families, rotation=0)\n", + "plt.ylabel(\"Test F1\")\n", + "plt.title(\"Test F1 by model family and feature set\")\n", + "plt.ylim(0.45, 1.0)\n", + "plt.legend(title=\"Feature set\")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "ee2b10c5", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig3 = plt.figure(figsize=(7,7))\n", + "for feat in features:\n", + " sub = df[df[\"feature_set\"].astype(str)==feat]\n", + " plt.scatter(sub[\"train_accuracy\"], sub[\"test_accuracy\"], label=feat)\n", + "# y=x reference\n", + "lims = [min(df[\"train_accuracy\"].min(), df[\"test_accuracy\"].min())-0.02, max(df[\"train_accuracy\"].max(), df[\"test_accuracy\"].max())+0.02]\n", + "plt.plot(lims, lims, linestyle=\"--\")\n", + "plt.xlim(lims); plt.ylim(lims)\n", + "plt.xlabel(\"Train accuracy\")\n", + "plt.ylabel(\"Test accuracy\")\n", + "plt.title(\"Overfitting analysis: Train vs Test accuracy\")\n", + "plt.legend(title=\"Feature set\", loc=\"lower right\")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "e879dbe3", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/bw/q877f1m179b8c_66m6m6x7wr0000gn/T/ipykernel_20862/2081568339.py:1: FutureWarning: The default of observed=False is deprecated and will be changed to True in a future version of pandas. Pass observed=False to retain current behavior or observed=True to adopt the future default and silence this warning.\n", + " best_rows = df.sort_values(\"test_accuracy\", ascending=False).groupby(\"feature_set\").head(1)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAeoAAAGWCAYAAAC3jcCAAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjYsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvq6yFwwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAYpdJREFUeJzt3Xd8E/X/B/DXJWnTme4JpS0UmYWyhMoqW0BFBJEhUFRQfogMRUSQqYA4ABVB+SpLVEDFgaBskCUIsncptNAFhTbdaZLP74/aQEha2rSUhLyej8c9aO4+n7vPtce98xn3OUkIIUBERERWSfagC0BEREQlY6AmIiKyYgzUREREVoyBmoiIyIoxUBMREVkxBmoiIiIrxkBNRERkxRioiYiIrBgDNRERkRWzu0B94cIFdO3aFR4eHpAkCT///HOl7v/y5cuQJAnLly+v1P3aspiYGMTExDzoYhCRhfR6PRo2bIj33nvvgZZj586dkCQJO3fuvG/HeOutt9CyZcv7tn9LPJBAHRcXh5dffhk1a9aEk5MTVCoVWrdujYULFyIvL+++Hnvo0KE4ceIE3nvvPaxatQrNmze/r8erSrGxsZAkCSqVyuzv8cKFC5AkCZIk4cMPPyz3/pOSkjB9+nQcPXq0EkprXYq/YJXl97J371707t0bAQEBUCqVCAsLw8svv4yEhIQS8xw/fhzDhg1DeHg4nJyc4ObmhqioKLz55pu4dOmSUdrY2Fi4ubkZrdPr9Vi5ciVatmwJb29vuLu745FHHsGQIUNw4MABAEBYWJjh71vaUvwlUpIkvPrqqyZlVavVmDFjBho3bgw3Nzc4OzujYcOGmDhxIpKSku75+ylWfFMtXuRyOfz9/dG3b1+cOXPGJH3x9WtucXJyMkmflpaGt956C5GRkXBzc4OTkxMiIiIwbNgw7Nmzxyjt8uXLjfanUChQrVo1xMbG4tq1ayb7jomJKbEsdevWNUp74sQJ9O3bF6GhoXByckK1atXQpUsXfPrpp0bpNBoNFi5ciCZNmkClUsHT0xMNGjTAiBEjcPbsWZOy/vPPPyblKs+1N336dEiShICAAOTm5ppsDwsLwxNPPGGy3pzvvvsOiYmJRtdLcTmdnJxK/B02bNiwTPu/2+eff/7AKjtjx47FsWPH8Ouvvz6Q45ujqOoD/v7773j22WehVCoxZMgQNGzYEBqNBnv27MGECRNw6tQpfPnll/fl2Hl5edi/fz8mT55s9gZVGUJDQ5GXlwcHB4f7sv97USgUyM3NxW+//YZ+/foZbVu9ejWcnJyQn59v0b6TkpIwY8YMhIWFISoqqsz5Nm/ebNHxrNGnn36KMWPGoGbNmhg9ejSCgoJw5swZ/O9//8OaNWuwceNGPPbYY0Z5li5dipEjR8LX1xeDBg1C3bp1odVqcfLkSaxcuRILFixAXl4e5HJ5icd97bXXsGjRIvTq1QuDBg2CQqHAuXPnsGnTJtSsWROtWrXCggULkJ2dbcizceNGfPfdd5g/fz58fX0N6+8u350uXbqEzp07IyEhAc8++yxGjBgBR0dHHD9+HF999RXWr1+P8+fPl+t39tprr6FFixYoLCzE8ePHsWTJEuzcuRMnT55EYGCgUVqlUon//e9/Jvu4+3dz8OBB9OzZE1lZWejfvz9eeeUVKJVKxMfH4+eff8by5cuxa9cutGvXzijfzJkzER4ejvz8fBw4cADLly/Hnj17cPLkSZMvA9WrV8ecOXNMyuLh4WH4ed++fejQoQNq1KiB4cOHIzAwEImJiThw4AAWLlyI0aNHG9L26dMHmzZtwoABAzB8+HAUFhbi7Nmz2LBhAx577DGTLwB3s+TaA4q+0CxevBivv/56qfsvzQcffID+/fsbnXuxgoICzJ071+SLSUV8/vnn8PX1RWxsrNH6du3aIS8vD46OjpV2rLsFBgaiV69e+PDDD/HUU0/dt+OUi6hCly5dEm5ubqJu3boiKSnJZPuFCxfEggUL7tvxr1y5IgCIDz744L4d40EaOnSocHV1FV27dhVPP/20yfbatWuLPn36WPw7OHTokAAgli1bVqb0OTk55T7GgxIfH3/P38uePXuETCYTbdu2NTm3ixcvioCAABEUFCRu3rxpWL93714hl8tFu3bthFqtNtlnXl6emDJlitBqtYZ1xX/HYikpKUKSJDF8+HCT/Hq9XqSmppot7wcffCAAiPj4eLPbAYhRo0YZPhcWForGjRsLFxcX8ddff5mkz8zMFG+//bbZfZmzY8cOAUCsW7fOaP3ixYsFAPH+++8brb/7vEty8+ZNERQUJAIDA8WZM2dMtuv1evHtt9+KgwcPGtYtW7ZMABCHDh0ySjtx4kQBQKxZs8Zoffv27UWDBg3uWZYePXoIPz8/cevWLZNtd/5dDh48KACI9957zySdVqsVN27cKLWsllx706ZNEwBEVFSUCAgIELm5uUb5QkNDRc+ePe95jkeOHBEAxNatW43WF5czKipKKJVKce3aNaPtZf0dmtOgQQPRvn17i/JWhh9++EFIkiTi4uIeWBnuVKVN3/PmzUN2dja++uorBAUFmWyPiIjAmDFjDJ+1Wi1mzZqFWrVqGZp53n77bRQUFBjlK27C2bNnDx599FE4OTmhZs2aWLlypSHN9OnTERoaCgCYMGECJElCWFgYgKImt+Kf71TcdHSnLVu2oE2bNvD09ISbmxvq1KmDt99+27C9pD7q7du3o23btnB1dYWnpyd69epl0vxXfLyLFy8iNjYWnp6e8PDwwLBhw8w2XZVk4MCB2LRpEzIyMgzrDh06hAsXLmDgwIEm6W/evIk33njD0ISoUqnQvXt3HDt2zJBm586daNGiBQBg2LBhJs2oxc1chw8fRrt27eDi4mL4vdzdRz106FA4OTmZnH+3bt3g5eVVrubVqjRr1ixIkoQVK1bAxcXFaFutWrUwb948JCcn44svvjCsnzFjBiRJwurVq+Hu7m6yTycnJ8yaNavU2nR8fDyEEGjdurXJNkmS4O/vX4Gzuu3HH3/EsWPHMHnyZLRp08Zku0qlqpQ+yrZt2wIo6gKzxJIlS5CcnIwFCxaYrYVKkoQBAwYYrtf7WZa4uDg0aNAAnp6eJtvu/LsU79/c31Aul8PHx6fU41hy7RWbOnUqUlNTsXjx4rKckomff/4Zjo6OJq0Txd5++23odDrMnTv3nvtatmwZOnbsCH9/fyiVStSvX9+kXGFhYTh16hR27dpluM8U3z/u7qN+9dVX4ebmZvb+OGDAAAQGBkKn0xnWbdq0yXAfdnd3R8+ePXHq1CmTvJ07dwYA/PLLL/c8p6pQpYH6t99+Q82aNUttervTSy+9hKlTp6Jp06aYP38+2rdvjzlz5qB///4maS9evIi+ffuiS5cu+Oijj+Dl5YXY2FjDH+GZZ57B/PnzART9AVetWoUFCxaUq/ynTp3CE088gYKCAsycORMfffQRnnrqKezdu7fUfFu3bkW3bt2QlpaG6dOnY/z48di3bx9at26Ny5cvm6Tv168fsrKyMGfOHPTr1w/Lly/HjBkzylzOZ555BpIk4aeffjKs+/bbb1G3bl00bdrUJP2lS5fw888/44knnsDHH3+MCRMm4MSJE2jfvr0haNarVw8zZ84EAIwYMQKrVq3CqlWrjP7zpqeno3v37oiKisKCBQvQoUMHs+VbuHAh/Pz8MHToUMN/oi+++AKbN2/Gp59+iuDg4DKfa1XJzc3Ftm3b0LZtW4SHh5tN89xzz0GpVGLDhg2GPNu3b0dMTAyqV69u8bGLv2CuW7euXF/Yyqu4T27w4MH37RgADNe8l5eX2e03btwwWdRqtWH7b7/9BmdnZzzzzDP3tSw6nc5sWXJycgxpQkNDcfjwYZw8ebLU4xT/DVevXg2tVluuMlpy7d2pbdu26NixI+bNm2fRGKB9+/ahYcOGJXbnhYeHY8iQIVi6dOk9v2QvXrwYoaGhePvtt/HRRx8hJCQE//d//4dFixYZ0ixYsADVq1dH3bp1DfeZyZMnm93fc889h5ycHPz+++9G64u7//r27Wv4Erxq1Sr07NkTbm5ueP/99/HOO+/g9OnTaNOmjcl92MPDA7Vq1brnvb3KVFXVPTMzUwAQvXr1KlP6o0ePCgDipZdeMlr/xhtvCABi+/bthnWhoaECgNi9e7dhXVpamlAqleL11183rCupeXPo0KEiNDTUpAzFTUfF5s+fLwCI69evl1ju4mPc2TwcFRUl/P39RXp6umHdsWPHhEwmE0OGDDE53gsvvGC0z969ewsfH58Sj3nneRQ3Hfbt21d06tRJCCGETqcTgYGBYsaMGWZ/B/n5+UKn05mch1KpFDNnzjSsK63pu3379gKAWLJkidltdzdj/fnnnwKAePfddw1dIuaa66vKvZq+i6/HMWPGlLqfRo0aCW9vbyFE0d8YgBg7dqxJuvT0dHH9+nXDUlBQYNhmrgl4yJAhAoDw8vISvXv3Fh9++KHZZt87lbfpu0mTJsLDw6PUfZZHcdP3119/La5fvy6SkpLEH3/8ISIiIoQkSUZN00IUnTcAs0u3bt0M6by8vERUVJTJ8dRqtdHvNDs727CtuJl269at4vr16yIxMVH88MMPws/PTyiVSpGYmGi0r+Lr2dzy8ssvG9Jt3rxZyOVyIZfLRXR0tHjzzTfFn3/+KTQajdH+9Hq9YZ8BAQFiwIABYtGiReLKlSsm53F307cl154Qt+8n169fF7t27RIAxMcff2zYXtam7+rVq4s+ffqUWs64uDihUCjEa6+9Zthurun77uZ3IYTo1q2bqFmzptG6kpq+i6+pHTt2CCGKfq/VqlUzKd/atWuNYkJWVpbw9PQ06T5KSUkRHh4eZruVunbtKurVq2ey/kGoshp18Tdic81/5mzcuBEAMH78eKP1xQMi7v4GVb9+fUMzFgD4+fmhTp06JiNqK6K4eeuXX36BXq8vU57k5GQcPXoUsbGx8Pb2Nqxv1KgRunTpYjjPO73yyitGn9u2bYv09HSjWsW9DBw4EDt37kRKSgq2b9+OlJQUs83eQNEAHpms6FLQ6XRIT083NOsfOXKkzMdUKpUYNmxYmdJ27doVL7/8MmbOnIlnnnkGTk5OZpvtrEVWVhaAe1+/7u7uhr9T8b93j+AGgJo1a8LPz8+w3GuE6bJly/DZZ58hPDwc69evxxtvvIF69eqhU6dOZkfcWkKtVpf5/2d5vPDCC/Dz80NwcDAef/xxZGZmYtWqVWabpp2cnLBlyxaT5c5mVbVabfZ3OnjwYKPf6cSJE03SdO7cGX5+fggJCUHfvn3h6uqKX3/91WyLR1hYmNmyjB071pCmS5cu2L9/P5566ikcO3YM8+bNQ7du3VCtWjWjv6kkSfjzzz/x7rvvwsvLC9999x1GjRqF0NBQPPfcc0bdVHez5Nq7W7t27dChQweLatXp6ekltn4Uq1mzJgYPHowvv/wSycnJJaZzdnY2/JyZmYkbN26gffv2uHTpEjIzM8tVLqDo9/rss89i48aNRgMp16xZg2rVqhm6cLZs2YKMjAwMGDDAqHVELpejZcuW2LFjh8m+vby8cOPGjXKX6X6oskCtUqkA3L7o7uXKlSuQyWSIiIgwWh8YGAhPT09cuXLFaH2NGjVM9uHl5YVbt25ZWGJTzz33HFq3bo2XXnoJAQEB6N+/P9auXVtq0C4uZ506dUy21atXz6QpDTA9l+L/JOU5lx49esDd3R1r1qzB6tWr0aJFC5PfZTG9Xo/58+ejdu3aUCqV8PX1hZ+fH44fP16u/zzVqlUr12jMDz/8EN7e3jh69Cg++eSTMvW1Xr9+HSkpKRYtd/ZVlVfxTfJe129WVpYhbfG/d95Aiv3yyy/YsmVLmR+Tk8lkGDVqFA4fPowbN27gl19+Qffu3bF9+3azXUGWUKlUZf7/WR5Tp07Fli1bsH79egwZMgSZmZmGL4Z3k8vl6Ny5s8ly51MG7u7uZn+nM2fONATTkixatAhbtmzBDz/8gB49euDGjRtQKpVm07q6upoty9394i1atMBPP/2EW7du4eDBg5g0aRKysrLQt29fnD592pBOqVRi8uTJOHPmDJKSkvDdd9+hVatWWLt2balPoVhy7Zkzffp0pKSkYMmSJaXuxxwhxD3TTJkyBVqtttS+6r1796Jz586GsTp+fn6GsSyWBGqg6L6cl5dn+GKUnZ2NjRs34tlnnzWMMbpw4QIAoGPHjkZf5vz8/LB582akpaWZ7FcIYTJG6UGpssezVCoVgoOD79mXc7ey/qJKGoxTlguspGPcfWN3dnbG7t27sWPHDvz+++/4448/sGbNGnTs2BGbN28udUBQeVTkXIoplUo888wzWLFiBS5duoTp06eXmHb27Nl455138MILL2DWrFnw9vaGTCbD2LFjy9xyABh/Wy6Lf//91/Af5MSJExgwYMA987Ro0cLkS1pZxcfHmx00WBYRERFQKBQ4fvx4iWkKCgpw7tw5w7P5xXnMXfPt27cHUPQ4XXn5+PjgqaeewlNPPYWYmBjs2rULV65cMfSDWqpu3br4999/kZiYiJCQkArt606RkZGGwTlPP/00cnNzMXz4cLRp08ai49StWxfHjh1DYWGhUb9po0aN7pn30UcfNfx9nn76abRp0wYDBw7EuXPnzNbSy8PR0REtWrRAixYt8Mgjj2DYsGFYt24dpk2bZpI2KCgI/fv3R58+fdCgQQOsXbsWy5cvN3s9WHLtmdOuXTvExMRg3rx5Jq12pfHx8SlTJaFmzZp4/vnn8eWXX+Ktt94y2R4XF4dOnTqhbt26+PjjjxESEgJHR0ds3LgR8+fPL9e95k6tWrVCWFgY1q5di4EDB+K3335DXl4ennvuOUOa4n2vWrXK5JFAwPz/w1u3bhk91vggVelz1E888QS+/PJL7N+/H9HR0aWmDQ0NhV6vx4ULF1CvXj3D+tTUVGRkZFT4pnQnLy8vs01P5gKCTCZDp06d0KlTJ3z88ceYPXs2Jk+ejB07dhhuRnefBwCcO3fOZNvZs2fh6+sLV1fXip+EGQMHDsTXX38NmUxWaq3rhx9+QIcOHfDVV18Zrc/IyDC6UCvz22VOTg6GDRuG+vXr47HHHsO8efPQu3fve47UXb16tcWT4pj7D1pWrq6u6NChA7Zv315iUFy7di0KCgoMk0i4uroaAum1a9dQrVo1i49fkubNm2PXrl1ITk6u8P+JJ598Et999x2++eYbTJo0qZJKaGru3LlYv3493nvvPYtqd0888QQOHDiA9evXm8wVUB5yuRxz5sxBhw4d8Nlnn5kNLpYqDpilNQMDgIODAxo1aoQLFy7gxo0bZq9RS669kkyfPh0xMTHl6maqW7cu4uPjy5R2ypQp+Oabb/D++++bbPvtt99QUFCAX3/91ajV0Fyzc3nvNf369cPChQuhVquxZs0ahIWFoVWrVobttWrVAlA0Et/cfdqc+Ph4NG7cuFzluF+qdNT3m2++CVdXV7z00ktITU012R4XF4eFCxcCKGq6BWAyMvvjjz8GAPTs2bPSylWrVi1kZmYafWNNTk7G+vXrjdLdvHnTJG9xk9zdj4wVCwoKQlRUFFasWGH0ZeDkyZPYvHmz4Tzvhw4dOmDWrFn47LPPSg1ScrncpLa+bt06k77P4i8UpfWnldXEiRORkJCAFStW4OOPP0ZYWBiGDh1a4u+xWOvWrc02R5ZlMTe7VXlMmTIFQgjExsaafFmIj4/Hm2++iaCgILz88suG9VOnToVOp8Pzzz9vtrm2LK0kKSkpRk2oxTQaDbZt22a2i8gSffv2RWRkJN577z3s37/fZHtWVlaJo2/Lo1atWujTpw+WL1+OlJSUcucfOXIkAgICMG7cOLOTr5Sn5SkmJgaPPvooFixYYNFEQDt27DB7vOKxJ8VdXhcuXDA7e1hGRgb2798PLy8v+Pn5lXgcS649c9q3b4+YmBi8//77ZT7f6OhonDx58p7/N4Giv+3zzz+PL774wuRvW9xSeOfvKzMzE8uWLTPZj6ura7nuM8899xwKCgqwYsUK/PHHHyZf4Lp16waVSoXZs2ejsLDQJP/169eNPmdmZiIuLq7MTyjdb1Vao65Vqxa+/fZbPPfcc6hXr57RzGT79u3DunXrDDPRNG7cGEOHDsWXX36JjIwMtG/fHgcPHsSKFSvw9NNPl/jojyX69++PiRMnonfv3njttdeQm5uLxYsX45FHHjEaTDVz5kzs3r0bPXv2RGhoKNLS0vD555+jevXqZp87LfbBBx+ge/fuiI6Oxosvvoi8vDx8+umn8PDwKLVJuqJkMhmmTJlyz3RPPPEEZs6ciWHDhuGxxx7DiRMnsHr1atSsWdMoXa1ateDp6YklS5bA3d0drq6uaNmyZYmPjJRk+/bt+PzzzzFt2jTD42LLli1DTEwM3nnnHcybN69c+6tM27ZtM3sDe/rpp9GuXTt8+OGHGD9+PBo1aoTY2FgEBQXh7NmzWLp0KfR6PTZu3Gg08KZt27b47LPPMHr0aNSuXdswM5lGo8H58+exevVqODo6lvpF6urVq3j00UfRsWNHdOrUCYGBgUhLS8N3332HY8eOYezYsZXSROfg4ICffvoJnTt3Rrt27dCvXz+0bt0aDg4OOHXqFL799lt4eXlVyrPUEyZMwNq1a7FgwQKjPk2tVotvvvnGbJ7evXvD1dUV3t7eWL9+PZ588kk0btwY/fv3R4sWLeDg4IDExESsW7cOgPlxKyWV5dlnn8Xy5cuNmoQzMzNLLMvzzz8PABg9ejRyc3PRu3dvw9913759hlpd8eDKY8eOYeDAgejevTvatm0Lb29vXLt2DStWrEBSUhIWLFhQateZJddeSaZNm1au+2evXr0wa9Ys7Nq1C127dr1n+smTJ2PVqlU4d+4cGjRoYFjftWtXODo64sknn8TLL7+M7OxsLF26FP7+/iYtD82aNcPixYvx7rvvIiIiAv7+/ujYsWOJx2zatCkiIiIwefJkFBQUGDV7A0Vdr4sXL8bgwYPRtGlT9O/fH35+fkhISMDvv/+O1q1b47PPPjOk37p1K4QQ6NWrV1l/TffXgxhqfv78eTF8+HARFhYmHB0dhbu7u2jdurX49NNPRX5+viFdYWGhmDFjhggPDxcODg4iJCRETJo0ySiNECU/ZnD3Y0GlPYKzefNm0bBhQ+Ho6Cjq1KkjvvnmG5PHs7Zt2yZ69eolgoODhaOjowgODhYDBgwQ58+fNznG3Y8wbd26VbRu3Vo4OzsLlUolnnzySXH69GmjNHc+TnGn4scgSnrMplhZZnYq6fGs119/XQQFBQlnZ2fRunVrsX//frOPVf3yyy+ifv36QqFQGJ1nabMQ3bkftVotQkNDRdOmTUVhYaFRunHjxgmZTCb2799f6jncD8W/l5KWVatWGdLu3r1b9OrVS/j6+goHBwdRo0YNMXz4cHH58uUS9//vv/+KIUOGiBo1aghHR0fh6uoqGjVqJF5//XVx8eJFo7R3/x3VarVYuHCh6Natm6hevbpwcHAQ7u7uIjo6WixdulTo9Xqzxyzv41nFbt26JaZOnSoiIyOFi4uLcHJyEg0bNhSTJk0SycnJpf0ajZQ0M1mxmJgYoVKpREZGhuG8S/sb3H0eycnJYsKECaJ+/frC2dlZKJVKUbNmTTFkyBCjRzWFKHlmMiGKHl+sVauWqFWrlmGGuNIez7rznrBp0ybxwgsviLp16wo3Nzfh6OgoIiIixOjRo41mJktNTRVz584V7du3F0FBQUKhUAgvLy/RsWNH8cMPP5S5rOW59kq6n9x5fmV5PEuIoke/XnzxxTKXs/hvefc94ddffxWNGjUSTk5OIiwsTLz//vvi66+/Nvn7pqSkiJ49ewp3d3cBwHD/uPvxrDtNnjxZABARERElnseOHTtEt27dhIeHh3BychK1atUSsbGx4p9//jFK99xzz4k2bdrc47dSdSQhytFOREREdmfVqlUYNWoUEhISzM7C9jBJSUlBeHg4vv/+e6upUdvday6JiKh8Bg0ahBo1ahjNIPawWrBgASIjI60mSAMAa9REVC55eXn3fObV29v7vr7hiMieVPlrLonItq1Zs+aeM9Dt2LHD6EUsRGQ51qiJqFySk5PNvnHoTs2aNSvTCGQiujcGaiIiIivGpm8iIrJ6+fn50Gg0FdqHo6NjhSc+ehAYqEuh1+uRlJQEd3d3q5mcnYjIFgkhkJWVheDg4BJfylKS/Px8hIe6ISXN8hfrAEXTCMfHx9tcsGagLkVSUlKlvpyAiMjeJSYmmn2taGk0Gg1S0nSIPxwKlbtlTxWrs/QIb3YFGo2GgfphUvzKuAuHq8HdjY+ck/Ua0LDVvRMRPUBaUYi/tD9X6J3nKneZxYHaljFQl6K4udvdzT4vDrIdCsnh3omIrEBFuhF1Qg+dhcOfdcKy12haAwZqIiKyCXoI6GFZpLY0nzVgoCYiIpughx6W1ostz/ngsT2XiIjIirFGTURENkEnBHQWztFlaT5rwEBNREQ2gX3UREREVkwPAZ0dBmr2URMREVkx1qiJiMgmsOmbiIjIinEwGRERkRXT/7dYmtdWsY+aiIjIirFGTURENkFXgVHfluazBgzURERkE3QCFXgpR+WWpSoxUBMRkU1gHzURERFZHdaoiYjIJughQQfL3mettzCfNWCgJiIim6AXRYuleW0VAzUREdkEXQVq1JbmswbsoyYiIrJirFETEZFNsNcaNQM1ERHZBL2QoBcWDiazMJ81YKAmIiKbYK81avZRExERWTHWqImIyCboIIPOwvqlrpLLUpUYqImIyCaICvRRC/ZRExER3V/soyYiIiKrwxo1ERHZBJ2QQScs7KPmFKJERET3lx4S9BY2BOthu5GaTd9ERGQTivuoLV3K69q1a3j++efh4+MDZ2dnREZG4p9//jFsF0Jg6tSpCAoKgrOzMzp37owLFy4Y7ePmzZsYNGgQVCoVPD098eKLLyI7O7tc5WCgJiIiusutW7fQunVrODg4YNOmTTh9+jQ++ugjeHl5GdLMmzcPn3zyCZYsWYK///4brq6u6NatG/Lz8w1pBg0ahFOnTmHLli3YsGEDdu/ejREjRpSrLGz6JiIim1CxPuryNX2///77CAkJwbJlywzrwsPDDT8LIbBgwQJMmTIFvXr1AgCsXLkSAQEB+Pnnn9G/f3+cOXMGf/zxBw4dOoTmzZsDAD799FP06NEDH374IYKDg8tUFtaoiYjIJhT1UVu+AIBarTZaCgoKzB7r119/RfPmzfHss8/C398fTZo0wdKlSw3b4+PjkZKSgs6dOxvWeXh4oGXLlti/fz8AYP/+/fD09DQEaQDo3LkzZDIZ/v777zKfNwM1ERHZBP1/M5NZshQPQgsJCYGHh4dhmTNnjtljXbp0CYsXL0bt2rXx559/YuTIkXjttdewYsUKAEBKSgoAICAgwChfQECAYVtKSgr8/f2NtisUCnh7exvSlAWbvomIyG4kJiZCpVIZPiuVSrPp9Ho9mjdvjtmzZwMAmjRpgpMnT2LJkiUYOnRolZS1GGvURERkE4r7qC1dAEClUhktJQXqoKAg1K9f32hdvXr1kJCQAAAIDAwEAKSmphqlSU1NNWwLDAxEWlqa0XatVoubN28a0pQFAzUREdkE/X9N2JYu5dG6dWucO3fOaN358+cRGhoKoGhgWWBgILZt22bYrlar8ffffyM6OhoAEB0djYyMDBw+fNiQZvv27dDr9WjZsmWZy8KmbyIisgk6IUFn4cs1yptv3LhxeOyxxzB79mz069cPBw8exJdffokvv/wSACBJEsaOHYt3330XtWvXRnh4ON555x0EBwfj6aefBlBUA3/88ccxfPhwLFmyBIWFhXj11VfRv3//Mo/4BhioiYiITLRo0QLr16/HpEmTMHPmTISHh2PBggUYNGiQIc2bb76JnJwcjBgxAhkZGWjTpg3++OMPODk5GdKsXr0ar776Kjp16gSZTIY+ffrgk08+KVdZJCHK+XCZHVGr1fDw8EDKuRCo3NlLQNarV1jrB10EolJpRSF2FK5DZmam0WCusii+Fy//tzFc3OUWHT83S4fYJscsOv6Dxho1ERHZBL2QQW/hhCd6G66TMlATEZFNKH4m2rK8thuo2Z5LRERkxVijJiIim6BH+Udv35nXVjFQExGRTbDkeeg789oqBmoiIrIJFXt7lu0GatstORERkR1gjZqIiGzCna+rtCSvrWKgJiIim2CvTd8M1EREZBMq9hy17QZq2y05ERGRHWCNmoiIbIJeSNBb+hy1hfmsAQM1ERHZBH0Fmr5t+Tlq2y05ERGRHWCNmoiIbELF3p5lu/VSBmoiIrIJOkjQWfg8tKX5rAEDNRER2QR7rVHbbsmJiIjsAGvURERkE3SwvAlbV7lFqVIM1EREZBPstembgZqIiGyCvc71bbslJyIisgOsURMRkU0QFXjNpeDjWURERPeXvTZ9M1ATEZFNsNeXctjuVwwiIiI7wBo1ERHZBF0F3p5laT5rwEBNREQ2wV6bvhmoqVJcS9binfcysHlHHnLzBGqFKbBkvg+aNVaisFBgxvsZ+HN7HuKvaKFSydCxrRNmvu2J4EDTS7CgQKBdz2ScOF2I/ZuD0Lih4wM4I3rYJOou4Kr+AvJENgDATfJATXkkfGXByBPZ2FP4q9l8jRRtECCrYficpLuEK/qzyBVqyOGAAFkN1FO0qJJzsHd6yCx+r7Qtv4+agZoq7FaGDp16paDdY05Y/40//HxkuHhJCy+Pov8YuXkCR09o8NZYD0TWd0RGph5vTL2JZ2OvY+8fQSb7m/zuLQQFynHidGFVnwo9xJwkZ0TIG8NFcgcAJOvicVS7G60Uj8NVUqGdQ2+j9Ff1F3FFdwY+0u1r9IruDK7ozqK2vAk8ZD7QCS3ykFOl50H2h4GaKuzjRWpUD1bgywW+hnVhNRwMP3uoZNiwJsA4z3veaNcjBYlXtQipfvsy/HN7HrbtysO3//PD5u3J97/wZDf8ZNWNPkcoGiNRcwGZIh1uMk8o4Wy0/br+KgJkNaCQiq7lQqHBRd1xRCnaw0cWWJRIAtzhVSXlJ0AnJOgsbMK2NJ81sN22ALIav2/OQ9PGjhg04jpCIxPRqksSvl6dVWoetVoPSQI8PG5fgqnXdRg1IR3/+9QXLs68NOn+EUKPFN1l6KCFh8zXZLtafxNZ4haqyWoZ1qXrkwEIFIhc7NNswG7NehzX7kG+YI26qhT3UVu62CrWqKnC4hMKsXRlIUaPUGHC6AAcPlaAN965BUcHCc/3czNJn58vMOW9DPR72gUq96KALITAiLE38NJgNzRrrMSVRG1VnwbZgSx9Bg5pN0MPHeRQoLGiLdwkD5N01/RxcIUKnjI/w7o8ZEMAiNedRh1FUyjgiDjdMRwu3IFoh+6QSfIqPBP7JCrwUg5hwxOe2G7JyWro9UBUQyVmTvJCVKQjXnzeHcMGuuF/q0xr1YWFAs+/fB1CAAvn+hjWL/4qC9nZAhNGm940iSqLq+SOVg7d8aiiG6rLauOU9gCyRaZRGp3QIkV/GcHyWib5BfSoq2gGX1kwPGW+iFS0Ri6ycFOkVtUpkB1ioKYKC/SXo+4jDkbr6tR2QOI14zfAFgfpxGtabPje31CbBoCde/Px9+ECeIYlwD3kCho+dg0A0KZ7MoaPuXH/T4LsgkySw0Vyh0rmjdqKKLhLnkjQnTNKk6pPhA46BMvCjdY7wgkA4HpHDdxRcoIjlMgXufe/8AQdpAottopN31Rh0S2UuBBnPEL74qVC1Kh2+/IqDtJx8Vps+iEAPt7GzYQfzfLGtIl6w+fkFB2eGpiGVUt80byJ8v6eANktAUAP4y+USfo4+EnV4Cg5Ga33lPkBOiBHqOEkuQAACkUBNCiAs+RaVUW2a3ph+fPQelHJhalCDNRUYa+OUKHjUymY90km+jzpgn/+1eDrb7Lx2QfeAIqC9MDh13H0hAY/rvSHTgekpBXdHL09ZXB0lIxGfgOAm2tRH3V4qAOqB/MypYq7oD0KX1kwnCQXaP9r3r4lUtFU3sGQJldk4ZZIQxNFjEl+V0kFP6k6zukOoz4ehQIOuKA7CldJBS8pwCQ9VT59BfqoLc1nDWy35BbYu3cvIiMj4eDggKeffvpBF+eh0TxKie+/8sO6n3PQvGMS5i7IwLyZXuj/TNFAsqQUHX7fnIdryTq06pKMmlFXDcuBfwoecOnJXmiQj5Pa/dhbuAGHtdugFuloqugAH9nt56Sv6eLgBBejZ6fv1FARDQ/JB/9qd+If7VbIIENTRQxkkl3dSqmKVWpVRZJKb5KYNm0apk+fXpmHLJfx48cjKioKmzZtgpub6WhkslyPLi7o0cXF7LbQEAVyk0LLtT9L8hCVpoGi1T3T1FZEoTaiStyukBzQQNEKDXDvfVHl01fgfdSW5rMGlRqok5NvT1CxZs0aTJ06FefO3R6ocWdwFEJAp9NBoai6Zs24uDi88sorqF69+r0TExGRVeGEJ5UgMDDQsHh4eECSJMPns2fPwt3dHZs2bUKzZs2gVCqxZ88exMbGmjRDjx07FjExMYbPer0ec+bMQXh4OJydndG4cWP88MMPZS7X5cuXIUkS0tPT8cILL0CSJCxfvrxyTpqIiKpEcR+1pYutqvKSv/XWW5g7dy7OnDmDRo0alSnPnDlzsHLlSixZsgSnTp3CuHHj8Pzzz2PXrl2GNGFhYSU2q4eEhCA5ORkqlQoLFixAcnIynnvuOZN0BQUFUKvVRgsREdGDVOXDaWfOnIkuXbqUOX1BQQFmz56NrVu3Ijo6GgBQs2ZN7NmzB1988QXat28PAKhVqxZ8fU2nAgQAuVyOwMBASJIEDw8PBAYGmk03Z84czJgxo5xnREREVUGPCrzmkn3UZde8efNypb948SJyc3NNgrtGo0GTJk0Mn7dt21bhsk2aNAnjx483fFar1QgJCanwfomIqOJEBQaTCQbqsnN1NZ4YQCaTQQjjJ9ELC29PnpGdXfTu2N9//x3VqlUzSqdUVu5EGEqlstL3ac3Sb+rQtH0Sdm8MQmjIw/es8jvv3UJOrsDH73k/6KJQBWhEAfYVbkBLh25wlh6+pzVu6JNwQXcUrRTd7/nkjL2ryMs1bPmlHA+8d93Pz89otDgAHD161PBz/fr1oVQqkZCQgIiICKOFtd2KmfdJJnp2c0FoiALpN3V4amAqaja5Cs+wK6jd7CrGvX0T6qw7ZgtL1SL2/66jUZtrcK12BROm3rznMY6f0mDoyOuo3ewqvGsmoEm7a1j0P9O+/9378hHdNRmeYUXTh65ak220/fufslG72VUE10vExOnGx72SqEWjNteMygoAY15RYfW6bMRf4XutbVm87iT8ZdUNQfqs9h8cKNyErZrvsb9wo9k8N/RJOFj4J7Zr1mKn5kccK/wLeSLbbNpiOUKNo4W7sFPzI7Zr1uJQ4Rbc1BvP4Z0ncvBv4U5s06zBTs2POK/9F3px+7pT62/iQOEmbNesxb+FO1Eobs8ToBd6HCjchEy98ZS4vrJgyCBDsv5yeX4tZEceeKDu2LEj/vnnH6xcuRIXLlzAtGnTcPLkScN2d3d3vPHGGxg3bhxWrFiBuLg4HDlyBJ9++ilWrFhhSNepUyd89tlnD+IUbFJurh4rvstG7ICim59MBjzRzQXrlvvh+J5q+HKBD3b8lYfXJqYb8mg0gK+PHBPHeCCyvkNJuzby73EN/Hzl+PozXxzeEYQ3x3hg6uwMLP76drC+nFCIZwanoX1rJQ5sCcaol9zxf2+kY8vOPADAjXQd/u+Nm5gz1Qu/fueP73/MwcYtt+dWHjMpHTPf9jKaOxwoKmvnGGcsXVH6DZqsl05okaS/hGCZ8QsyqslqIVBWw2yePJGNY9rd8JIC0MqhO5oqOkCDAhzT/lXqsY4W7oKAQDNFR7R0eBxukif+1e5EgSi6DoXQ46h2J/TQ41FFVzRURCNJfwlxuuOGfZzW/Q0vKQAtHR6HFoWI150ybLuiPwtPyc/sazWDZTWRqD9nsp6M2euo7wfe3tmtWze88847ePPNN5Gfn48XXngBQ4YMwYkTJwxpZs2aBT8/P8yZMweXLl2Cp6cnmjZtirffftuQJi4uDjdu8OUNZfXn9jwoHSU82qyoqd/LU44RQ90N22tUV2DEUHfMX3w7oIaGKPDhrKJm5JXfly34DR1g3FQZHuqAv/8pwK+bcjHyBRUA4H8rsxFWQ4G504r2Xbe2A/YfLMCnX6rRJcYZ8QlaqNwl9O1V1G3S7jEnnLtQiB5dgLXrc+CgkPB0D/OTrfTo4ozpczMwe6pXmcpL1uWGSIIEGTzvCG51FUXjXDTafGQhwySPWtyEgECEvHFRU7IEhKEujmp3Qy/0ZmcR04h85CIL9eUt4S4rulZqy6NwVX8B2SITSskZ6SIF2UKNdg4doZSc4Q4v1JI3wkXdUdQSkZBJcuQINSIVj8FVUiFQFoYb+qKXy+SKbCTp4tDS4XGz5+krq4azun+QK7LgIrmbTUP22/R93wJ1bGwsYmNjDZ9jYmJM+qKLzZgxo9TR1pIkYcyYMRgzZkyJaS5fvnzPMmVkZNwzjb3Y+3cBoho5lrg9KUWLXzblom20U4lpLKXOEvDyvP1Sjr8PF6BDW+PjdI5xxpvTipq4I8IVyMsTOHpCgxrV5Th8TIMhA9xwK0OHmR9k4I91Jc+z3DxKiWvJOlxJ1D6U/fAPu1v6NKik8o0xKEov/VcTD4cWWiTrL8NbCixxqk8HKOECFZL18VBJ3pAgw1X9RTjCyXD8DP0NuEkeUErOhny+siCc1R1CtsiESvKGu+SJdH0KnGXuuKlPgZvkCQA4oz2I2oooKCTzLVHOkisc4YQM/XW4yBmoS8KZyciuJFzVIijA9EX3Q0dex4Y/85CXL9CjizM+/9DHTG7LHTiUjx9+zcFPK/0N61Kv6+DvZ1wWfz851FkCeXl6eHnK8eVCXwwfcwN5+QID+7qiS4wzXhl/A68Mc8flRC36xqZBqwUmv+6B3k/cHrAYFCg3nC8Dte3JF7lGgbEsnCU3NFV0wAntXpzRHYSAgIfka/ZFG8UkSUIzh444qt2N7YVrIUGCA5zQRBEDB6noC60GeVDC+Atl8asvNcgHANSXt8QZ3T+4ojsDT5kfwuUNkKSLhxwKqCQfHCncjlyRjUBZKCIUjY32pZSckYeccp0r2QfeuexUfr6Ak9L0G+b7M7zx9ng9LlwqxLQ5GZg44yYWzqmcYH3qrAb9hl3H2+M90DmmfDffXt1d0Kv77ebtv/bn4+SZQnz8rjcatk7Cis99EeAnR7ueyWjdygn+vkUB2tmp6Bxz82z4HXd2TA8tZCjftVIg8nBGexBBsnAEykKhgxZxuuM4rv0LTRUdzY6sFkLgrPYQHKFEC0UXyCDHNX0cjmp3oaXD42X+suAm80QLWWfDZ40owCXdcTR36IJz2n/gIfNDY1k7/F34Bzz0PvCT3Z7OWAY59EJbrnO1N/ba9G27vetUIT7eMmRk6k3WB/rLUae2A57o5oJP3/fG0hXZSE6t+M3jzHkNevZLxbDn3fDWWE+jbQF+cqRdN34ncNp1HVTuEpydTS/RggKBsZNu4tP3vRF3WQudVqBttBMeiXBARE0HHDpye6TtzYyic/T14aVuixwkJbTQlCtPou48FJIDHlE0gUrmDS+ZPxoqHsNNkYpMkW42z02RiusiCY0UbeAp84NK5o16ihaQQY4k/SUAgCOcUfBfzblYcU3aEea7iM7rjqCGvC6cJBfcFGkIkNWAXFLAV1YNN/VpRmm1QgMHqfK7mh4mxYHa0sVW8e5lpxo3dMSZ86U/tlT8onVN+e6TJk6f06B731QMetYNM94yHdTVspkSO/cY3wC3784zDHS729yFmejSwQlNGimh0wHaO2J8YaGA7o7Pp89q4OAA1H+kbKPUybq4S97IFpnlyqODDrirP1IyfDbfsqKH+S+j0h378ZT5IltkQiNuX6vp+hQo4AA3ycMkb7o+BTkiEyGyRwzHFv89yiWgNyqLTuiQi2y4Sxz0WBoGarIrnWOcceZ8IW5lFEW1P7blYeX32Th1VoMriVps2pqL1ybeRHQLpVHf7rGTGhw7qUF2jsCNdB2OndTgzPnbkfyXTbmIanvN8PnU2aIg3am9M0a/rEJKmg4paTpcT78dTV8a4ob4K1pMnnUL5y4U4ovlWfjxt1yMHqEyKfeZ8xr8+GsO3pngCQCoE6GATAKWf5uFTVtzcT6uEM2ibg+S2/t3AVq3dDJbMyfr5yMFIUdkolDcvsZyRRay9LdQgHzohQ5Z+lvI0t+CXhRdU36yYKhFOuJ0J5Aj1FDrb+KU9gCc4GoIhJn6G9ir2YB8UfSYn4fkCwc44pT2ALL0t5Aj1Div/Rd5yIGvFPxfWQLhJqlwUrsPWfpbuKFPwkXdMVSX1YZMMh5joRM6nNP+g/ryloamdg/JF4n688jS30KqPhGeMj9D+kxxAzLI4CmZnwaZ7Bv7qO1Uw3qOiIp0xI+/5eKlwe5wdpKwbHU2Jk7XoEADVA+Wo1d3F7z+qnFNIbrr7clp/j2uwZr1uahRXY6zB4v62tRqPc7H3a6drN+Qi+vpenz3Yw6++/H2QJk784TVcMBPq/zx5rSbWPSVGtWCFPj8Qx90uasfWwiBVyfcxNxpXnB1KQq8zs4yfLHAB+PevokCjcDH73qjWtDty/qHX3Iw+XXPyvmlUZVzl3nCXfJGqv4KqstrAwBOa//GLXG72fiAdhMAoI3DU3CGG7xlgYiUP4bL+jO4ojsDGeTwlHzR1CEGcqno2tBBh1yo/6vZAo5S0cCxON0xHNZugx56uEkeiFK0MzyuJUkyRClicEZ7EAe1myGHAsGycNSSm75c6JLuBHxlwYa8QNFjZSe0e/GPdisCZWHwl25P2JSiv4JAWZihfGSevfZRS6KkZ6YIarUaHh4eSDkXYjKZxsNg09ZcTJ6VgX92BEEms92LuCR/bs/DpBm3cHBbEBSKh+/87tQrrPWDLsJ9c11/DRe0/yLaoedDOcWmRuT/N0Xq4w/lFKnFtKIQOwrXITMzEyqVaWtZaYrvxZ03vgyFq2XTPGtzCrC1xxcWHf9Be/iiD5VZ984ueOF5NyQl6+6d2Abl5uqxZL7PQx+kH3Z+smqoJo9AAXLvndgG5Ykc1JW3eKiDdGWpyj7q6dOnQ5Iko6Vu3bqG7TExMSbbX3nlFaN9JCQkoGfPnnBxcYG/vz8mTJgArbb8g3PZzmLnXh1uW98sy+PO56nJtoXK6947kY3ykPnAA5U7XwFVjgYNGmDr1q2GzwqFccgcPnw4Zs6cafjs4nL7EVKdToeePXsiMDAQ+/btQ3JyMoYMGQIHBwfMnj27XOVgoCYiIptQ1X3UCoUCgYGBJW53cXEpcfvmzZtx+vRpbN26FQEBAYiKisKsWbMwceJETJ8+HY6OJc8MeTc2fRMRkU2ojKZvtVpttBQUFJR4vAsXLiA4OBg1a9bEoEGDkJCQYLR99erV8PX1RcOGDTFp0iTk5t7untm/fz8iIyMREHB7iuNu3bpBrVbj1KlTKA/WqImIyCZURo367tcjT5s2DdOnTzdJ37JlSyxfvhx16tRBcnIyZsyYgbZt2+LkyZNwd3fHwIEDERoaiuDgYBw/fhwTJ07EuXPn8NNPPwEAUlJSjII0AMPnlJSUcpWdgZqIiOxGYmKi0ahvpdL8KPLu3bsbfm7UqBFatmyJ0NBQrF27Fi+++CJGjBhh2B4ZGYmgoCB06tQJcXFxqFWrlrldWoxN30REZBOEkCq0AIBKpTJaSgrUd/P09MQjjzyCixcvmt3esmVLADBsDwwMRGpqqlGa4s+l9Xubw0BNREQ2ofg1l5YuFZGdnY24uDgEBQWZ3X706FEAMGyPjo7GiRMnkJZ2e3KeLVu2QKVSoX79+uU6Npu+iYjIJlTlqO833ngDTz75JEJDQ5GUlIRp06ZBLpdjwIABiIuLw7fffosePXrAx8cHx48fx7hx49CuXTs0alQ0U13Xrl1Rv359DB48GPPmzUNKSgqmTJmCUaNGlbkWX4yBmoiI6C5Xr17FgAEDkJ6eDj8/P7Rp0wYHDhyAn58f8vPzsXXrVixYsAA5OTkICQlBnz59MGXKFEN+uVyODRs2YOTIkYiOjoarqyuGDh1q9Nx1WTFQExGRTbizr9mSvOXx/fffl7gtJCQEu3btuuc+QkNDsXHjxnId1xwGaiIisgn2+lIOBmoiIrIJVVmjtiYc9U1ERGTFWKMmIiKbICrQ9G3LNWoGaiIisgkCgBCW57VVDNRERGQT9JAgWThxSUUnPHmQ2EdNRERkxVijJiIim2Cvo74ZqImIyCbohQSJz1ETERFZJyEqMJjMhkeTsY+aiIjIirFGTURENoF91ERERFaMgZqIiMiK2etgMvZRExERWTHWqImIyCbY66hvBmoiIrIJRYHa0j7qSi5MFWKgJiIim2Cvg8nYR01ERGTFWKMmIiKbIGD56yptuOWbgZqIiGyDvTZ9M1ATEZFtsNMqNfuoiYiIrBhr1EREZBsq0PQNNn0TERHdX5zwhIiIyIrZ62Ay9lETERFZMdaoiYjINgjJ8r5mG65RM1ATEZFNYB81ERGRNeNz1ERERGRtWKMmIiKbYK+jvhmoiYjIdthwE7alGKiJiMgm2GuNmn3UREREVow1aiIisg12OuqbgZqIiGyE9N9iaV7bxEBNRES2wU5r1OyjJiIismKsURMRkW2w0xo1AzUREdkGvpSDiIjIetnrSznYR01ERGTFWKMmIiLbwD5qIiIiK8Y+aiIiIusliaLF0ry2in3UREREVow1aiIisg3soyYiIrJi7KMmIiKyYnZao2YfNRERkRVjjZqIiGyDndaoGaiJiMg22GmgZtM3ERGRFWONmoiIbANHfRMREVkvzkxGRERkzUQFl3KYPn06JEkyWurWrWvYnp+fj1GjRsHHxwdubm7o06cPUlNTjfaRkJCAnj17wsXFBf7+/pgwYQK0Wm25T5s1aiIiIjMaNGiArVu3Gj4rFLdD5rhx4/D7779j3bp18PDwwKuvvopnnnkGe/fuBQDodDr07NkTgYGB2LdvH5KTkzFkyBA4ODhg9uzZ5SoHAzUREZEZCoUCgYGBJuszMzPx1Vdf4dtvv0XHjh0BAMuWLUO9evVw4MABtGrVCps3b8bp06exdetWBAQEICoqCrNmzcLEiRMxffp0ODo6lr0clXZGD7H+dZpCITk86GIQlejPpIMPughEpVJn6eH1SMX2IaECfdTF5VCrjdYrlUoolUqzeS5cuIDg4GA4OTkhOjoac+bMQY0aNXD48GEUFhaic+fOhrR169ZFjRo1sH//frRq1Qr79+9HZGQkAgICDGm6deuGkSNH4tSpU2jSpEmZy84+aiIisg3Fo74tXQCEhITAw8PDsMyZM8fsoVq2bInly5fjjz/+wOLFixEfH4+2bdsiKysLKSkpcHR0hKenp1GegIAApKSkAABSUlKMgnTx9uJt5cEaNRER2Y3ExESoVCrD55Jq0927dzf83KhRI7Rs2RKhoaFYu3YtnJ2d73s578QaNRER2YZKGPWtUqmMlpIC9d08PT3xyCOP4OLFiwgMDIRGo0FGRoZRmtTUVEOfdmBgoMko8OLP5vq9S8NATUREtqEKH8+6W3Z2NuLi4hAUFIRmzZrBwcEB27ZtM2w/d+4cEhISEB0dDQCIjo7GiRMnkJaWZkizZcsWqFQq1K9fv1zHZtM3ERHZhKqc8OSNN97Ak08+idDQUCQlJWHatGmQy+UYMGAAPDw88OKLL2L8+PHw9vaGSqXC6NGjER0djVatWgEAunbtivr162Pw4MGYN28eUlJSMGXKFIwaNarMtfhiDNRERER3uXr1KgYMGID09HT4+fmhTZs2OHDgAPz8/AAA8+fPh0wmQ58+fVBQUIBu3brh888/N+SXy+XYsGEDRo4ciejoaLi6umLo0KGYOXNmucvCQE1ERLahCt+e9f3335e63cnJCYsWLcKiRYtKTBMaGoqNGzeW78BmMFATEZFtsNPXXDJQExGRTeBLOYiIiMjqsEZNRES2ge+jJiIismLsoyYiIrJe7KMmIiIiq8MaNRER2QY2fRMREVmxCjR9M1ATERHdb3Zao2YfNRERkRVjjZqIiGyDndaoGaiJiMgm8PEsIiIisjoM1ERERFaMTd9ERGQb2EdNRERkvey1j5qBmoiIbIcNB1xLsY+aiIjIirFGTUREtoF91ERERNaLfdRERETWzE5r1OyjJiIismKsURMRkU1g0zcREZE1s9OmbwZqIiKyDXYaqNlHTUREZMVYoyYiIpvAPmoiIiJrZqdN3wzURERkG+w0ULOPmoiIyIqxRk1ERDaBfdRERETWzE6bvhmoiYjIJthrjZp91ERERFaMNWoiIrINbPomIiKyYgzURERE1kv6b7E0r61iHzUREZEVY42aiIhsA5u+iYiIrJe9Pp7FQE1ERLbBTmvU7KMmIiKyYqxRExGR7bDhmrGlGKiJiMgmsI+aiIjImrGPmoiIiKwNa9RERGQT2PRNRERkzey06ZuBmoiIbIK91qjZR01ERGTFWKMmIiLbwKZvIiIiK8ZATUREZL3YR01ERERWhzVqIiKyDXba9M0aNRER2QRJiAotlpo7dy4kScLYsWMN62JiYiBJktHyyiuvGOVLSEhAz5494eLiAn9/f0yYMAFarbbcx2eNmoiIbMMDqFEfOnQIX3zxBRo1amSybfjw4Zg5c6bhs4uLi+FnnU6Hnj17IjAwEPv27UNycjKGDBkCBwcHzJ49u1xlYI2aiIjIjOzsbAwaNAhLly6Fl5eXyXYXFxcEBgYaFpVKZdi2efNmnD59Gt988w2ioqLQvXt3zJo1C4sWLYJGoylXORioiYjIJhSP+rZ0AQC1Wm20FBQUlHi8UaNGoWfPnujcubPZ7atXr4avry8aNmyISZMmITc317Bt//79iIyMREBAgGFdt27doFarcerUqXKdN5u+iYjINlRC03dISIjR6mnTpmH69Okmyb///nscOXIEhw4dMru7gQMHIjQ0FMHBwTh+/DgmTpyIc+fO4aeffgIApKSkGAVpAIbPKSkp5So6AzUREdmEyniOOjEx0aiJWqlUmqRNTEzEmDFjsGXLFjg5OZnd34gRIww/R0ZGIigoCJ06dUJcXBxq1aplWSFLwKZvIiKyGyqVymgxF6gPHz6MtLQ0NG3aFAqFAgqFArt27cInn3wChUIBnU5nkqdly5YAgIsXLwIAAgMDkZqaapSm+HNgYGC5ysxATUREtkFUcCmjTp064cSJEzh69Khhad68OQYNGoSjR49CLpeb5Dl69CgAICgoCAAQHR2NEydOIC0tzZBmy5YtUKlUqF+/frlOm03fVGFXRRyu4hLykAMAcIMK4agHXykIeSIHe7HJbL5ItEKAVB1ZIgOXcQ4ZuIFCFMAJrqiOmqgh1a7K0yA7cC1Zi7fevYE/duQiN08gIswBX833R/MoJxQWCrzzfjo2bcvFpSuF8FDJ0KmtC+ZM9kFw4O1b5fk4Dd6clY59B/OgKRRoVE+JGRO90aG1SylHpspQVVOIuru7o2HDhkbrXF1d4ePjg4YNGyIuLg7ffvstevToAR8fHxw/fhzjxo1Du3btDI9xde3aFfXr18fgwYMxb948pKSkYMqUKRg1apTZWnxpGKipwpRwRgQawgVuEACScQXHsA8tRWe4QoW2eMIo/TVcwhWchw+Kmn/UuAVHKNEQj0IJZ2QiHWdwBJKQECJFPIAzoofRrQwd2j51FTGtnfH76mD4+chx4VIhvDyLake5eXocOVGAyeO80Li+Ercy9Rj3znU8PTQZB/+8PQDpqSHJiAh3wNYfqsHZScLCpZl4anAyLhwIRaA/b6n3lZXMTObo6IitW7diwYIFyMnJQUhICPr06YMpU6YY0sjlcmzYsAEjR45EdHQ0XF1dMXToUKPnrsuKVxVVmJ8UbPQ5Ag1xVcQhEzfhJnlACePBGGkiCQGoDoVUdPlVk8KNtrvADZniJtJwDSFgoKbKMW/RLYQEK/D1gtsjccNrOBh+9lDJsXlNNaM8n8z2Q6vuV5FwtRA1qjvgRroOFy4VYulH/mhUv6hWNGeyDxYvz8TJsxoG6ofYzp07DT+HhIRg165d98wTGhqKjRs3VvjY7KOmSiWEQIpIhA46eMDHZLta3EI2MhCMsFL3o0UhHOB4n0pJ9ui3P3PQrLES/YYnI7BhPJp1ScDSbzJLzZOp1kOSAE+Polq3j7cMdWo5YNW6LOTk6qHVCny5KhP+vnI0a1S+5kyyTEWeobZV/PpHlSJbZOIQtkMPPeRQoDGi4SapTNIlIR6ucIen5FvivjLEDaQiEVFofT+LTHbmUoIWS1aqMW6EJya95o1DR/Mx9p0bcHSUMLSf6bWan6/HpHfT0f9pN6jci+o0kiRh89pqeGZYMjwiLkEmA/x95dj4bbChCZ3uIyGKFkvz2igGaqoULnBHS3SBFoVIw1WcwiE0EzFGwVondEhBIsJRr8T9ZItMHMM+hKM+fKTyPcJAVBq9XqB5Yye893ZRS0+TSCVOndPgy5WZJoG6sFDguZdTIATw+fv+hvVCCLz69nX4+cqx6+eiPuqvvlWj19Ak/L0pBEEBvKXeT3wfNVEFyCQZXCQ3qCQvREiRcIcnEnHBKE0arkIHLYIQanYf2UKNI9iNaqiJmlLJwZzIEkH+CtR7xLg7pW5tRyRcM36bUWGhwHMjUpBwVYs/1wQbatMAsH1PHn7fkoPvlgSi9aPOaNrICYvm+sPZSYaVa7Oq5DzI/vDrH90XAgJ66I3WXUM8/BAMR8m0Ly9bZOIIdiMIoYiQGppsJ6qoxx51wvmLxi9DuBCnQWj12wPKioP0xfhCbPuhGny8jZuzc/OKqmWyu6o4MllRjZ3uMysZ9V3VWKOmCrsoTuCWuI48kYNskVn0GdcRiBqGNLkiGxm4gWCEm+TPFpk4jN3wRgBq4BEUiHwUiHxoRMmT5ROV19gRnjhwJB9zFt7ExXgNvv0pC0u/UWNkrAeAoiD97PAUHD5egFWLAqDTC6SkaZGSpoVGU3SXj27mBC8PGWJfS8WxUwVFz1TPvIH4hEL06Oz6IE/PLkj6ii22ijVqqjANCnAKh1CAfCjgAHd4oAnawke6/RhMEuKhhDN8EGCSPxVXUYgCpCABKUgwrHeCC9qgR5WcAz38WkQ54cevgzB5djpmzb+F8BAFPp7pi0F93AEA11K0+O3Pokl7mnZONMq77cdgxDzmAl+fooFjU+amo/Oz11BYKNCgjiPWLwtC4wYc9X3f2WmNusyBWpKkUreX9AYSevjVl5rfM02EFIkIRJrdVktqgFpoUNnFIjLxRBdXPNHFfM03LMQBuuR7P7ffPMoJf3xf7Z7piCpLmQN1cnKy4ec1a9Zg6tSpOHfunGGdm5ub4WchBHQ6HRQKVtiJiKhycNT3PQQGBhoWDw8PSJJk+Hz27Fm4u7tj06ZNaNasGZRKJfbs2YPY2Fg8/fTTRvsZO3YsYmJiDJ/1ej3mzJmD8PBwODs7o3Hjxvjhhx/KdRI7d+6EJEn4888/0aRJEzg7O6Njx45IS0vDpk2bUK9ePahUKgwcONDoxd5ERGRDip+jtnSxUZVa5X3rrbfw4YcfombNmvDy8ipTnjlz5uCbb77BkiVLULt2bezevRvPP/88/Pz80L59ewBAWFgYYmNj79m0Pn36dHz22WdwcXFBv3790K9fPyiVSnz77bfIzs5G79698emnn2LixIlm8xcUFKCg4PYAJrVaXbYTJyKi+85ea9SVGqhnzpyJLl26lDl9QUEBZs+eja1btyI6OhoAULNmTezZswdffPGFIVDXqlULvr4lz2RV7N1330Xr1kWzWb344ouYNGkS4uLiULNmTQBA3759sWPHjhID9Zw5czBjxowyl5+IiOh+q9RA3bz5vQcV3enixYvIzc01Ce4ajQZNmjQxfN62bVuZ9lf8ejEACAgIgIuLiyFIF687ePBgifknTZqE8ePHGz6r1WqEhISUmJ6IiKoQR31XnKur8WhKmUwGcVe/QGFhoeHn7OxsAMDvv/+OatWMR1GW932dAODgcHviAkmSjD4Xr9PrS36YTqlUWnRcW6URBdiPzXgUHeEsPXzPgN4QKbiIE2iJzvd8aoGsV/pNHRq0S8CBTdURFuJw7ww2ZtJ7N5CTK/DJe34PuihWz16bvu/rhCd+fn5Go8UB4OjRo4af69evD6VSiYSEBERERBgtrMnef5dxFn4INgTpc+Io/hZbsU38hANii9k86SIFB8V27BA/Y5f4FcfEfuSJnHse64ZIxkGxDdvFT9gpfsExsc9oe77Ixb9iD7aL9dglfsMFcRx6cftLlVrcwgGxFTvEehwVe1Eobs8wpRd6/C22IlPcNNqnrxQIGWRGz2aT7Zm98Cae6uaKsBAHpN/UofuAJFSPiodz6EWENruM0W9fhzrr9rWSnKrFoP9LQd3WV6AIvohx71wv1/HSb+pQo2k85EEXkZGpM9q2c18umndJhHPoRTwSfQXL1xiPY1n9YxZCm12GT91LeH2a8XEvJxaibusrRmUFgNdf8cLKtWpculIIugc7HUx2XwN1x44d8c8//2DlypW4cOECpk2bhpMnTxq2u7u744033sC4ceOwYsUKxMXF4ciRI/j000+xYsUKQ7pOnTrhs88+u59FtTs6ocU1xKPaXa+bDEYYAlDdbJ48kYNj2Adv+KElOqMJ2qIQBTiO/aUeK1VcxUkcRDDC0BJd0BwdEIjbX8SEEPgXeyCgRwt0QAM0RxIu4xJOGdKcwWF4ww+PojO0KEQ8zhi2JeA8POELD8nb5NhBCEUiLpblV0JWKDdXj6+/y8ILA4temiGTAU897oqflwfh7J5QfL3AH9t252LkxDRDngKNgJ+3HG+P8ULjBuV/VepL49MQWc+0ZS0+oRBPPp+MmNbOOLKlBsYM98CI19Pw546iL6o30nUY8UYa5k31wR/fB2P1j9nYsOX2l9hRb13H7Ld9jOYOBwBfHzm6xrhgyYrSX7lJ9uu+Bupu3brhnXfewZtvvokWLVogKysLQ4YMMUoza9YsvPPOO5gzZw7q1auHxx9/HL///jvCw29PNRkXF4cbN27cz6LanRtIgQxyeEi33xldR4pCiBQBZ5hvBlfjFgQEaqGh4QUcoXgEWcgwqv3eSS/0OI9jqI1GqC7VgqvkDjdJhQDpdqBORwpyoEYDPAp3yRO+UhBqoQESEWfYbw6yUA3hcJXcEYgQ5KDoBQi5IhtJuFzihCl+CIYat5Arsi36PdGDtXF7LpSOElo1cwIAeHnKMXKoB5pHOSE0xAGd2rpgZKwH9vydb8gTFuKABe/6YUg/FTzcy3eLW7wiE5lqHV4f6Wmy7YuVmQiv4YAPp/ui3iOOGPWCJ/o84YYFXxYF2EsJhfBwl+G5Xu5oEeWEmNbOOHuhqOXnu/VZcHCQ8ExPN5P9AkUTsaz5hdfovVj6Lmpbfye1RX3UsbGxiI2NNXyOiYkx6YsuNmPGjFJHUkuShDFjxmDMmDElprl8+XKp5TF3/LvLCBQ9vsXZ04pk4AZU8CxXHhW8AEhIwmUEizDooEUyEuANf8gk8zfELGSgAHmQIOGA2AoN8uEOD9RGI7hJRXMsZ+Im3OABpeRkyOeDQJzFv8hGJlTwgjs8kI40OAs33EQa3FGU9yyOIAKRUEjm+y6dJBc4CiUycAMuMH+TJOu150AemjYqedxIUooW6zdmo10rpxLTlNXpcxq8+/FN7P+9Oi4lmDZDH/gnH53aOhut6xrjgvFTiyoRtcMdkJunx78nChBaXYF/juZjWH933MrQYdq8m9j2Q3CJx360iROuJmlxObHwoeyHrzR2OpiML+WwU/nIhRLO9054B2fJFU3RFnE4ie34CTvxCwqQi0i0KjFPHoqa/i7hNMJRF1FoDQUccRi7DP3MGuTDEcY3WkcoDdsAoB6aIQ1XsQ9/QIIMYaiLZHEFciiggjeOiL+wV2zCRXESd1PCGfngRDe26MpVLYID5SbrB45MgVt4HEKaXIa7uwxLP/I3k7vsCgoEBv1fCt5/xxc1qpsPlCnXdQjwMy5LgJ8c6iw98vL08PKUY9nCAMS+lopWPa5i8LPu6NbBFRNm3sCoYR6IT9CiWZcENIpJwA8bjGvPwYFFdaYricav3CRjrFGTXdFBByVMb4ClKRD5OIPDCEIoAhACHbSIwymcwAE0EW1LGFld9L8jDHURIBX1fTcQzfEXfkcqrqI6aprJY8pN8kBzxBg+a0QBLuE0mqE9zuFfeMIHjRGNg9gGD+ENP+l27UUGOXTgDdAW5eXr4aQ0vU19PMMXU8d74/ylQkyenY7Xp9/AormWB+u3Z99A3dqOeL6ve0WKi9493NC7x+2Wm1378nDitAafvOuHRx67gtWfByLQX45WPa6iXSsn+PsWnZuzU9H/ndw8G37FE903rFHbKUc4ohCaeye8w1VchAIOqC01gkrygpfkh4Z4FDeRBjVums1TXFN2g8qwTibJ4QxXQy3XEU6GmnMxDQqM8t/tAo4jBBFwklxwC9fhj+qQSwr4Igi3YDzathAaQw2dbIuvtxy37hp5DQCB/grUre2Ip7q5YvE8PyxZoUZyquVfxnbszcMPv2XDsfpFOFa/iC7PJgEA/BvEY/oH6UXH9JMj9bpxWVKv66Byl8HZ2fRWWlAg8Oqk61g8zw8XLxdCqwXaP+aMOhGOeKSmA/4+cnsWxJsZRfv18ynfl2e7oxcVW2wUa9R2yh2eSC7nY0s6mN4wJRTVBEQJHUAqeEEGGXKQBU8UzS6nF3rkIxdOcAEAeMAb8TgDjciH43/91OlIhRwKowBf7KZIRQ7UqI/mhmMLFNVE9DCukeiEDnnIhns5++PJOjSJVGL1j1mlpimeGqFAY/mNeN3/gpCXf/vaOXS0AC+NS8Oun6uhVlhRU3ir5k7YtM24C2Xr7lzDQLe7vbfgJrp1cEHTRk7490QBtLrb5SvUCuju+HzyrAYODkCDOuUfpW5X7LSPmoHaTvkgEBdxEoVCAwep6OaQK7KhgxYaFEAPHbJEBgDAFSrIJBl8EYQEXMAlcRqBCIEWWsThJJzgAncUze2eKW7iFA6hKdrBSXKGQnJANVETl3AaTsIZTnDFFRS9da34MTAfBMIVKpzEIdQWkdAgH3E4hRDUgkwyrmHohA5ncRSRaGloaveEL64iDtVFLaThGh5BY0P6TKQXjW6HD8j2dI1xwduz03ErQwcvTzk2bstB6nUdWkQp4eYqw6lzGkyceQOtWzgZDcI6erKotpqdI3A9XYejJwvg6CCh/n+BcP3GbEyenY7Te0IBwBCMi924WfSltF5tR3h6FF2DLw/xwKKvMzFx1g0M66/Cjr15WPdrNn5bFWRS7tPnNFj7azYObyl6uqFuhANkEvDVt2oE+stx9mIhWkTdDvB7/s5D25bOZmvmdJuECkx4UqklqVoM1HbKTfKAu/A06ic+jX+QgduPwf2NrQCA1ugOZ7jCW/JHQ9ESV3AOV3AOMijgAW80QRvI/wuoOmiRiyxDDRcAaqMRJEg4hUPQQQcPeKMp2hm+IEiShCjRGmfxLw5hB+SQIwihqGnmkat4nIYvAuEueRrW1UEUTuJv/IOdCEIN+OP2LHepSEQgakAu8VK3RZH1lGgaqcTaX7Px8hAPODtJ+Gq1Gq9P06BAIxASrEDvHq6Y+KrxS4CadUk0/Hz4eAG+W5+N0OoKXDoUBgDIzNLjXFz5JhgJr+GA374JwuvTbuCT/2WgepACX37kj24djB9nFELglQlp+HC6L1xdigKvs7MMXy8MwOhJ11GgEfjkPV9UC7p9Ta75ORtT3zCdB4AIACRR0nNVBLVaDQ8PD8SgV4mP/9iyGyIZF3AcrdD1oZxis2iK1D/xKDo9lFOk3unPpKMPugj3ze9bczBx5g0c31kDMtnDd51u2paDCTNu4Oj2GlAoHr7zK6bO0sPrkUvIzMyESmXapVVq3v/uxa07TYdCYdmjeFptPvZum27R8R80VjPsmK8UhFyRjQLkGfqLHyb5yEEdNHnog/TDrmdnV1y8VIhryVqEVHv4vjDn5Al8tSDgoQ7SlcVe5/pmoLZzNaTaD7oI941K8oYKbE58GIwZ4fmgi3Df9H2CE/FQ6RioiYjINnDUNxERkfWShIBk4bAqS/NZAwZqIiKyDfr/Fkvz2ig+tEdERGTFWKMmIiKbwKZvIiIia8bBZERERFZMiKLF0rw2in3UREREVow1aiIisgmcmYyIiMia2WnTNwM1ERHZBElftFia11axj5qIiMiKsUZNRES2gU3fREREVozPURMREVkve52ZjH3UREREVow1aiIisg3soyYiIrJiApa/rtJ24zQDNRER2Qb2URMREZHVYY2aiIhsg0AF+qgrtSRVioGaiIhsAweTERERWTE9AKkCeW0U+6iJiIisGGvURERkE+x11DcDNRER2Qb2URMREVkxOw3U7KMmIiKyYqxRExGRbWCNmoiIyIrpK7hYaO7cuZAkCWPHjjWsy8/Px6hRo+Dj4wM3Nzf06dMHqampRvkSEhLQs2dPuLi4wN/fHxMmTIBWqy338RmoiYjIJhSP+rZ0scShQ4fwxRdfoFGjRkbrx40bh99++w3r1q3Drl27kJSUhGeeecawXafToWfPntBoNNi3bx9WrFiB5cuXY+rUqeUuAwM1ERGRGdnZ2Rg0aBCWLl0KLy8vw/rMzEx89dVX+Pjjj9GxY0c0a9YMy5Ytw759+3DgwAEAwObNm3H69Gl88803iIqKQvfu3TFr1iwsWrQIGo2mXOVgoCYiIttQ3Edt6QJArVYbLQUFBSUebtSoUejZsyc6d+5stP7w4cMoLCw0Wl+3bl3UqFED+/fvBwDs378fkZGRCAgIMKTp1q0b1Go1Tp06Va7TZqAmIiLboBcVWwCEhITAw8PDsMyZM8fsob7//nscOXLE7PaUlBQ4OjrC09PTaH1AQABSUlIMae4M0sXbi7eVB0d9ExGRbaiEUd+JiYlQqVSG1Uql0iRpYmIixowZgy1btsDJycmy41Ui1qiJiMhuqFQqo8VcoD58+DDS0tLQtGlTKBQKKBQK7Nq1C5988gkUCgUCAgKg0WiQkZFhlC81NRWBgYEAgMDAQJNR4MWfi9OUFQM1ERHZiIr0T5e9Jt6pUyecOHECR48eNSzNmzfHoEGDDD87ODhg27Zthjznzp1DQkICoqOjAQDR0dE4ceIE0tLSDGm2bNkClUqF+vXrl+us2fRNRES2oYomPHF3d0fDhg2N1rm6usLHx8ew/sUXX8T48ePh7e0NlUqF0aNHIzo6Gq1atQIAdO3aFfXr18fgwYMxb948pKSkYMqUKRg1apTZWnxpGKiJiMg26MtXMzbNW3nmz58PmUyGPn36oKCgAN26dcPnn39u2C6Xy7FhwwaMHDkS0dHRcHV1xdChQzFz5sxyH4uBmoiI6B527txp9NnJyQmLFi3CokWLSswTGhqKjRs3VvjYDNRERGQbhL5osTSvjWKgJiIi22CnL+VgoCYiIttgRX3UVYmPZxEREVkx1qiJiMg2sOmbiIjIiglUIFBXakmqFAM1ERHZBjutUbOPmoiIyIqxRk1ERLZBrwdg4fPQej5HTUREdH/ZadM3AzUREdkGOw3U7KMmIiKyYqxRExGRbbDTmckYqImIyCYIoYew8OUaluazBgzURERkG4SwvGbMPmoiIiK6H1ijJiIi2yAq0EdtwzVqBmoiIrINej0gWdjXzD5qIiKi+8xOa9TsoyYiIrJirFETEZFNEHo9hIVN33w8i4iI6H6z06ZvBmoiIrINegFI9heo2UdNRERkxVijJiIi2yAELH4ftQ3XqBmoiYjIJgi9gLCw6VswUBMREd1nQg/La9S2O+qbfdRERERWjDXqUhQ3lWhRaPETAURVQZ1lu7UFsg/q7KJrtCJN0Gz6JhNZWVkAgD3Y+IBLQlQ6r0cedAmIyiYrKwseHh4W5dWKAoubsLUotCifNZCELX/NuM/0ej2SkpLg7u4OSZIedHEeCmq1GiEhIUhMTIRKpXrQxSEyi9dp5RNCICsrC8HBwZDJytfrmp+fj/DwcKSkpFSoDIGBgYiPj4eTk1OF9lPVGKipSqnVanh4eCAzM5M3QLJavE6tT35+PjQaTYX24ejoaHNBGmDTNxER2QAnJyebDLKVgaO+iYiIrBgDNVUppVKJadOmQalUPuiiEJWI1ylZE/ZRExERWTHWqImIiKwYAzUREZEVY6AmIiKyYgzUZBViY2Px9NNPlyuPEAIjRoyAt7c3JEnC0aNH70vZyH5Zcl0SVTYGaipRbGwsJEmCJElwdHREREQEZs6cCa1W+6CLBgD4448/sHz5cmzYsAHJyclo2LDhgy4SVQFrvy6JKhsnPKFSPf7441i2bBkKCgqwceNGjBo1Cg4ODpg0aZJJWo1GA0dHxyorW1xcHIKCgvDYY49V2THJOljzdUlU2VijplIplUoEBgYiNDQUI0eOROfOnfHrr78CuN0s+N577yE4OBh16tQBACQmJqJfv37w9PSEt7c3evXqhcuXLxv2qdPpMH78eHh6esLHxwdvvvlmud9sExsbi9GjRyMhIQGSJCEsLKyyTplsgLVelwAQExOD0aNHY+zYsfDy8kJAQACWLl2KnJwcDBs2DO7u7oiIiMCmTZsq5XdBDz8GaioXZ2dno/l2t23bhnPnzmHLli3YsGEDCgsL0a1bN7i7u+Ovv/7C3r174ebmhscff9yQ76OPPsLy5cvx9ddfY8+ePbh58ybWr19vdJzly5eX+iKUhQsXYubMmahevTqSk5Nx6NCh+3PCZBOs5bostmLFCvj6+uLgwYMYPXo0Ro4ciWeffRaPPfYYjhw5gq5du2Lw4MHIzc2t3F8EPZwEUQmGDh0qevXqJYQQQq/Xiy1btgilUineeOMNw/aAgABRUFBgyLNq1SpRp04dodfrDesKCgqEs7Oz+PPPP4UQQgQFBYl58+YZthcWForq1asbjiWEED/99JOoU6dOqeWbP3++CA0NreBZkq2x9uuyffv2ok2bNobPWq1WuLq6isGDBxvWJScnCwBi//795f8FkN1hHzWVasOGDXBzc0NhYSH0ej0GDhyI6dOnG7ZHRkYa9f8dO3YMFy9ehLu7u9F+8vPzERcXh8zMTCQnJ6Nly5aGbQqFAs2bNzdqZuzduzd69+59/06MbJq1X5eNGjUy/CyXy+Hj44PIyEjDuoCAAABAWlpa2U+a7BYDNZWqQ4cOWLx4MRwdHREcHAyFwviScXV1NfqcnZ2NZs2aYfXq1Sb78vPzu69lJfth7delg4OD0WdJkozWFTef6/X6Sj82PXwYqKlUrq6uiIiIKHP6pk2bYs2aNfD39y/xPb5BQUH4+++/0a5dOwCAVqvF4cOH0bRp00opMz38eF2SPeFgMqpUgwYNgq+vL3r16oW//voL8fHx2LlzJ1577TVcvXoVADBmzBjMnTsXP//8M86ePYv/+7//Q0ZGhtF+1q9fj7p16z6AM6CHEa9LsmUM1FSpXFxcsHv3btSoUQPPPPMM6tWrhxdffBH5+fmGmszrr7+OwYMHY+jQoYiOjoa7u7tJv19mZibOnTv3IE6BHkK8LsmW8TWXREREVow1aiIiIivGQE1ERGTFGKiJiIisGAM1ERGRFWOgJiIismIM1ERERFaMgZqIiMiKMVATERFZMQZqIiIiK8ZATUREZMUYqImIiKwYAzUREZEV+3/BNcHEvJQQmwAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "best_rows = df.sort_values(\"test_accuracy\", ascending=False).groupby(\"feature_set\").head(1)\n", + "for _, row in best_rows.iterrows():\n", + " cm = np.array([[row[\"TN\"], row[\"FP\"]], [row[\"FN\"], row[\"TP\"]]], dtype=float)\n", + " if np.isnan(cm).any():\n", + " continue\n", + " fig = plt.figure(figsize=(5,5))\n", + " im = plt.imshow(cm, interpolation=\"nearest\")\n", + " plt.title(f\"Confusion Matrix — {row['model_family']} ({row['feature_set']})\")\n", + " plt.xticks([0,1], [\"Pred: f\",\"Pred: m\"])\n", + " plt.yticks([0,1], [\"True: f\",\"True: m\"])\n", + " # Annotate counts and rates\n", + " total = cm.sum()\n", + " for i in range(2):\n", + " for j in range(2):\n", + " val = cm[i,j]\n", + " plt.text(j, i, f\"{int(val)}\\n({val/total:.2%})\", ha=\"center\", va=\"center\")\n", + " plt.colorbar(im, fraction=0.046, pad=0.04)\n", + " plt.tight_layout()\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "588d43f2", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
model_familycomparisondelta_accuracy
0LOGISTIC_REGRESSIONFull name minus Native0.1930
1LOGISTIC_REGRESSIONSurname minus Native0.2095
2LIGHTGBMFull name minus Native0.0785
3LIGHTGBMSurname minus Native0.2230
4LSTMFull name minus Native0.2120
5LSTMSurname minus Native0.1775
6CNNFull name minus Native0.2535
7CNNSurname minus Native0.2680
8BIGRUFull name minus Native0.2115
9BIGRUSurname minus Native0.1970
10RANDOM_FORESTFull name minus Native-0.0010
11RANDOM_FORESTSurname minus Native0.2630
12TRANSFORMERFull name minus Native0.2055
13TRANSFORMERSurname minus Native0.1985
14NAIVE_BAYESFull name minus Native0.1855
15NAIVE_BAYESSurname minus Native0.1985
16XGBOOSTFull name minus Native0.1670
17XGBOOSTSurname minus Native0.2370
\n", + "
" + ], + "text/plain": [ + " model_family comparison delta_accuracy\n", + "0 LOGISTIC_REGRESSION Full name minus Native 0.1930\n", + "1 LOGISTIC_REGRESSION Surname minus Native 0.2095\n", + "2 LIGHTGBM Full name minus Native 0.0785\n", + "3 LIGHTGBM Surname minus Native 0.2230\n", + "4 LSTM Full name minus Native 0.2120\n", + "5 LSTM Surname minus Native 0.1775\n", + "6 CNN Full name minus Native 0.2535\n", + "7 CNN Surname minus Native 0.2680\n", + "8 BIGRU Full name minus Native 0.2115\n", + "9 BIGRU Surname minus Native 0.1970\n", + "10 RANDOM_FOREST Full name minus Native -0.0010\n", + "11 RANDOM_FOREST Surname minus Native 0.2630\n", + "12 TRANSFORMER Full name minus Native 0.2055\n", + "13 TRANSFORMER Surname minus Native 0.1985\n", + "14 NAIVE_BAYES Full name minus Native 0.1855\n", + "15 NAIVE_BAYES Surname minus Native 0.1985\n", + "16 XGBOOST Full name minus Native 0.1670\n", + "17 XGBOOST Surname minus Native 0.2370" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "deltas = []\n", + "for fam in families:\n", + " fam_rows = df[df[\"model_family\"].astype(str)==fam]\n", + " base = fam_rows[fam_rows[\"feature_set\"]==\"Native\"]\n", + " if len(base):\n", + " base_acc = float(base.iloc[0][\"test_accuracy\"])\n", + " for feat in [\"Full name\",\"Surname\"]:\n", + " tgt = fam_rows[fam_rows[\"feature_set\"]==feat]\n", + " if len(tgt):\n", + " deltas.append({\n", + " \"model_family\": fam,\n", + " \"comparison\": f\"{feat} minus Native\",\n", + " \"delta_accuracy\": float(tgt.iloc[0][\"test_accuracy\"]) - base_acc\n", + " })\n", + "\n", + "deltas_df = pd.DataFrame(deltas)\n", + "display(deltas_df)\n", + "\n", + "fig5 = plt.figure(figsize=(10,6))\n", + "# Make bars grouped by model_family\n", + "comp_types = deltas_df[\"comparison\"].unique().tolist() if not deltas_df.empty else []\n", + "x2 = np.arange(len(families))\n", + "width2 = 0.8 / max(1, len(comp_types))\n", + "for i, comp in enumerate(comp_types):\n", + " sub = deltas_df[deltas_df[\"comparison\"]==comp]\n", + " y = []\n", + " for fam in families:\n", + " row = sub[sub[\"model_family\"]==fam]\n", + " y.append(float(row.iloc[0][\"delta_accuracy\"]) if len(row) else np.nan)\n", + " plt.bar(x2 + i*width2 - (len(comp_types)-1)*width2/2, y, width2, label=comp)\n", + "\n", + "plt.xticks(x2, families)\n", + "plt.axhline(0, linestyle=\"--\")\n", + "plt.ylabel(\"Δ Accuracy vs Native\")\n", + "plt.title(\"Effect of feature set: Full name/Surname vs Native\")\n", + "plt.legend()\n", + "plt.tight_layout()\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/notebooks/names.ipynb b/src/notebooks/names.ipynb index 519aec1..cedf457 100644 --- a/src/notebooks/names.ipynb +++ b/src/notebooks/names.ipynb @@ -10,7 +10,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 19, "id": "initial_id", "metadata": { "ExecuteTime": { @@ -30,7 +30,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "id": "584a6fcfcbea71e4", "metadata": { "ExecuteTime": { @@ -44,7 +44,7 @@ "\n", "from ners.core.utils.data_loader import DataLoader\n", "from ners.core.utils.region_mapper import RegionMapper\n", - "from ners.core.config.pipeline_config import PipelineConfig\n", + "from ners.core.config import setup_config\n", "\n", "from ners.research.statistics.utils import LETTERS\n", "from ners.research.statistics.utils import build_category_distribution\n", @@ -58,7 +58,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 21, "id": "f1a69290-a9c0-40d0-9fe8-a06d8a466671", "metadata": { "ExecuteTime": { @@ -66,26 +66,27 @@ "start_time": "2025-09-28T21:41:26.478191Z" } }, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-10-05 23:12:53,875 - root - WARNING - Config file not found: config/pipeline.development.yaml. Using defaults.\n", + "2025-10-05 23:12:54,155 - root - INFO - Ensured all required directories exist\n", + "2025-10-05 23:12:54,165 - root - INFO - Loaded configuration: drc_names_pipeline v1.0.0\n", + "2025-10-05 23:12:54,174 - root - INFO - Environment: development\n", + "2025-10-05 23:12:54,193 - root - INFO - Config file: config/pipeline.development.yaml\n" + ] + } + ], "source": [ - "config = PipelineConfig(\n", - " paths={\n", - " \"root_dir\": \"../data\",\n", - " \"data_dir\": \"../data/dataset\",\n", - " \"models_dir\": \"../models\",\n", - " \"outputs_dir\": \"../data/processed\",\n", - " \"logs_dir\": \"../logs\",\n", - " \"configs_dir\": \"../configs\",\n", - " \"checkpoints_dir\": \"../checkpoints\",\n", - " }\n", - ")\n", - "\n", + "config = setup_config()\n", "loader = DataLoader(config)" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 22, "id": "e48c6fd9a213bcd2", "metadata": { "ExecuteTime": { @@ -94,6 +95,15 @@ } }, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-10-05 23:12:54,285 - root - INFO - Reading /Users/bernard-ng/dev/community/analysis/drc-ners-nlp/data/dataset/names_featured.csv with encoding: utf-8\n", + "2025-10-05 23:17:27,547 - root - INFO - Successfully read /Users/bernard-ng/dev/community/analysis/drc-ners-nlp/data/dataset/names_featured.csv with encoding: utf-8\n", + "2025-10-05 23:17:27,680 - root - INFO - Concatenating 65 optimized chunks\n" + ] + }, { "data": { "text/plain": [ @@ -104,7 +114,7 @@ " dtype='object')" ] }, - "execution_count": 4, + "execution_count": 22, "metadata": {}, "output_type": "execute_result" } @@ -125,7 +135,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 23, "id": "378147d2abc9ab24", "metadata": { "ExecuteTime": { @@ -139,7 +149,7 @@ "df_name_categories.head(12)\n", "\n", "# save data\n", - "df_name_categories.to_csv(\"../assets/identified_category_distribution.csv\", index=False)" + "df_name_categories.to_csv(\"../../assets/identified_category_distribution.csv\", index=False)" ] }, { @@ -152,7 +162,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 24, "id": "ae30e79a975010d4", "metadata": { "ExecuteTime": { @@ -163,7 +173,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -196,8 +206,8 @@ "plt.tight_layout()\n", "\n", "# Save figures\n", - "plt.savefig(\"../assets/distribution_grid.png\")\n", - "plt.savefig(\"../assets/distribution_grid.svg\")\n", + "plt.savefig(\"../../assets/distribution_grid.png\")\n", + "plt.savefig(\"../../assets/distribution_grid.svg\")\n", "\n", "plt.show()" ] @@ -212,7 +222,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 25, "id": "6d5c1abb55b7076a", "metadata": { "ExecuteTime": { @@ -223,7 +233,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -249,8 +259,8 @@ "plt.tight_layout()\n", "\n", "# save figures\n", - "plt.savefig(\"../assets/identified_category_distribution_by_province.png\")\n", - "plt.savefig(\"../assets/identified_category_distribution_by_province.svg\")\n", + "plt.savefig(\"../../assets/identified_category_distribution_by_province.png\")\n", + "plt.savefig(\"../../assets/identified_category_distribution_by_province.svg\")\n", "\n", "plt.show()" ] @@ -265,7 +275,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 26, "id": "1e7dde234bb3504f", "metadata": { "ExecuteTime": { @@ -280,7 +290,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "id": "24a4ad40319f441b", "metadata": { "ExecuteTime": { @@ -288,72 +298,7 @@ "start_time": "2025-09-28T21:42:05.308895Z" } }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
countuniquetopfreq
name10015595644336ilunga82342
province1001559512KINSHASA2106077
sex100155952m6033856
\n", - "
" - ], - "text/plain": [ - " count unique top freq\n", - "name 10015595 644336 ilunga 82342\n", - "province 10015595 12 KINSHASA 2106077\n", - "sex 10015595 2 m 6033856" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "df_names = build_words_token(df_base, \"identified_name\", \"name\")\n", "df_names = df_names[[\"name\", \"province\", \"sex\"]].reset_index(drop=True)\n", @@ -362,7 +307,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "id": "736b0d787b9a6809", "metadata": { "ExecuteTime": { @@ -431,7 +376,7 @@ "sex 5007877 2 m 3017009" ] }, - "execution_count": 10, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -444,7 +389,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "id": "7980efe654809722", "metadata": { "ExecuteTime": { @@ -463,7 +408,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "id": "9568492106dd2169", "metadata": { "ExecuteTime": { @@ -474,7 +419,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -515,15 +460,15 @@ "plt.tight_layout()\n", "\n", "# Save figures\n", - "plt.savefig(\"../assets/name_by_gender_distribution_grid.png\")\n", - "plt.savefig(\"../assets/name_by_gender_distribution_grid.svg\")\n", + "plt.savefig(\"../../assets/name_by_gender_distribution_grid.png\")\n", + "plt.savefig(\"../../assets/name_by_gender_distribution_grid.svg\")\n", "\n", "plt.show()" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "id": "12a7094d94ad519f", "metadata": { "ExecuteTime": { @@ -538,13 +483,13 @@ "names_transitions_females = build_transition_probabilities(df_names_f[\"name\"])\n", "\n", "names_transitions[\"df_probs\"].to_csv(\n", - " \"../assets/names_transition_probs.csv\", index=False\n", + " \"../../assets/names_transition_probs.csv\", index=False\n", ")" ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "id": "684b467b17955d65", "metadata": { "ExecuteTime": { @@ -559,13 +504,13 @@ "surnames_transitions_females = build_transition_probabilities(df_surnames_f[\"name\"])\n", "\n", "surnames_transitions[\"df_probs\"].to_csv(\n", - " \"../assets/surnames_transition_probs.csv\", index=False\n", + " \"../../assets/surnames_transition_probs.csv\", index=False\n", ")" ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "id": "f15ad6eb4df27527", "metadata": { "ExecuteTime": { @@ -573,28 +518,7 @@ "start_time": "2025-09-28T21:43:45.960221Z" } }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "fig, axes = plt.subplots(1, 3, figsize=(20, 6), sharex=True, sharey=True)\n", "hm1 = plot_transition_matrix(axes[0], names_transitions[\"df_probs\"], \"Native - Male\")\n", @@ -606,8 +530,8 @@ " hm3.collections[0], ax=axes, orientation=\"vertical\", fraction=0.03, pad=0.02\n", ")\n", "cbar.set_label(\"Transition probability\")\n", - "plt.savefig(\"../assets/names_transition_probabilities.png\")\n", - "plt.savefig(\"../assets/names_transition_probabilities.svg\")\n", + "plt.savefig(\"../../assets/names_transition_probabilities.png\")\n", + "plt.savefig(\"../../assets/names_transition_probabilities.svg\")\n", "\n", "fig, axes = plt.subplots(1, 3, figsize=(20, 6), sharex=True, sharey=True)\n", "hm4 = plot_transition_matrix(\n", @@ -623,8 +547,8 @@ " hm6.collections[0], ax=axes, orientation=\"vertical\", fraction=0.03, pad=0.02\n", ")\n", "cbar.set_label(\"Transition probability\")\n", - "plt.savefig(\"../assets/surnames_transition_probabilities.png\")\n", - "plt.savefig(\"../assets/surnames_transition_probabilities.svg\")\n", + "plt.savefig(\"../../assets/surnames_transition_probabilities.png\")\n", + "plt.savefig(\"../../assets/surnames_transition_probabilities.svg\")\n", "plt.show()" ] }, @@ -638,7 +562,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "id": "51ec0792317364fc", "metadata": { "ExecuteTime": { @@ -646,18 +570,7 @@ "start_time": "2025-09-28T21:43:49.382953Z" } }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "names_transitions_diff = (\n", " names_transitions_males[\"df_probs\"] - names_transitions_females[\"df_probs\"]\n", @@ -693,13 +606,13 @@ ")\n", "cbar.set_label(\"Difference in transition probability (Male − Female)\")\n", "\n", - "plt.savefig(\"../assets/transition_difference.png\")\n", + "plt.savefig(\"../../assets/transition_difference.png\")\n", "plt.show()" ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "id": "dae836cd8a6c26e6", "metadata": { "ExecuteTime": { @@ -707,73 +620,13 @@ "start_time": "2025-09-28T21:43:51.881491Z" } }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
l2kl_mfkl_fmjsdpermutation_p_value
names0.3189040.0432010.0215380.0323700.973
surnames1.2770020.2936190.2398950.2667570.003
\n", - "
" - ], - "text/plain": [ - " l2 kl_mf kl_fm jsd permutation_p_value\n", - "names 0.318904 0.043201 0.021538 0.032370 0.973\n", - "surnames 1.277002 0.293619 0.239895 0.266757 0.003" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "df_comparisons = build_transition_comparisons(\n", " {\"m\": names_transitions_males, \"f\": names_transitions_females},\n", " {\"m\": surnames_transitions_males, \"f\": surnames_transitions_females},\n", ")\n", - "df_comparisons.to_csv(\"../assets/transition_comparisons.csv\", index_label=\"category\")\n", + "df_comparisons.to_csv(\"../../assets/transition_comparisons.csv\", index_label=\"category\")\n", "df_comparisons.head(3)" ] }, @@ -807,7 +660,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "id": "9265e47639c4319d", "metadata": { "ExecuteTime": { @@ -815,25 +668,14 @@ "start_time": "2025-09-28T21:43:53.482784Z" } }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plot_letter_frequencies(df_names_m, df_names_f, title=\"names\")" ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "id": "395dace523f1bed4", "metadata": { "ExecuteTime": { @@ -841,18 +683,7 @@ "start_time": "2025-09-28T21:44:10.480696Z" } }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plot_letter_frequencies(df_surnames_m, df_surnames_f, title=\"surnames\")" ] @@ -875,7 +706,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": null, "id": "a685260c6ab8213d", "metadata": { "ExecuteTime": { @@ -953,7 +784,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": null, "id": "3924bde83845366f", "metadata": { "ExecuteTime": { @@ -989,7 +820,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": null, "id": "9ceaae3cc9040c31", "metadata": { "ExecuteTime": { @@ -997,129 +828,17 @@ "start_time": "2025-09-28T21:46:14.334119Z" } }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
sexposition2-grams3-grams4-grams
0femaleprefixka, ma, mu, mb, ng, ba, ki, lu, ts, botsh, kab, ngo, mas, kas, kal, muk, kav, mbu, mantshi, kavi, ngoy, kaso, ilun, mbuy, kaba, ntum...
1femalesuffixba, ga, la, ka, ma, da, go, ya, bo, nanga, mba, ngo, nda, ala, mbo, ngu, ndo, mbe, mbuanga, amba, ongo, umba, inga, ombo, unga, enga...
2femaleanyng, ka, mb, an, ba, ma, nd, ga, la, amnga, mba, ang, ngo, amb, ong, nda, ala, mbo, enganga, amba, ongo, tshi, umba, inga, ombo, unga...
3maleprefixka, mu, ma, ba, mb, ng, ki, lu, ts, bokab, tsh, kal, kas, muk, ngo, kam, mut, mul, mbutshi, ngoy, ilun, kaba, kaso, kamb, muke, kabe...
4malesuffixba, ga, la, go, ka, da, bo, le, di, manga, mba, ngo, nda, ala, mbo, ngu, mbe, ndo, eleamba, ongo, anga, umba, unga, ombo, anda, enga...
5maleanyng, ka, mb, ba, an, ma, mu, nd, am, alnga, mba, ngo, amb, ang, ong, ala, nda, shi, mboamba, ongo, anga, tshi, umba, unga, ombo, anda...
\n", - "
" - ], - "text/plain": [ - " sex position 2-grams \\\n", - "0 female prefix ka, ma, mu, mb, ng, ba, ki, lu, ts, bo \n", - "1 female suffix ba, ga, la, ka, ma, da, go, ya, bo, na \n", - "2 female any ng, ka, mb, an, ba, ma, nd, ga, la, am \n", - "3 male prefix ka, mu, ma, ba, mb, ng, ki, lu, ts, bo \n", - "4 male suffix ba, ga, la, go, ka, da, bo, le, di, ma \n", - "5 male any ng, ka, mb, ba, an, ma, mu, nd, am, al \n", - "\n", - " 3-grams \\\n", - "0 tsh, kab, ngo, mas, kas, kal, muk, kav, mbu, man \n", - "1 nga, mba, ngo, nda, ala, mbo, ngu, ndo, mbe, mbu \n", - "2 nga, mba, ang, ngo, amb, ong, nda, ala, mbo, eng \n", - "3 kab, tsh, kal, kas, muk, ngo, kam, mut, mul, mbu \n", - "4 nga, mba, ngo, nda, ala, mbo, ngu, mbe, ndo, ele \n", - "5 nga, mba, ngo, amb, ang, ong, ala, nda, shi, mbo \n", - "\n", - " 4-grams \n", - "0 tshi, kavi, ngoy, kaso, ilun, mbuy, kaba, ntum... \n", - "1 anga, amba, ongo, umba, inga, ombo, unga, enga... \n", - "2 anga, amba, ongo, tshi, umba, inga, ombo, unga... \n", - "3 tshi, ngoy, ilun, kaba, kaso, kamb, muke, kabe... \n", - "4 amba, ongo, anga, umba, unga, ombo, anda, enga... \n", - "5 amba, ongo, anga, tshi, umba, unga, ombo, anda... " - ] - }, - "execution_count": 22, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "names_ngrams_summary = build_ngram_summary_table(names_ngrams, top_k=10)\n", "\n", - "names_ngrams_summary.to_csv(\"../assets/names_ngrams_summary.csv\", index=False)\n", + "names_ngrams_summary.to_csv(\"../../assets/names_ngrams_summary.csv\", index=False)\n", "names_ngrams_summary" ] }, { "cell_type": "code", - "execution_count": 23, + "execution_count": null, "id": "951e8301584e549c", "metadata": { "ExecuteTime": { @@ -1155,7 +874,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": null, "id": "f7ee40432896ef54", "metadata": { "ExecuteTime": { @@ -1163,123 +882,11 @@ "start_time": "2025-09-28T21:47:19.831696Z" } }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
sexposition2-grams3-grams4-grams
0femaleprefixma, ch, be, na, an, sa, es, jo, ju, memar, cha, est, chr, gra, dor, sar, rut, ben, mermari, chri, esth, grac, sara, dorc, ruth, rach...
1femalesuffixne, ie, te, le, ce, ia, se, el, ah, thine, tte, lle, rah, nce, ene, nne, her, lie, rieette, line, tine, elle, ther, arie, ille, rcas...
2femaleanyne, in, el, an, ie, ri, ra, li, ar, erine, tte, ett, mar, ari, lle, lin, eli, the, ellette, line, ther, mari, tine, elle, rist, chri...
3maleprefixjo, je, pa, ch, ma, da, al, ju, be, frjea, jos, chr, pat, mar, jon, fra, dan, cha, benjean, chri, jose, jona, patr, fran, mich, emma...
4malesuffixin, el, an, ck, on, re, ce, er, se, isean, tin, ick, ier, ard, uel, ert, ain, iel, isejean, stin, rick, bert, seph, than, oise, avid...
5maleanyan, er, el, ie, in, ri, is, on, en, reric, sti, jea, ean, tin, ris, ier, ist, ick, josjean, stin, rist, rick, chri, hris, usti, bert...
\n", - "
" - ], - "text/plain": [ - " sex position 2-grams \\\n", - "0 female prefix ma, ch, be, na, an, sa, es, jo, ju, me \n", - "1 female suffix ne, ie, te, le, ce, ia, se, el, ah, th \n", - "2 female any ne, in, el, an, ie, ri, ra, li, ar, er \n", - "3 male prefix jo, je, pa, ch, ma, da, al, ju, be, fr \n", - "4 male suffix in, el, an, ck, on, re, ce, er, se, is \n", - "5 male any an, er, el, ie, in, ri, is, on, en, re \n", - "\n", - " 3-grams \\\n", - "0 mar, cha, est, chr, gra, dor, sar, rut, ben, mer \n", - "1 ine, tte, lle, rah, nce, ene, nne, her, lie, rie \n", - "2 ine, tte, ett, mar, ari, lle, lin, eli, the, ell \n", - "3 jea, jos, chr, pat, mar, jon, fra, dan, cha, ben \n", - "4 ean, tin, ick, ier, ard, uel, ert, ain, iel, ise \n", - "5 ric, sti, jea, ean, tin, ris, ier, ist, ick, jos \n", - "\n", - " 4-grams \n", - "0 mari, chri, esth, grac, sara, dorc, ruth, rach... \n", - "1 ette, line, tine, elle, ther, arie, ille, rcas... \n", - "2 ette, line, ther, mari, tine, elle, rist, chri... \n", - "3 jean, chri, jose, jona, patr, fran, mich, emma... \n", - "4 jean, stin, rick, bert, seph, than, oise, avid... \n", - "5 jean, stin, rist, rick, chri, hris, usti, bert... " - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "surnames_ngrams_summary = build_ngram_summary_table(surnames_ngrams, top_k=10)\n", "\n", - "surnames_ngrams_summary.to_csv(\"../assets/surnames_ngrams_summary.csv\", index=False)\n", + "surnames_ngrams_summary.to_csv(\"../../assets/surnames_ngrams_summary.csv\", index=False)\n", "surnames_ngrams_summary" ] }, @@ -1293,7 +900,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": null, "id": "28fe77f9-f9b0-4267-9dbb-3969e04b83fb", "metadata": { "ExecuteTime": { @@ -1391,7 +998,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": null, "id": "a01eb547985d5a62", "metadata": { "ExecuteTime": { @@ -1399,95 +1006,7 @@ "start_time": "2025-09-28T21:48:59.020841Z" } }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
name
0Monga
1Ngonganga
2Kanda
3Mbombonda
4Mbanga
5Mbanda
6Manga
7Bambi
8Mbale
9Mamba
\n", - "
" - ], - "text/plain": [ - " name\n", - "0 Monga\n", - "1 Ngonganga\n", - "2 Kanda\n", - "3 Mbombonda\n", - "4 Mbanga\n", - "5 Mbanda\n", - "6 Manga\n", - "7 Bambi\n", - "8 Mbale\n", - "9 Mamba" - ] - }, - "execution_count": 33, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "P = prepare_prob_matrix(names_transitions_males[\"df_probs\"], tokens)\n", "generated_var = [\n", @@ -1501,7 +1020,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": null, "id": "5d5ec37da189b7a8", "metadata": { "ExecuteTime": { @@ -1509,95 +1028,7 @@ "start_time": "2025-09-28T21:48:52.049436Z" } }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
name
0Mamba
1Kanga
2Mbokangango
3Belango
4Mbanga
5Mungo
6Langa
7Kambo
8Konga
9Mbulu
\n", - "
" - ], - "text/plain": [ - " name\n", - "0 Mamba\n", - "1 Kanga\n", - "2 Mbokangango\n", - "3 Belango\n", - "4 Mbanga\n", - "5 Mungo\n", - "6 Langa\n", - "7 Kambo\n", - "8 Konga\n", - "9 Mbulu" - ] - }, - "execution_count": 32, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "P = prepare_prob_matrix(names_transitions_females[\"df_probs\"], tokens)\n", "generated_var = [\n", @@ -1611,7 +1042,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": null, "id": "746028258a8d8dfe", "metadata": { "ExecuteTime": { @@ -1619,95 +1050,7 @@ "start_time": "2025-09-28T21:49:58.329362Z" } }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
name
0Jomane
1Maielane
2Miela
3Canella
4Thelie
5Siele
6Mielice
7Juege
8Anella
9Sesane
\n", - "
" - ], - "text/plain": [ - " name\n", - "0 Jomane\n", - "1 Maielane\n", - "2 Miela\n", - "3 Canella\n", - "4 Thelie\n", - "5 Siele\n", - "6 Mielice\n", - "7 Juege\n", - "8 Anella\n", - "9 Sesane" - ] - }, - "execution_count": 35, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "P = prepare_prob_matrix(surnames_transitions_females[\"df_probs\"], tokens)\n", "generated_var = [\n", @@ -1721,7 +1064,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": null, "id": "7227ac855ee3688f", "metadata": { "ExecuteTime": { @@ -1729,95 +1072,7 @@ "start_time": "2025-09-28T21:49:30.664938Z" } }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
name
0Jaman
1Chistis
2Mannane
3Celerie
4Jeusus
5Drinie
6Jerien
7Seristinelel
8Distugueran
9Alanche
\n", - "
" - ], - "text/plain": [ - " name\n", - "0 Jaman\n", - "1 Chistis\n", - "2 Mannane\n", - "3 Celerie\n", - "4 Jeusus\n", - "5 Drinie\n", - "6 Jerien\n", - "7 Seristinelel\n", - "8 Distugueran\n", - "9 Alanche" - ] - }, - "execution_count": 34, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "P = prepare_prob_matrix(surnames_transitions_males[\"df_probs\"], tokens)\n", "generated_var = [\n", @@ -1828,19 +1083,11 @@ "names = pd.DataFrame(generated_var, columns=[\"name\"])\n", "names" ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a96630f0d2a9195b", - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": ".venv", "language": "python", "name": "python3" }, @@ -1854,7 +1101,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.3" + "version": "3.11.13" } }, "nbformat": 4, diff --git a/src/notebooks/overview.ipynb b/src/notebooks/overview.ipynb index 2cc879d..cd2a130 100644 --- a/src/notebooks/overview.ipynb +++ b/src/notebooks/overview.ipynb @@ -10,7 +10,23 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, + "id": "80feb4d5", + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "import os\n", + "import math\n", + "from typing import Dict\n", + "\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 2, "id": "initial_id", "metadata": { "ExecuteTime": { @@ -21,23 +37,15 @@ }, "outputs": [], "source": [ - "import sys\n", - "import os\n", - "import math\n", - "from typing import Dict\n", - "\n", - "import pandas as pd\n", - "import matplotlib.pyplot as plt\n", - "\n", "sys.path.append(os.path.abspath(\"..\"))\n", + "from ners.core.config import setup_config\n", "from ners.core.utils.data_loader import DataLoader\n", - "from ners.core.utils.region_mapper import RegionMapper\n", - "from ners.core.config.pipeline_config import PipelineConfig" + "from ners.core.utils.region_mapper import RegionMapper" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "id": "a8fb2b6242a1d3ce", "metadata": { "ExecuteTime": { @@ -45,26 +53,27 @@ "start_time": "2025-10-03T09:49:28.633945Z" } }, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:root:Config file not found: config/pipeline.development.yaml. Using defaults.\n", + "2025-10-05 22:55:20,981 - root - INFO - Ensured all required directories exist\n", + "2025-10-05 22:55:20,987 - root - INFO - Loaded configuration: drc_names_pipeline v1.0.0\n", + "2025-10-05 22:55:20,995 - root - INFO - Environment: development\n", + "2025-10-05 22:55:21,002 - root - INFO - Config file: config/pipeline.development.yaml\n" + ] + } + ], "source": [ - "config = PipelineConfig(\n", - " paths={\n", - " \"root_dir\": \"../data\",\n", - " \"data_dir\": \"../data/dataset\",\n", - " \"models_dir\": \"../models\",\n", - " \"outputs_dir\": \"../data/processed\",\n", - " \"logs_dir\": \"../logs\",\n", - " \"configs_dir\": \"../configs\",\n", - " \"checkpoints_dir\": \"../checkpoints\",\n", - " }\n", - ")\n", - "\n", + "config = setup_config()\n", "loader = DataLoader(config)" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "id": "56b61bdd0628ebe4", "metadata": { "ExecuteTime": { @@ -72,7 +81,17 @@ "start_time": "2025-10-03T09:49:28.645041Z" } }, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-10-05 22:55:21,044 - root - INFO - Reading /Users/bernard-ng/dev/community/analysis/drc-ners-nlp/data/dataset/names.csv with encoding: utf-8\n", + "2025-10-05 22:57:35,223 - root - INFO - Successfully read /Users/bernard-ng/dev/community/analysis/drc-ners-nlp/data/dataset/names.csv with encoding: utf-8\n", + "2025-10-05 22:57:35,237 - root - INFO - Concatenating 81 optimized chunks\n" + ] + } + ], "source": [ "df = loader.load_csv_complete(config.paths.data_dir / \"names.csv\")" ] @@ -87,7 +106,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "id": "7000df8794ddfaad", "metadata": { "ExecuteTime": { @@ -190,7 +209,7 @@ "line 117146.0 826262.0 " ] }, - "execution_count": 4, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -209,7 +228,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "id": "e02c8023d43b3466", "metadata": { "ExecuteTime": { @@ -321,7 +340,7 @@ "[125 rows x 2 columns]" ] }, - "execution_count": 5, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -349,7 +368,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "id": "8f8a9bb068152311", "metadata": { "ExecuteTime": { @@ -450,7 +469,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "id": "4083480dfe1df962", "metadata": { "ExecuteTime": { @@ -461,7 +480,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -476,7 +495,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "id": "5242e5b15acb277c", "metadata": { "ExecuteTime": { @@ -491,7 +510,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "id": "d3e3268c111c5c22", "metadata": { "ExecuteTime": { @@ -508,7 +527,7 @@ " dtype='object')" ] }, - "execution_count": 9, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -519,7 +538,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 12, "id": "4d673e975665827f", "metadata": { "ExecuteTime": { @@ -739,7 +758,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 15, "id": "595487c63277e585", "metadata": { "ExecuteTime": { @@ -944,7 +963,7 @@ " )\n", "\n", " # legend, axes, limits\n", - " ax.legend(handles, labels, title=\"Province\", loc=\"upper left\", ncol=3)\n", + " ax.legend(handles, labels, title=\"Province\", loc=\"lower right\", ncol=3)\n", "\n", " ax.set_aspect(\"equal\", adjustable=\"datalim\")\n", " ax.set_xticks([])\n", @@ -957,13 +976,13 @@ " ax.set_xlim(min(xs) - pad, max(xs) + pad)\n", " # ax.set_ylim(min(ys) - pad, max(ys) + pad)\n", "\n", - " plt.savefig(\"../assets/regions-clusters-readable.png\")\n", + " plt.savefig(\"../../assets/regions-clusters-readable.png\")\n", " plt.show()" ] }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 16, "id": "20e16282a8eebc97", "metadata": { "ExecuteTime": { @@ -976,12 +995,12 @@ "name": "stderr", "output_type": "stream", "text": [ - "WARNING:matplotlib.axes._base:Ignoring fixed x limits to fulfill fixed data aspect with adjustable data limits.\n" + "2025-10-05 23:10:16,306 - matplotlib.axes._base - WARNING - Ignoring fixed x limits to fulfill fixed data aspect with adjustable data limits.\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1006,7 +1025,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "id": "73eac09aa9dd3d5", "metadata": { "ExecuteTime": { @@ -1165,7 +1184,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": null, "id": "d19d077267fbcff0", "metadata": { "ExecuteTime": { @@ -1315,9 +1334,39 @@ } }, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-10-05 23:15:29,930 - matplotlib.category - INFO - Using categorical units to plot a list of strings that are all parsable as floats or dates. If these strings should be plotted as numbers, cast to the appropriate data type before plotting.\n", + "2025-10-05 23:15:29,966 - matplotlib.category - INFO - Using categorical units to plot a list of strings that are all parsable as floats or dates. If these strings should be plotted as numbers, cast to the appropriate data type before plotting.\n", + "2025-10-05 23:15:30,223 - matplotlib.category - INFO - Using categorical units to plot a list of strings that are all parsable as floats or dates. If these strings should be plotted as numbers, cast to the appropriate data type before plotting.\n", + "2025-10-05 23:15:30,265 - matplotlib.category - INFO - Using categorical units to plot a list of strings that are all parsable as floats or dates. If these strings should be plotted as numbers, cast to the appropriate data type before plotting.\n", + "2025-10-05 23:15:30,419 - matplotlib.category - INFO - Using categorical units to plot a list of strings that are all parsable as floats or dates. If these strings should be plotted as numbers, cast to the appropriate data type before plotting.\n", + "2025-10-05 23:15:30,425 - matplotlib.category - INFO - Using categorical units to plot a list of strings that are all parsable as floats or dates. If these strings should be plotted as numbers, cast to the appropriate data type before plotting.\n", + "2025-10-05 23:15:30,645 - matplotlib.category - INFO - Using categorical units to plot a list of strings that are all parsable as floats or dates. If these strings should be plotted as numbers, cast to the appropriate data type before plotting.\n", + "2025-10-05 23:15:30,669 - matplotlib.category - INFO - Using categorical units to plot a list of strings that are all parsable as floats or dates. If these strings should be plotted as numbers, cast to the appropriate data type before plotting.\n", + "2025-10-05 23:15:30,905 - matplotlib.category - INFO - Using categorical units to plot a list of strings that are all parsable as floats or dates. If these strings should be plotted as numbers, cast to the appropriate data type before plotting.\n", + "2025-10-05 23:15:30,922 - matplotlib.category - INFO - Using categorical units to plot a list of strings that are all parsable as floats or dates. If these strings should be plotted as numbers, cast to the appropriate data type before plotting.\n", + "2025-10-05 23:15:31,157 - matplotlib.category - INFO - Using categorical units to plot a list of strings that are all parsable as floats or dates. If these strings should be plotted as numbers, cast to the appropriate data type before plotting.\n", + "2025-10-05 23:15:31,162 - matplotlib.category - INFO - Using categorical units to plot a list of strings that are all parsable as floats or dates. If these strings should be plotted as numbers, cast to the appropriate data type before plotting.\n", + "2025-10-05 23:15:31,453 - matplotlib.category - INFO - Using categorical units to plot a list of strings that are all parsable as floats or dates. If these strings should be plotted as numbers, cast to the appropriate data type before plotting.\n", + "2025-10-05 23:15:31,484 - matplotlib.category - INFO - Using categorical units to plot a list of strings that are all parsable as floats or dates. If these strings should be plotted as numbers, cast to the appropriate data type before plotting.\n", + "2025-10-05 23:15:31,722 - matplotlib.category - INFO - Using categorical units to plot a list of strings that are all parsable as floats or dates. If these strings should be plotted as numbers, cast to the appropriate data type before plotting.\n", + "2025-10-05 23:15:31,736 - matplotlib.category - INFO - Using categorical units to plot a list of strings that are all parsable as floats or dates. If these strings should be plotted as numbers, cast to the appropriate data type before plotting.\n", + "2025-10-05 23:15:31,907 - matplotlib.category - INFO - Using categorical units to plot a list of strings that are all parsable as floats or dates. If these strings should be plotted as numbers, cast to the appropriate data type before plotting.\n", + "2025-10-05 23:15:31,919 - matplotlib.category - INFO - Using categorical units to plot a list of strings that are all parsable as floats or dates. If these strings should be plotted as numbers, cast to the appropriate data type before plotting.\n", + "2025-10-05 23:15:32,177 - matplotlib.category - INFO - Using categorical units to plot a list of strings that are all parsable as floats or dates. If these strings should be plotted as numbers, cast to the appropriate data type before plotting.\n", + "2025-10-05 23:15:32,186 - matplotlib.category - INFO - Using categorical units to plot a list of strings that are all parsable as floats or dates. If these strings should be plotted as numbers, cast to the appropriate data type before plotting.\n", + "2025-10-05 23:15:32,411 - matplotlib.category - INFO - Using categorical units to plot a list of strings that are all parsable as floats or dates. If these strings should be plotted as numbers, cast to the appropriate data type before plotting.\n", + "2025-10-05 23:15:32,468 - matplotlib.category - INFO - Using categorical units to plot a list of strings that are all parsable as floats or dates. If these strings should be plotted as numbers, cast to the appropriate data type before plotting.\n", + "2025-10-05 23:15:32,772 - matplotlib.category - INFO - Using categorical units to plot a list of strings that are all parsable as floats or dates. If these strings should be plotted as numbers, cast to the appropriate data type before plotting.\n", + "2025-10-05 23:15:32,782 - matplotlib.category - INFO - Using categorical units to plot a list of strings that are all parsable as floats or dates. If these strings should be plotted as numbers, cast to the appropriate data type before plotting.\n" + ] + }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1329,25 +1378,33 @@ "source": [ "plot_all_parents_by_year_grid(df[\"region\"], df[\"year\"], RegionMapper(), per_row=4)" ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fcdf0854", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": ".venv", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", - "version": 2 + "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.6" + "pygments_lexer": "ipython3", + "version": "3.11.13" } }, "nbformat": 4, diff --git a/uv.lock b/uv.lock index 7c4d45c..af00728 100644 --- a/uv.lock +++ b/uv.lock @@ -55,6 +55,24 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/15/b3/9b1a8074496371342ec1e796a96f99c82c945a339cd81a8e73de28b4cf9e/anyio-4.11.0-py3-none-any.whl", hash = "sha256:0287e96f4d26d4149305414d4e3bc32f0dcd0862365a4bddea19d7a1ec38c4fc", size = 109097, upload-time = "2025-09-23T09:19:10.601Z" }, ] +[[package]] +name = "appnope" +version = "0.1.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/35/5d/752690df9ef5b76e169e68d6a129fa6d08a7100ca7f754c89495db3c6019/appnope-0.1.4.tar.gz", hash = "sha256:1de3860566df9caf38f01f86f65e0e13e379af54f9e4bee1e66b48f2efffd1ee", size = 4170, upload-time = "2024-02-06T09:43:11.258Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/81/29/5ecc3a15d5a33e31b26c11426c45c501e439cb865d0bff96315d86443b78/appnope-0.1.4-py2.py3-none-any.whl", hash = "sha256:502575ee11cd7a28c0205f379b525beefebab9d161b7c964670864014ed7213c", size = 4321, upload-time = "2024-02-06T09:43:09.663Z" }, +] + +[[package]] +name = "asttokens" +version = "3.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/4a/e7/82da0a03e7ba5141f05cce0d302e6eed121ae055e0456ca228bf693984bc/asttokens-3.0.0.tar.gz", hash = "sha256:0dcd8baa8d62b0c1d118b399b2ddba3c4aff271d0d7a9e0d4c1681c79035bbc7", size = 61978, upload-time = "2024-11-30T04:30:14.439Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/25/8a/c46dcc25341b5bce5472c718902eb3d38600a903b14fa6aeecef3f21a46f/asttokens-3.0.0-py3-none-any.whl", hash = "sha256:e3078351a059199dd5138cb1c706e6430c05eff2ff136af5eb4790f9d28932e2", size = 26918, upload-time = "2024-11-30T04:30:10.946Z" }, +] + [[package]] name = "astunparse" version = "1.6.3" @@ -151,6 +169,76 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/e4/37/af0d2ef3967ac0d6113837b44a4f0bfe1328c2b9763bd5b1744520e5cfed/certifi-2025.10.5-py3-none-any.whl", hash = "sha256:0f212c2744a9bb6de0c56639a6f68afe01ecd92d91f14ae897c4fe7bbeeef0de", size = 163286, upload-time = "2025-10-05T04:12:14.03Z" }, ] +[[package]] +name = "cffi" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pycparser", marker = "implementation_name != 'PyPy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/eb/56/b1ba7935a17738ae8453301356628e8147c79dbb825bcbc73dc7401f9846/cffi-2.0.0.tar.gz", hash = "sha256:44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529", size = 523588, upload-time = "2025-09-08T23:24:04.541Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/12/4a/3dfd5f7850cbf0d06dc84ba9aa00db766b52ca38d8b86e3a38314d52498c/cffi-2.0.0-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:b4c854ef3adc177950a8dfc81a86f5115d2abd545751a304c5bcf2c2c7283cfe", size = 184344, upload-time = "2025-09-08T23:22:26.456Z" }, + { url = "https://files.pythonhosted.org/packages/4f/8b/f0e4c441227ba756aafbe78f117485b25bb26b1c059d01f137fa6d14896b/cffi-2.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2de9a304e27f7596cd03d16f1b7c72219bd944e99cc52b84d0145aefb07cbd3c", size = 180560, upload-time = "2025-09-08T23:22:28.197Z" }, + { url = "https://files.pythonhosted.org/packages/b1/b7/1200d354378ef52ec227395d95c2576330fd22a869f7a70e88e1447eb234/cffi-2.0.0-cp311-cp311-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:baf5215e0ab74c16e2dd324e8ec067ef59e41125d3eade2b863d294fd5035c92", size = 209613, upload-time = "2025-09-08T23:22:29.475Z" }, + { url = "https://files.pythonhosted.org/packages/b8/56/6033f5e86e8cc9bb629f0077ba71679508bdf54a9a5e112a3c0b91870332/cffi-2.0.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:730cacb21e1bdff3ce90babf007d0a0917cc3e6492f336c2f0134101e0944f93", size = 216476, upload-time = "2025-09-08T23:22:31.063Z" }, + { url = "https://files.pythonhosted.org/packages/dc/7f/55fecd70f7ece178db2f26128ec41430d8720f2d12ca97bf8f0a628207d5/cffi-2.0.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:6824f87845e3396029f3820c206e459ccc91760e8fa24422f8b0c3d1731cbec5", size = 203374, upload-time = "2025-09-08T23:22:32.507Z" }, + { url = "https://files.pythonhosted.org/packages/84/ef/a7b77c8bdc0f77adc3b46888f1ad54be8f3b7821697a7b89126e829e676a/cffi-2.0.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:9de40a7b0323d889cf8d23d1ef214f565ab154443c42737dfe52ff82cf857664", size = 202597, upload-time = "2025-09-08T23:22:34.132Z" }, + { url = "https://files.pythonhosted.org/packages/d7/91/500d892b2bf36529a75b77958edfcd5ad8e2ce4064ce2ecfeab2125d72d1/cffi-2.0.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8941aaadaf67246224cee8c3803777eed332a19d909b47e29c9842ef1e79ac26", size = 215574, upload-time = "2025-09-08T23:22:35.443Z" }, + { url = "https://files.pythonhosted.org/packages/44/64/58f6255b62b101093d5df22dcb752596066c7e89dd725e0afaed242a61be/cffi-2.0.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:a05d0c237b3349096d3981b727493e22147f934b20f6f125a3eba8f994bec4a9", size = 218971, upload-time = "2025-09-08T23:22:36.805Z" }, + { url = "https://files.pythonhosted.org/packages/ab/49/fa72cebe2fd8a55fbe14956f9970fe8eb1ac59e5df042f603ef7c8ba0adc/cffi-2.0.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:94698a9c5f91f9d138526b48fe26a199609544591f859c870d477351dc7b2414", size = 211972, upload-time = "2025-09-08T23:22:38.436Z" }, + { url = "https://files.pythonhosted.org/packages/0b/28/dd0967a76aab36731b6ebfe64dec4e981aff7e0608f60c2d46b46982607d/cffi-2.0.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:5fed36fccc0612a53f1d4d9a816b50a36702c28a2aa880cb8a122b3466638743", size = 217078, upload-time = "2025-09-08T23:22:39.776Z" }, + { url = "https://files.pythonhosted.org/packages/2b/c0/015b25184413d7ab0a410775fdb4a50fca20f5589b5dab1dbbfa3baad8ce/cffi-2.0.0-cp311-cp311-win32.whl", hash = "sha256:c649e3a33450ec82378822b3dad03cc228b8f5963c0c12fc3b1e0ab940f768a5", size = 172076, upload-time = "2025-09-08T23:22:40.95Z" }, + { url = "https://files.pythonhosted.org/packages/ae/8f/dc5531155e7070361eb1b7e4c1a9d896d0cb21c49f807a6c03fd63fc877e/cffi-2.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:66f011380d0e49ed280c789fbd08ff0d40968ee7b665575489afa95c98196ab5", size = 182820, upload-time = "2025-09-08T23:22:42.463Z" }, + { url = "https://files.pythonhosted.org/packages/95/5c/1b493356429f9aecfd56bc171285a4c4ac8697f76e9bbbbb105e537853a1/cffi-2.0.0-cp311-cp311-win_arm64.whl", hash = "sha256:c6638687455baf640e37344fe26d37c404db8b80d037c3d29f58fe8d1c3b194d", size = 177635, upload-time = "2025-09-08T23:22:43.623Z" }, + { url = "https://files.pythonhosted.org/packages/ea/47/4f61023ea636104d4f16ab488e268b93008c3d0bb76893b1b31db1f96802/cffi-2.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6d02d6655b0e54f54c4ef0b94eb6be0607b70853c45ce98bd278dc7de718be5d", size = 185271, upload-time = "2025-09-08T23:22:44.795Z" }, + { url = "https://files.pythonhosted.org/packages/df/a2/781b623f57358e360d62cdd7a8c681f074a71d445418a776eef0aadb4ab4/cffi-2.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8eca2a813c1cb7ad4fb74d368c2ffbbb4789d377ee5bb8df98373c2cc0dee76c", size = 181048, upload-time = "2025-09-08T23:22:45.938Z" }, + { url = "https://files.pythonhosted.org/packages/ff/df/a4f0fbd47331ceeba3d37c2e51e9dfc9722498becbeec2bd8bc856c9538a/cffi-2.0.0-cp312-cp312-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:21d1152871b019407d8ac3985f6775c079416c282e431a4da6afe7aefd2bccbe", size = 212529, upload-time = "2025-09-08T23:22:47.349Z" }, + { url = "https://files.pythonhosted.org/packages/d5/72/12b5f8d3865bf0f87cf1404d8c374e7487dcf097a1c91c436e72e6badd83/cffi-2.0.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:b21e08af67b8a103c71a250401c78d5e0893beff75e28c53c98f4de42f774062", size = 220097, upload-time = "2025-09-08T23:22:48.677Z" }, + { url = "https://files.pythonhosted.org/packages/c2/95/7a135d52a50dfa7c882ab0ac17e8dc11cec9d55d2c18dda414c051c5e69e/cffi-2.0.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:1e3a615586f05fc4065a8b22b8152f0c1b00cdbc60596d187c2a74f9e3036e4e", size = 207983, upload-time = "2025-09-08T23:22:50.06Z" }, + { url = "https://files.pythonhosted.org/packages/3a/c8/15cb9ada8895957ea171c62dc78ff3e99159ee7adb13c0123c001a2546c1/cffi-2.0.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:81afed14892743bbe14dacb9e36d9e0e504cd204e0b165062c488942b9718037", size = 206519, upload-time = "2025-09-08T23:22:51.364Z" }, + { url = "https://files.pythonhosted.org/packages/78/2d/7fa73dfa841b5ac06c7b8855cfc18622132e365f5b81d02230333ff26e9e/cffi-2.0.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3e17ed538242334bf70832644a32a7aae3d83b57567f9fd60a26257e992b79ba", size = 219572, upload-time = "2025-09-08T23:22:52.902Z" }, + { url = "https://files.pythonhosted.org/packages/07/e0/267e57e387b4ca276b90f0434ff88b2c2241ad72b16d31836adddfd6031b/cffi-2.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3925dd22fa2b7699ed2617149842d2e6adde22b262fcbfada50e3d195e4b3a94", size = 222963, upload-time = "2025-09-08T23:22:54.518Z" }, + { url = "https://files.pythonhosted.org/packages/b6/75/1f2747525e06f53efbd878f4d03bac5b859cbc11c633d0fb81432d98a795/cffi-2.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:2c8f814d84194c9ea681642fd164267891702542f028a15fc97d4674b6206187", size = 221361, upload-time = "2025-09-08T23:22:55.867Z" }, + { url = "https://files.pythonhosted.org/packages/7b/2b/2b6435f76bfeb6bbf055596976da087377ede68df465419d192acf00c437/cffi-2.0.0-cp312-cp312-win32.whl", hash = "sha256:da902562c3e9c550df360bfa53c035b2f241fed6d9aef119048073680ace4a18", size = 172932, upload-time = "2025-09-08T23:22:57.188Z" }, + { url = "https://files.pythonhosted.org/packages/f8/ed/13bd4418627013bec4ed6e54283b1959cf6db888048c7cf4b4c3b5b36002/cffi-2.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:da68248800ad6320861f129cd9c1bf96ca849a2771a59e0344e88681905916f5", size = 183557, upload-time = "2025-09-08T23:22:58.351Z" }, + { url = "https://files.pythonhosted.org/packages/95/31/9f7f93ad2f8eff1dbc1c3656d7ca5bfd8fb52c9d786b4dcf19b2d02217fa/cffi-2.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:4671d9dd5ec934cb9a73e7ee9676f9362aba54f7f34910956b84d727b0d73fb6", size = 177762, upload-time = "2025-09-08T23:22:59.668Z" }, + { url = "https://files.pythonhosted.org/packages/4b/8d/a0a47a0c9e413a658623d014e91e74a50cdd2c423f7ccfd44086ef767f90/cffi-2.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:00bdf7acc5f795150faa6957054fbbca2439db2f775ce831222b66f192f03beb", size = 185230, upload-time = "2025-09-08T23:23:00.879Z" }, + { url = "https://files.pythonhosted.org/packages/4a/d2/a6c0296814556c68ee32009d9c2ad4f85f2707cdecfd7727951ec228005d/cffi-2.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:45d5e886156860dc35862657e1494b9bae8dfa63bf56796f2fb56e1679fc0bca", size = 181043, upload-time = "2025-09-08T23:23:02.231Z" }, + { url = "https://files.pythonhosted.org/packages/b0/1e/d22cc63332bd59b06481ceaac49d6c507598642e2230f201649058a7e704/cffi-2.0.0-cp313-cp313-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:07b271772c100085dd28b74fa0cd81c8fb1a3ba18b21e03d7c27f3436a10606b", size = 212446, upload-time = "2025-09-08T23:23:03.472Z" }, + { url = "https://files.pythonhosted.org/packages/a9/f5/a2c23eb03b61a0b8747f211eb716446c826ad66818ddc7810cc2cc19b3f2/cffi-2.0.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d48a880098c96020b02d5a1f7d9251308510ce8858940e6fa99ece33f610838b", size = 220101, upload-time = "2025-09-08T23:23:04.792Z" }, + { url = "https://files.pythonhosted.org/packages/f2/7f/e6647792fc5850d634695bc0e6ab4111ae88e89981d35ac269956605feba/cffi-2.0.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:f93fd8e5c8c0a4aa1f424d6173f14a892044054871c771f8566e4008eaa359d2", size = 207948, upload-time = "2025-09-08T23:23:06.127Z" }, + { url = "https://files.pythonhosted.org/packages/cb/1e/a5a1bd6f1fb30f22573f76533de12a00bf274abcdc55c8edab639078abb6/cffi-2.0.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:dd4f05f54a52fb558f1ba9f528228066954fee3ebe629fc1660d874d040ae5a3", size = 206422, upload-time = "2025-09-08T23:23:07.753Z" }, + { url = "https://files.pythonhosted.org/packages/98/df/0a1755e750013a2081e863e7cd37e0cdd02664372c754e5560099eb7aa44/cffi-2.0.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c8d3b5532fc71b7a77c09192b4a5a200ea992702734a2e9279a37f2478236f26", size = 219499, upload-time = "2025-09-08T23:23:09.648Z" }, + { url = "https://files.pythonhosted.org/packages/50/e1/a969e687fcf9ea58e6e2a928ad5e2dd88cc12f6f0ab477e9971f2309b57c/cffi-2.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d9b29c1f0ae438d5ee9acb31cadee00a58c46cc9c0b2f9038c6b0b3470877a8c", size = 222928, upload-time = "2025-09-08T23:23:10.928Z" }, + { url = "https://files.pythonhosted.org/packages/36/54/0362578dd2c9e557a28ac77698ed67323ed5b9775ca9d3fe73fe191bb5d8/cffi-2.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6d50360be4546678fc1b79ffe7a66265e28667840010348dd69a314145807a1b", size = 221302, upload-time = "2025-09-08T23:23:12.42Z" }, + { url = "https://files.pythonhosted.org/packages/eb/6d/bf9bda840d5f1dfdbf0feca87fbdb64a918a69bca42cfa0ba7b137c48cb8/cffi-2.0.0-cp313-cp313-win32.whl", hash = "sha256:74a03b9698e198d47562765773b4a8309919089150a0bb17d829ad7b44b60d27", size = 172909, upload-time = "2025-09-08T23:23:14.32Z" }, + { url = "https://files.pythonhosted.org/packages/37/18/6519e1ee6f5a1e579e04b9ddb6f1676c17368a7aba48299c3759bbc3c8b3/cffi-2.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:19f705ada2530c1167abacb171925dd886168931e0a7b78f5bffcae5c6b5be75", size = 183402, upload-time = "2025-09-08T23:23:15.535Z" }, + { url = "https://files.pythonhosted.org/packages/cb/0e/02ceeec9a7d6ee63bb596121c2c8e9b3a9e150936f4fbef6ca1943e6137c/cffi-2.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:256f80b80ca3853f90c21b23ee78cd008713787b1b1e93eae9f3d6a7134abd91", size = 177780, upload-time = "2025-09-08T23:23:16.761Z" }, + { url = "https://files.pythonhosted.org/packages/92/c4/3ce07396253a83250ee98564f8d7e9789fab8e58858f35d07a9a2c78de9f/cffi-2.0.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fc33c5141b55ed366cfaad382df24fe7dcbc686de5be719b207bb248e3053dc5", size = 185320, upload-time = "2025-09-08T23:23:18.087Z" }, + { url = "https://files.pythonhosted.org/packages/59/dd/27e9fa567a23931c838c6b02d0764611c62290062a6d4e8ff7863daf9730/cffi-2.0.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c654de545946e0db659b3400168c9ad31b5d29593291482c43e3564effbcee13", size = 181487, upload-time = "2025-09-08T23:23:19.622Z" }, + { url = "https://files.pythonhosted.org/packages/d6/43/0e822876f87ea8a4ef95442c3d766a06a51fc5298823f884ef87aaad168c/cffi-2.0.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:24b6f81f1983e6df8db3adc38562c83f7d4a0c36162885ec7f7b77c7dcbec97b", size = 220049, upload-time = "2025-09-08T23:23:20.853Z" }, + { url = "https://files.pythonhosted.org/packages/b4/89/76799151d9c2d2d1ead63c2429da9ea9d7aac304603de0c6e8764e6e8e70/cffi-2.0.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:12873ca6cb9b0f0d3a0da705d6086fe911591737a59f28b7936bdfed27c0d47c", size = 207793, upload-time = "2025-09-08T23:23:22.08Z" }, + { url = "https://files.pythonhosted.org/packages/bb/dd/3465b14bb9e24ee24cb88c9e3730f6de63111fffe513492bf8c808a3547e/cffi-2.0.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:d9b97165e8aed9272a6bb17c01e3cc5871a594a446ebedc996e2397a1c1ea8ef", size = 206300, upload-time = "2025-09-08T23:23:23.314Z" }, + { url = "https://files.pythonhosted.org/packages/47/d9/d83e293854571c877a92da46fdec39158f8d7e68da75bf73581225d28e90/cffi-2.0.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:afb8db5439b81cf9c9d0c80404b60c3cc9c3add93e114dcae767f1477cb53775", size = 219244, upload-time = "2025-09-08T23:23:24.541Z" }, + { url = "https://files.pythonhosted.org/packages/2b/0f/1f177e3683aead2bb00f7679a16451d302c436b5cbf2505f0ea8146ef59e/cffi-2.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:737fe7d37e1a1bffe70bd5754ea763a62a066dc5913ca57e957824b72a85e205", size = 222828, upload-time = "2025-09-08T23:23:26.143Z" }, + { url = "https://files.pythonhosted.org/packages/c6/0f/cafacebd4b040e3119dcb32fed8bdef8dfe94da653155f9d0b9dc660166e/cffi-2.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:38100abb9d1b1435bc4cc340bb4489635dc2f0da7456590877030c9b3d40b0c1", size = 220926, upload-time = "2025-09-08T23:23:27.873Z" }, + { url = "https://files.pythonhosted.org/packages/3e/aa/df335faa45b395396fcbc03de2dfcab242cd61a9900e914fe682a59170b1/cffi-2.0.0-cp314-cp314-win32.whl", hash = "sha256:087067fa8953339c723661eda6b54bc98c5625757ea62e95eb4898ad5e776e9f", size = 175328, upload-time = "2025-09-08T23:23:44.61Z" }, + { url = "https://files.pythonhosted.org/packages/bb/92/882c2d30831744296ce713f0feb4c1cd30f346ef747b530b5318715cc367/cffi-2.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:203a48d1fb583fc7d78a4c6655692963b860a417c0528492a6bc21f1aaefab25", size = 185650, upload-time = "2025-09-08T23:23:45.848Z" }, + { url = "https://files.pythonhosted.org/packages/9f/2c/98ece204b9d35a7366b5b2c6539c350313ca13932143e79dc133ba757104/cffi-2.0.0-cp314-cp314-win_arm64.whl", hash = "sha256:dbd5c7a25a7cb98f5ca55d258b103a2054f859a46ae11aaf23134f9cc0d356ad", size = 180687, upload-time = "2025-09-08T23:23:47.105Z" }, + { url = "https://files.pythonhosted.org/packages/3e/61/c768e4d548bfa607abcda77423448df8c471f25dbe64fb2ef6d555eae006/cffi-2.0.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:9a67fc9e8eb39039280526379fb3a70023d77caec1852002b4da7e8b270c4dd9", size = 188773, upload-time = "2025-09-08T23:23:29.347Z" }, + { url = "https://files.pythonhosted.org/packages/2c/ea/5f76bce7cf6fcd0ab1a1058b5af899bfbef198bea4d5686da88471ea0336/cffi-2.0.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7a66c7204d8869299919db4d5069a82f1561581af12b11b3c9f48c584eb8743d", size = 185013, upload-time = "2025-09-08T23:23:30.63Z" }, + { url = "https://files.pythonhosted.org/packages/be/b4/c56878d0d1755cf9caa54ba71e5d049479c52f9e4afc230f06822162ab2f/cffi-2.0.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7cc09976e8b56f8cebd752f7113ad07752461f48a58cbba644139015ac24954c", size = 221593, upload-time = "2025-09-08T23:23:31.91Z" }, + { url = "https://files.pythonhosted.org/packages/e0/0d/eb704606dfe8033e7128df5e90fee946bbcb64a04fcdaa97321309004000/cffi-2.0.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:92b68146a71df78564e4ef48af17551a5ddd142e5190cdf2c5624d0c3ff5b2e8", size = 209354, upload-time = "2025-09-08T23:23:33.214Z" }, + { url = "https://files.pythonhosted.org/packages/d8/19/3c435d727b368ca475fb8742ab97c9cb13a0de600ce86f62eab7fa3eea60/cffi-2.0.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:b1e74d11748e7e98e2f426ab176d4ed720a64412b6a15054378afdb71e0f37dc", size = 208480, upload-time = "2025-09-08T23:23:34.495Z" }, + { url = "https://files.pythonhosted.org/packages/d0/44/681604464ed9541673e486521497406fadcc15b5217c3e326b061696899a/cffi-2.0.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:28a3a209b96630bca57cce802da70c266eb08c6e97e5afd61a75611ee6c64592", size = 221584, upload-time = "2025-09-08T23:23:36.096Z" }, + { url = "https://files.pythonhosted.org/packages/25/8e/342a504ff018a2825d395d44d63a767dd8ebc927ebda557fecdaca3ac33a/cffi-2.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:7553fb2090d71822f02c629afe6042c299edf91ba1bf94951165613553984512", size = 224443, upload-time = "2025-09-08T23:23:37.328Z" }, + { url = "https://files.pythonhosted.org/packages/e1/5e/b666bacbbc60fbf415ba9988324a132c9a7a0448a9a8f125074671c0f2c3/cffi-2.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6c6c373cfc5c83a975506110d17457138c8c63016b563cc9ed6e056a82f13ce4", size = 223437, upload-time = "2025-09-08T23:23:38.945Z" }, + { url = "https://files.pythonhosted.org/packages/a0/1d/ec1a60bd1a10daa292d3cd6bb0b359a81607154fb8165f3ec95fe003b85c/cffi-2.0.0-cp314-cp314t-win32.whl", hash = "sha256:1fc9ea04857caf665289b7a75923f2c6ed559b8298a1b8c49e59f7dd95c8481e", size = 180487, upload-time = "2025-09-08T23:23:40.423Z" }, + { url = "https://files.pythonhosted.org/packages/bf/41/4c1168c74fac325c0c8156f04b6749c8b6a8f405bbf91413ba088359f60d/cffi-2.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:d68b6cef7827e8641e8ef16f4494edda8b36104d79773a334beaa1e3521430f6", size = 191726, upload-time = "2025-09-08T23:23:41.742Z" }, + { url = "https://files.pythonhosted.org/packages/ae/3a/dbeec9d1ee0844c679f6bb5d6ad4e9f198b1224f4e7a32825f47f6192b0c/cffi-2.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:0a1527a803f0a659de1af2e1fd700213caba79377e27e4693648c2923da066f9", size = 184195, upload-time = "2025-09-08T23:23:43.004Z" }, +] + [[package]] name = "charset-normalizer" version = "3.4.3" @@ -234,6 +322,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" }, ] +[[package]] +name = "comm" +version = "0.2.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/4c/13/7d740c5849255756bc17888787313b61fd38a0a8304fc4f073dfc46122aa/comm-0.2.3.tar.gz", hash = "sha256:2dc8048c10962d55d7ad693be1e7045d891b7ce8d999c97963a5e3e99c055971", size = 6319, upload-time = "2025-07-25T14:02:04.452Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/60/97/891a0971e1e4a8c5d2b20bbe0e524dc04548d2307fee33cdeba148fd4fc7/comm-0.2.3-py3-none-any.whl", hash = "sha256:c615d91d75f7f04f095b30d1c1711babd43bdc6419c1be9886a85f2f4e489417", size = 7294, upload-time = "2025-07-25T14:02:02.896Z" }, +] + [[package]] name = "confection" version = "0.1.5" @@ -367,6 +464,49 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/74/65/c162fbac63e867a055240b6600b92ef96c0eb7a1895312ac53c4be93d056/cymem-2.0.11-cp313-cp313-win_amd64.whl", hash = "sha256:25da111adf425c29af0cfd9fecfec1c71c8d82e2244a85166830a0817a66ada7", size = 39090, upload-time = "2025-01-16T21:50:24.239Z" }, ] +[[package]] +name = "debugpy" +version = "1.8.17" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/15/ad/71e708ff4ca377c4230530d6a7aa7992592648c122a2cd2b321cf8b35a76/debugpy-1.8.17.tar.gz", hash = "sha256:fd723b47a8c08892b1a16b2c6239a8b96637c62a59b94bb5dab4bac592a58a8e", size = 1644129, upload-time = "2025-09-17T16:33:20.633Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d8/53/3af72b5c159278c4a0cf4cffa518675a0e73bdb7d1cac0239b815502d2ce/debugpy-1.8.17-cp311-cp311-macosx_15_0_universal2.whl", hash = "sha256:d3fce3f0e3de262a3b67e69916d001f3e767661c6e1ee42553009d445d1cd840", size = 2207154, upload-time = "2025-09-17T16:33:29.457Z" }, + { url = "https://files.pythonhosted.org/packages/8f/6d/204f407df45600e2245b4a39860ed4ba32552330a0b3f5f160ae4cc30072/debugpy-1.8.17-cp311-cp311-manylinux_2_34_x86_64.whl", hash = "sha256:c6bdf134457ae0cac6fb68205776be635d31174eeac9541e1d0c062165c6461f", size = 3170322, upload-time = "2025-09-17T16:33:30.837Z" }, + { url = "https://files.pythonhosted.org/packages/f2/13/1b8f87d39cf83c6b713de2620c31205299e6065622e7dd37aff4808dd410/debugpy-1.8.17-cp311-cp311-win32.whl", hash = "sha256:e79a195f9e059edfe5d8bf6f3749b2599452d3e9380484cd261f6b7cd2c7c4da", size = 5155078, upload-time = "2025-09-17T16:33:33.331Z" }, + { url = "https://files.pythonhosted.org/packages/c2/c5/c012c60a2922cc91caa9675d0ddfbb14ba59e1e36228355f41cab6483469/debugpy-1.8.17-cp311-cp311-win_amd64.whl", hash = "sha256:b532282ad4eca958b1b2d7dbcb2b7218e02cb934165859b918e3b6ba7772d3f4", size = 5179011, upload-time = "2025-09-17T16:33:35.711Z" }, + { url = "https://files.pythonhosted.org/packages/08/2b/9d8e65beb2751876c82e1aceb32f328c43ec872711fa80257c7674f45650/debugpy-1.8.17-cp312-cp312-macosx_15_0_universal2.whl", hash = "sha256:f14467edef672195c6f6b8e27ce5005313cb5d03c9239059bc7182b60c176e2d", size = 2549522, upload-time = "2025-09-17T16:33:38.466Z" }, + { url = "https://files.pythonhosted.org/packages/b4/78/eb0d77f02971c05fca0eb7465b18058ba84bd957062f5eec82f941ac792a/debugpy-1.8.17-cp312-cp312-manylinux_2_34_x86_64.whl", hash = "sha256:24693179ef9dfa20dca8605905a42b392be56d410c333af82f1c5dff807a64cc", size = 4309417, upload-time = "2025-09-17T16:33:41.299Z" }, + { url = "https://files.pythonhosted.org/packages/37/42/c40f1d8cc1fed1e75ea54298a382395b8b937d923fcf41ab0797a554f555/debugpy-1.8.17-cp312-cp312-win32.whl", hash = "sha256:6a4e9dacf2cbb60d2514ff7b04b4534b0139facbf2abdffe0639ddb6088e59cf", size = 5277130, upload-time = "2025-09-17T16:33:43.554Z" }, + { url = "https://files.pythonhosted.org/packages/72/22/84263b205baad32b81b36eac076de0cdbe09fe2d0637f5b32243dc7c925b/debugpy-1.8.17-cp312-cp312-win_amd64.whl", hash = "sha256:e8f8f61c518952fb15f74a302e068b48d9c4691768ade433e4adeea961993464", size = 5319053, upload-time = "2025-09-17T16:33:53.033Z" }, + { url = "https://files.pythonhosted.org/packages/50/76/597e5cb97d026274ba297af8d89138dfd9e695767ba0e0895edb20963f40/debugpy-1.8.17-cp313-cp313-macosx_15_0_universal2.whl", hash = "sha256:857c1dd5d70042502aef1c6d1c2801211f3ea7e56f75e9c335f434afb403e464", size = 2538386, upload-time = "2025-09-17T16:33:54.594Z" }, + { url = "https://files.pythonhosted.org/packages/5f/60/ce5c34fcdfec493701f9d1532dba95b21b2f6394147234dce21160bd923f/debugpy-1.8.17-cp313-cp313-manylinux_2_34_x86_64.whl", hash = "sha256:3bea3b0b12f3946e098cce9b43c3c46e317b567f79570c3f43f0b96d00788088", size = 4292100, upload-time = "2025-09-17T16:33:56.353Z" }, + { url = "https://files.pythonhosted.org/packages/e8/95/7873cf2146577ef71d2a20bf553f12df865922a6f87b9e8ee1df04f01785/debugpy-1.8.17-cp313-cp313-win32.whl", hash = "sha256:e34ee844c2f17b18556b5bbe59e1e2ff4e86a00282d2a46edab73fd7f18f4a83", size = 5277002, upload-time = "2025-09-17T16:33:58.231Z" }, + { url = "https://files.pythonhosted.org/packages/46/11/18c79a1cee5ff539a94ec4aa290c1c069a5580fd5cfd2fb2e282f8e905da/debugpy-1.8.17-cp313-cp313-win_amd64.whl", hash = "sha256:6c5cd6f009ad4fca8e33e5238210dc1e5f42db07d4b6ab21ac7ffa904a196420", size = 5319047, upload-time = "2025-09-17T16:34:00.586Z" }, + { url = "https://files.pythonhosted.org/packages/de/45/115d55b2a9da6de812696064ceb505c31e952c5d89c4ed1d9bb983deec34/debugpy-1.8.17-cp314-cp314-macosx_15_0_universal2.whl", hash = "sha256:045290c010bcd2d82bc97aa2daf6837443cd52f6328592698809b4549babcee1", size = 2536899, upload-time = "2025-09-17T16:34:02.657Z" }, + { url = "https://files.pythonhosted.org/packages/5a/73/2aa00c7f1f06e997ef57dc9b23d61a92120bec1437a012afb6d176585197/debugpy-1.8.17-cp314-cp314-manylinux_2_34_x86_64.whl", hash = "sha256:b69b6bd9dba6a03632534cdf67c760625760a215ae289f7489a452af1031fe1f", size = 4268254, upload-time = "2025-09-17T16:34:04.486Z" }, + { url = "https://files.pythonhosted.org/packages/86/b5/ed3e65c63c68a6634e3ba04bd10255c8e46ec16ebed7d1c79e4816d8a760/debugpy-1.8.17-cp314-cp314-win32.whl", hash = "sha256:5c59b74aa5630f3a5194467100c3b3d1c77898f9ab27e3f7dc5d40fc2f122670", size = 5277203, upload-time = "2025-09-17T16:34:06.65Z" }, + { url = "https://files.pythonhosted.org/packages/b0/26/394276b71c7538445f29e792f589ab7379ae70fd26ff5577dfde71158e96/debugpy-1.8.17-cp314-cp314-win_amd64.whl", hash = "sha256:893cba7bb0f55161de4365584b025f7064e1f88913551bcd23be3260b231429c", size = 5318493, upload-time = "2025-09-17T16:34:08.483Z" }, + { url = "https://files.pythonhosted.org/packages/b0/d0/89247ec250369fc76db477720a26b2fce7ba079ff1380e4ab4529d2fe233/debugpy-1.8.17-py2.py3-none-any.whl", hash = "sha256:60c7dca6571efe660ccb7a9508d73ca14b8796c4ed484c2002abba714226cfef", size = 5283210, upload-time = "2025-09-17T16:34:25.835Z" }, +] + +[[package]] +name = "decorator" +version = "5.2.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/43/fa/6d96a0978d19e17b68d634497769987b16c8f4cd0a7a05048bec693caa6b/decorator-5.2.1.tar.gz", hash = "sha256:65f266143752f734b0a7cc83c46f4618af75b8c5911b00ccb61d0ac9b6da0360", size = 56711, upload-time = "2025-02-24T04:41:34.073Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4e/8c/f3147f5c4b73e7550fe5f9352eaa956ae838d5c51eb58e7a25b9f3e2643b/decorator-5.2.1-py3-none-any.whl", hash = "sha256:d316bb415a2d9e2d2b3abcc4084c6502fc09240e292cd76a76afc106a1c8e04a", size = 9190, upload-time = "2025-02-24T04:41:32.565Z" }, +] + +[[package]] +name = "executing" +version = "2.2.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/cc/28/c14e053b6762b1044f34a13aab6859bbf40456d37d23aa286ac24cfd9a5d/executing-2.2.1.tar.gz", hash = "sha256:3632cc370565f6648cc328b32435bd120a1e4ebb20c77e3fdde9a13cd1e533c4", size = 1129488, upload-time = "2025-09-01T09:48:10.866Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c1/ea/53f2148663b321f21b5a606bd5f191517cf40b7072c0497d3c92c4a13b1e/executing-2.2.1-py2.py3-none-any.whl", hash = "sha256:760643d3452b4d777d295bb167ccc74c64a81df23fb5e08eff250c425a4b2017", size = 28317, upload-time = "2025-09-01T09:48:08.5Z" }, +] + [[package]] name = "flatbuffers" version = "25.9.23" @@ -570,6 +710,76 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/76/c6/c88e154df9c4e1a2a66ccf0005a88dfb2650c1dffb6f5ce603dfbd452ce3/idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3", size = 70442, upload-time = "2024-09-15T18:07:37.964Z" }, ] +[[package]] +name = "ipykernel" +version = "6.30.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "appnope", marker = "sys_platform == 'darwin'" }, + { name = "comm" }, + { name = "debugpy" }, + { name = "ipython" }, + { name = "jupyter-client" }, + { name = "jupyter-core" }, + { name = "matplotlib-inline" }, + { name = "nest-asyncio" }, + { name = "packaging" }, + { name = "psutil" }, + { name = "pyzmq" }, + { name = "tornado" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/bb/76/11082e338e0daadc89c8ff866185de11daf67d181901038f9e139d109761/ipykernel-6.30.1.tar.gz", hash = "sha256:6abb270161896402e76b91394fcdce5d1be5d45f456671e5080572f8505be39b", size = 166260, upload-time = "2025-08-04T15:47:35.018Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fc/c7/b445faca8deb954fe536abebff4ece5b097b923de482b26e78448c89d1dd/ipykernel-6.30.1-py3-none-any.whl", hash = "sha256:aa6b9fb93dca949069d8b85b6c79b2518e32ac583ae9c7d37c51d119e18b3fb4", size = 117484, upload-time = "2025-08-04T15:47:32.622Z" }, +] + +[[package]] +name = "ipython" +version = "9.6.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "decorator" }, + { name = "ipython-pygments-lexers" }, + { name = "jedi" }, + { name = "matplotlib-inline" }, + { name = "pexpect", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, + { name = "prompt-toolkit" }, + { name = "pygments" }, + { name = "stack-data" }, + { name = "traitlets" }, + { name = "typing-extensions", marker = "python_full_version < '3.12'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/2a/34/29b18c62e39ee2f7a6a3bba7efd952729d8aadd45ca17efc34453b717665/ipython-9.6.0.tar.gz", hash = "sha256:5603d6d5d356378be5043e69441a072b50a5b33b4503428c77b04cb8ce7bc731", size = 4396932, upload-time = "2025-09-29T10:55:53.948Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/48/c5/d5e07995077e48220269c28a221e168c91123ad5ceee44d548f54a057fc0/ipython-9.6.0-py3-none-any.whl", hash = "sha256:5f77efafc886d2f023442479b8149e7d86547ad0a979e9da9f045d252f648196", size = 616170, upload-time = "2025-09-29T10:55:47.676Z" }, +] + +[[package]] +name = "ipython-pygments-lexers" +version = "1.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ef/4c/5dd1d8af08107f88c7f741ead7a40854b8ac24ddf9ae850afbcf698aa552/ipython_pygments_lexers-1.1.1.tar.gz", hash = "sha256:09c0138009e56b6854f9535736f4171d855c8c08a563a0dcd8022f78355c7e81", size = 8393, upload-time = "2025-01-17T11:24:34.505Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d9/33/1f075bf72b0b747cb3288d011319aaf64083cf2efef8354174e3ed4540e2/ipython_pygments_lexers-1.1.1-py3-none-any.whl", hash = "sha256:a9462224a505ade19a605f71f8fa63c2048833ce50abc86768a0d81d876dc81c", size = 8074, upload-time = "2025-01-17T11:24:33.271Z" }, +] + +[[package]] +name = "jedi" +version = "0.19.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "parso" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/72/3a/79a912fbd4d8dd6fbb02bf69afd3bb72cf0c729bb3063c6f4498603db17a/jedi-0.19.2.tar.gz", hash = "sha256:4770dc3de41bde3966b02eb84fbcf557fb33cce26ad23da12c742fb50ecb11f0", size = 1231287, upload-time = "2024-11-11T01:41:42.873Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c0/5a/9cac0c82afec3d09ccd97c8b6502d48f165f9124db81b4bcb90b4af974ee/jedi-0.19.2-py2.py3-none-any.whl", hash = "sha256:a8ef22bde8490f57fe5c7681a3c83cb58874daf72b4784de3cce5b6ef6edb5b9", size = 1572278, upload-time = "2024-11-11T01:41:40.175Z" }, +] + [[package]] name = "jinja2" version = "3.1.6" @@ -618,6 +828,36 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/41/45/1a4ed80516f02155c51f51e8cedb3c1902296743db0bbc66608a0db2814f/jsonschema_specifications-2025.9.1-py3-none-any.whl", hash = "sha256:98802fee3a11ee76ecaca44429fda8a41bff98b00a0f2838151b113f210cc6fe", size = 18437, upload-time = "2025-09-08T01:34:57.871Z" }, ] +[[package]] +name = "jupyter-client" +version = "8.6.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-core" }, + { name = "python-dateutil" }, + { name = "pyzmq" }, + { name = "tornado" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/71/22/bf9f12fdaeae18019a468b68952a60fe6dbab5d67cd2a103cac7659b41ca/jupyter_client-8.6.3.tar.gz", hash = "sha256:35b3a0947c4a6e9d589eb97d7d4cd5e90f910ee73101611f01283732bd6d9419", size = 342019, upload-time = "2024-09-17T10:44:17.613Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/11/85/b0394e0b6fcccd2c1eeefc230978a6f8cb0c5df1e4cd3e7625735a0d7d1e/jupyter_client-8.6.3-py3-none-any.whl", hash = "sha256:e8a19cc986cc45905ac3362915f410f3af85424b4c0905e94fa5f2cb08e8f23f", size = 106105, upload-time = "2024-09-17T10:44:15.218Z" }, +] + +[[package]] +name = "jupyter-core" +version = "5.8.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "platformdirs" }, + { name = "pywin32", marker = "platform_python_implementation != 'PyPy' and sys_platform == 'win32'" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/99/1b/72906d554acfeb588332eaaa6f61577705e9ec752ddb486f302dafa292d9/jupyter_core-5.8.1.tar.gz", hash = "sha256:0a5f9706f70e64786b75acba995988915ebd4601c8a52e534a40b51c95f59941", size = 88923, upload-time = "2025-05-27T07:38:16.655Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2f/57/6bffd4b20b88da3800c5d691e0337761576ee688eb01299eae865689d2df/jupyter_core-5.8.1-py3-none-any.whl", hash = "sha256:c28d268fc90fb53f1338ded2eb410704c5449a358406e8a948b75706e24863d0", size = 28880, upload-time = "2025-05-27T07:38:15.137Z" }, +] + [[package]] name = "keras" version = "3.11.3" @@ -994,6 +1234,18 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/16/53/8d8fa0ea32a8c8239e04d022f6c059ee5e1b77517769feccd50f1df43d6d/matplotlib-3.10.6-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4d6ca6ef03dfd269f4ead566ec6f3fb9becf8dab146fb999022ed85ee9f6b3eb", size = 8693933, upload-time = "2025-08-30T00:14:22.942Z" }, ] +[[package]] +name = "matplotlib-inline" +version = "0.1.7" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/99/5b/a36a337438a14116b16480db471ad061c36c3694df7c2084a0da7ba538b7/matplotlib_inline-0.1.7.tar.gz", hash = "sha256:8423b23ec666be3d16e16b60bdd8ac4e86e840ebd1dd11a30b9f117f2fa0ab90", size = 8159, upload-time = "2024-04-15T13:44:44.803Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8f/8e/9ad090d3553c280a8060fbf6e24dc1c0c29704ee7d1c372f0c174aa59285/matplotlib_inline-0.1.7-py3-none-any.whl", hash = "sha256:df192d39a4ff8f21b1895d72e6a13f5fcc5099f00fa84384e0ea28c2cc0653ca", size = 9899, upload-time = "2024-04-15T13:44:43.265Z" }, +] + [[package]] name = "mdurl" version = "0.1.2" @@ -1076,6 +1328,7 @@ dependencies = [ { name = "joblib" }, { name = "lightgbm" }, { name = "matplotlib" }, + { name = "networkx" }, { name = "numpy" }, { name = "ollama" }, { name = "pandas" }, @@ -1095,6 +1348,7 @@ dependencies = [ [package.dev-dependencies] dev = [ + { name = "ipykernel" }, { name = "ruff" }, ] @@ -1104,6 +1358,7 @@ requires-dist = [ { name = "joblib", specifier = ">=1.5.2" }, { name = "lightgbm", specifier = ">=4.6.0" }, { name = "matplotlib", specifier = ">=3.10.6" }, + { name = "networkx", specifier = ">=3.5" }, { name = "numpy", specifier = ">=2.3.3" }, { name = "ollama", specifier = ">=0.6.0" }, { name = "pandas", specifier = ">=2.3.3" }, @@ -1122,7 +1377,28 @@ requires-dist = [ ] [package.metadata.requires-dev] -dev = [{ name = "ruff", specifier = ">=0.13.3" }] +dev = [ + { name = "ipykernel", specifier = ">=6.30.1" }, + { name = "ruff", specifier = ">=0.13.3" }, +] + +[[package]] +name = "nest-asyncio" +version = "1.6.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/83/f8/51569ac65d696c8ecbee95938f89d4abf00f47d58d48f6fbabfe8f0baefe/nest_asyncio-1.6.0.tar.gz", hash = "sha256:6f172d5449aca15afd6c646851f4e31e02c598d553a667e38cafa997cfec55fe", size = 7418, upload-time = "2024-01-21T14:25:19.227Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a0/c4/c2971a3ba4c6103a3d10c4b0f24f461ddc027f0f09763220cf35ca1401b3/nest_asyncio-1.6.0-py3-none-any.whl", hash = "sha256:87af6efd6b5e897c81050477ef65c62e2b2f35d51703cae01aff2905b1852e1c", size = 5195, upload-time = "2024-01-21T14:25:17.223Z" }, +] + +[[package]] +name = "networkx" +version = "3.5" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6c/4f/ccdb8ad3a38e583f214547fd2f7ff1fc160c43a75af88e6aec213404b96a/networkx-3.5.tar.gz", hash = "sha256:d4c6f9cf81f52d69230866796b82afbccdec3db7ae4fbd1b65ea750feed50037", size = 2471065, upload-time = "2025-05-29T11:35:07.804Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/eb/8d/776adee7bbf76365fdd7f2552710282c79a4ead5d2a46408c9043a2b70ba/networkx-3.5-py3-none-any.whl", hash = "sha256:0030d386a9a06dee3565298b4a734b68589749a544acbb6c412dc9e2489ec6ec", size = 2034406, upload-time = "2025-05-29T11:35:04.961Z" }, +] [[package]] name = "numpy" @@ -1331,6 +1607,27 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/70/44/5191d2e4026f86a2a109053e194d3ba7a31a2d10a9c2348368c63ed4e85a/pandas-2.3.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:3869faf4bd07b3b66a9f462417d0ca3a9df29a9f6abd5d0d0dbab15dac7abe87", size = 13202175, upload-time = "2025-09-29T23:31:59.173Z" }, ] +[[package]] +name = "parso" +version = "0.8.5" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d4/de/53e0bcf53d13e005bd8c92e7855142494f41171b34c2536b86187474184d/parso-0.8.5.tar.gz", hash = "sha256:034d7354a9a018bdce352f48b2a8a450f05e9d6ee85db84764e9b6bd96dafe5a", size = 401205, upload-time = "2025-08-23T15:15:28.028Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/16/32/f8e3c85d1d5250232a5d3477a2a28cc291968ff175caeadaf3cc19ce0e4a/parso-0.8.5-py2.py3-none-any.whl", hash = "sha256:646204b5ee239c396d040b90f9e272e9a8017c630092bf59980beb62fd033887", size = 106668, upload-time = "2025-08-23T15:15:25.663Z" }, +] + +[[package]] +name = "pexpect" +version = "4.9.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ptyprocess" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/42/92/cc564bf6381ff43ce1f4d06852fc19a2f11d180f23dc32d9588bee2f149d/pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f", size = 166450, upload-time = "2023-11-25T09:07:26.339Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9e/c3/059298687310d527a58bb01f3b1965787ee3b40dce76752eda8b44e9a2c5/pexpect-4.9.0-py2.py3-none-any.whl", hash = "sha256:7236d1e080e4936be2dc3e326cec0af72acf9212a7e1d060210e70a47e253523", size = 63772, upload-time = "2023-11-25T06:56:14.81Z" }, +] + [[package]] name = "pillow" version = "11.3.0" @@ -1415,6 +1712,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/34/e7/ae39f538fd6844e982063c3a5e4598b8ced43b9633baa3a85ef33af8c05c/pillow-11.3.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:c84d689db21a1c397d001aa08241044aa2069e7587b398c8cc63020390b1c1b8", size = 6984598, upload-time = "2025-07-01T09:16:27.732Z" }, ] +[[package]] +name = "platformdirs" +version = "4.4.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/23/e8/21db9c9987b0e728855bd57bff6984f67952bea55d6f75e055c46b5383e8/platformdirs-4.4.0.tar.gz", hash = "sha256:ca753cf4d81dc309bc67b0ea38fd15dc97bc30ce419a7f58d13eb3bf14c4febf", size = 21634, upload-time = "2025-08-26T14:32:04.268Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/40/4b/2028861e724d3bd36227adfa20d3fd24c3fc6d52032f4a93c133be5d17ce/platformdirs-4.4.0-py3-none-any.whl", hash = "sha256:abd01743f24e5287cd7a5db3752faf1a2d65353f38ec26d98e25a6db65958c85", size = 18654, upload-time = "2025-08-26T14:32:02.735Z" }, +] + [[package]] name = "plotly" version = "6.3.1" @@ -1461,6 +1767,18 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/fa/8c/d3e30f80b2ef21f267f09f0b7d18995adccc928ede5b73ea3fe54e1303f4/preshed-3.0.10-cp313-cp313-win_amd64.whl", hash = "sha256:97e0e2edfd25a7dfba799b49b3c5cc248ad0318a76edd9d5fd2c82aa3d5c64ed", size = 115769, upload-time = "2025-05-26T15:18:21.842Z" }, ] +[[package]] +name = "prompt-toolkit" +version = "3.0.52" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "wcwidth" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a1/96/06e01a7b38dce6fe1db213e061a4602dd6032a8a97ef6c1a862537732421/prompt_toolkit-3.0.52.tar.gz", hash = "sha256:28cde192929c8e7321de85de1ddbe736f1375148b02f2e17edd840042b1be855", size = 434198, upload-time = "2025-08-27T15:24:02.057Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/84/03/0d3ce49e2505ae70cf43bc5bb3033955d2fc9f932163e84dc0779cc47f48/prompt_toolkit-3.0.52-py3-none-any.whl", hash = "sha256:9aac639a3bbd33284347de5ad8d68ecc044b91a762dc39b7c21095fcd6a19955", size = 391431, upload-time = "2025-08-27T15:23:59.498Z" }, +] + [[package]] name = "protobuf" version = "6.32.1" @@ -1491,6 +1809,24 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/26/65/1070a6e3c036f39142c2820c4b52e9243246fcfc3f96239ac84472ba361e/psutil-7.1.0-cp37-abi3-win_arm64.whl", hash = "sha256:6937cb68133e7c97b6cc9649a570c9a18ba0efebed46d8c5dae4c07fa1b67a07", size = 244971, upload-time = "2025-09-17T20:15:12.262Z" }, ] +[[package]] +name = "ptyprocess" +version = "0.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/20/e5/16ff212c1e452235a90aeb09066144d0c5a6a8c0834397e03f5224495c4e/ptyprocess-0.7.0.tar.gz", hash = "sha256:5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220", size = 70762, upload-time = "2020-12-28T15:15:30.155Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/22/a6/858897256d0deac81a172289110f31629fc4cee19b6f01283303e18c8db3/ptyprocess-0.7.0-py2.py3-none-any.whl", hash = "sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35", size = 13993, upload-time = "2020-12-28T15:15:28.35Z" }, +] + +[[package]] +name = "pure-eval" +version = "0.2.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/cd/05/0a34433a064256a578f1783a10da6df098ceaa4a57bbeaa96a6c0352786b/pure_eval-0.2.3.tar.gz", hash = "sha256:5f4e983f40564c576c7c8635ae88db5956bb2229d7e9237d03b3c0b0190eaf42", size = 19752, upload-time = "2024-07-21T12:58:21.801Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8e/37/efad0257dc6e593a18957422533ff0f87ede7c9c6ea010a2177d738fb82f/pure_eval-0.2.3-py3-none-any.whl", hash = "sha256:1db8e35b67b3d218d818ae653e27f06c3aa420901fa7b081ca98cbedc874e0d0", size = 11842, upload-time = "2024-07-21T12:58:20.04Z" }, +] + [[package]] name = "pyarrow" version = "21.0.0" @@ -1527,6 +1863,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/e5/4e/519c1bc1876625fe6b71e9a28287c43ec2f20f73c658b9ae1d485c0c206e/pyarrow-21.0.0-cp313-cp313t-win_amd64.whl", hash = "sha256:222c39e2c70113543982c6b34f3077962b44fca38c0bd9e68bb6781534425c10", size = 26371006, upload-time = "2025-07-18T00:56:56.379Z" }, ] +[[package]] +name = "pycparser" +version = "2.23" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/fe/cf/d2d3b9f5699fb1e4615c8e32ff220203e43b248e1dfcc6736ad9057731ca/pycparser-2.23.tar.gz", hash = "sha256:78816d4f24add8f10a06d6f05b4d424ad9e96cfebf68a4ddc99c65c0720d00c2", size = 173734, upload-time = "2025-09-09T13:23:47.91Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a0/e3/59cd50310fc9b59512193629e1984c1f95e5c8ae6e5d8c69532ccc65a7fe/pycparser-2.23-py3-none-any.whl", hash = "sha256:e5c6e8d3fbad53479cab09ac03729e0a9faf2bee3db8208a550daf5af81a5934", size = 118140, upload-time = "2025-09-09T13:23:46.651Z" }, +] + [[package]] name = "pydantic" version = "2.11.10" @@ -1755,6 +2100,25 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/81/c4/34e93fe5f5429d7570ec1fa436f1986fb1f00c3e0f43a589fe2bbcd22c3f/pytz-2025.2-py2.py3-none-any.whl", hash = "sha256:5ddf76296dd8c44c26eb8f4b6f35488f3ccbf6fbbd7adee0b7262d43f0ec2f00", size = 509225, upload-time = "2025-03-25T02:24:58.468Z" }, ] +[[package]] +name = "pywin32" +version = "311" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7c/af/449a6a91e5d6db51420875c54f6aff7c97a86a3b13a0b4f1a5c13b988de3/pywin32-311-cp311-cp311-win32.whl", hash = "sha256:184eb5e436dea364dcd3d2316d577d625c0351bf237c4e9a5fabbcfa5a58b151", size = 8697031, upload-time = "2025-07-14T20:13:13.266Z" }, + { url = "https://files.pythonhosted.org/packages/51/8f/9bb81dd5bb77d22243d33c8397f09377056d5c687aa6d4042bea7fbf8364/pywin32-311-cp311-cp311-win_amd64.whl", hash = "sha256:3ce80b34b22b17ccbd937a6e78e7225d80c52f5ab9940fe0506a1a16f3dab503", size = 9508308, upload-time = "2025-07-14T20:13:15.147Z" }, + { url = "https://files.pythonhosted.org/packages/44/7b/9c2ab54f74a138c491aba1b1cd0795ba61f144c711daea84a88b63dc0f6c/pywin32-311-cp311-cp311-win_arm64.whl", hash = "sha256:a733f1388e1a842abb67ffa8e7aad0e70ac519e09b0f6a784e65a136ec7cefd2", size = 8703930, upload-time = "2025-07-14T20:13:16.945Z" }, + { url = "https://files.pythonhosted.org/packages/e7/ab/01ea1943d4eba0f850c3c61e78e8dd59757ff815ff3ccd0a84de5f541f42/pywin32-311-cp312-cp312-win32.whl", hash = "sha256:750ec6e621af2b948540032557b10a2d43b0cee2ae9758c54154d711cc852d31", size = 8706543, upload-time = "2025-07-14T20:13:20.765Z" }, + { url = "https://files.pythonhosted.org/packages/d1/a8/a0e8d07d4d051ec7502cd58b291ec98dcc0c3fff027caad0470b72cfcc2f/pywin32-311-cp312-cp312-win_amd64.whl", hash = "sha256:b8c095edad5c211ff31c05223658e71bf7116daa0ecf3ad85f3201ea3190d067", size = 9495040, upload-time = "2025-07-14T20:13:22.543Z" }, + { url = "https://files.pythonhosted.org/packages/ba/3a/2ae996277b4b50f17d61f0603efd8253cb2d79cc7ae159468007b586396d/pywin32-311-cp312-cp312-win_arm64.whl", hash = "sha256:e286f46a9a39c4a18b319c28f59b61de793654af2f395c102b4f819e584b5852", size = 8710102, upload-time = "2025-07-14T20:13:24.682Z" }, + { url = "https://files.pythonhosted.org/packages/a5/be/3fd5de0979fcb3994bfee0d65ed8ca9506a8a1260651b86174f6a86f52b3/pywin32-311-cp313-cp313-win32.whl", hash = "sha256:f95ba5a847cba10dd8c4d8fefa9f2a6cf283b8b88ed6178fa8a6c1ab16054d0d", size = 8705700, upload-time = "2025-07-14T20:13:26.471Z" }, + { url = "https://files.pythonhosted.org/packages/e3/28/e0a1909523c6890208295a29e05c2adb2126364e289826c0a8bc7297bd5c/pywin32-311-cp313-cp313-win_amd64.whl", hash = "sha256:718a38f7e5b058e76aee1c56ddd06908116d35147e133427e59a3983f703a20d", size = 9494700, upload-time = "2025-07-14T20:13:28.243Z" }, + { url = "https://files.pythonhosted.org/packages/04/bf/90339ac0f55726dce7d794e6d79a18a91265bdf3aa70b6b9ca52f35e022a/pywin32-311-cp313-cp313-win_arm64.whl", hash = "sha256:7b4075d959648406202d92a2310cb990fea19b535c7f4a78d3f5e10b926eeb8a", size = 8709318, upload-time = "2025-07-14T20:13:30.348Z" }, + { url = "https://files.pythonhosted.org/packages/c9/31/097f2e132c4f16d99a22bfb777e0fd88bd8e1c634304e102f313af69ace5/pywin32-311-cp314-cp314-win32.whl", hash = "sha256:b7a2c10b93f8986666d0c803ee19b5990885872a7de910fc460f9b0c2fbf92ee", size = 8840714, upload-time = "2025-07-14T20:13:32.449Z" }, + { url = "https://files.pythonhosted.org/packages/90/4b/07c77d8ba0e01349358082713400435347df8426208171ce297da32c313d/pywin32-311-cp314-cp314-win_amd64.whl", hash = "sha256:3aca44c046bd2ed8c90de9cb8427f581c479e594e99b5c0bb19b29c10fd6cb87", size = 9656800, upload-time = "2025-07-14T20:13:34.312Z" }, + { url = "https://files.pythonhosted.org/packages/c0/d2/21af5c535501a7233e734b8af901574572da66fcc254cb35d0609c9080dd/pywin32-311-cp314-cp314-win_arm64.whl", hash = "sha256:a508e2d9025764a8270f93111a970e1d0fbfc33f4153b388bb649b7eec4f9b42", size = 8932540, upload-time = "2025-07-14T20:13:36.379Z" }, +] + [[package]] name = "pyyaml" version = "6.0.3" @@ -1810,6 +2174,64 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" }, ] +[[package]] +name = "pyzmq" +version = "27.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi", marker = "implementation_name == 'pypy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/04/0b/3c9baedbdf613ecaa7aa07027780b8867f57b6293b6ee50de316c9f3222b/pyzmq-27.1.0.tar.gz", hash = "sha256:ac0765e3d44455adb6ddbf4417dcce460fc40a05978c08efdf2948072f6db540", size = 281750, upload-time = "2025-09-08T23:10:18.157Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/06/5d/305323ba86b284e6fcb0d842d6adaa2999035f70f8c38a9b6d21ad28c3d4/pyzmq-27.1.0-cp311-cp311-macosx_10_15_universal2.whl", hash = "sha256:226b091818d461a3bef763805e75685e478ac17e9008f49fce2d3e52b3d58b86", size = 1333328, upload-time = "2025-09-08T23:07:45.946Z" }, + { url = "https://files.pythonhosted.org/packages/bd/a0/fc7e78a23748ad5443ac3275943457e8452da67fda347e05260261108cbc/pyzmq-27.1.0-cp311-cp311-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:0790a0161c281ca9723f804871b4027f2e8b5a528d357c8952d08cd1a9c15581", size = 908803, upload-time = "2025-09-08T23:07:47.551Z" }, + { url = "https://files.pythonhosted.org/packages/7e/22/37d15eb05f3bdfa4abea6f6d96eb3bb58585fbd3e4e0ded4e743bc650c97/pyzmq-27.1.0-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c895a6f35476b0c3a54e3eb6ccf41bf3018de937016e6e18748317f25d4e925f", size = 668836, upload-time = "2025-09-08T23:07:49.436Z" }, + { url = "https://files.pythonhosted.org/packages/b1/c4/2a6fe5111a01005fc7af3878259ce17684fabb8852815eda6225620f3c59/pyzmq-27.1.0-cp311-cp311-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5bbf8d3630bf96550b3be8e1fc0fea5cbdc8d5466c1192887bd94869da17a63e", size = 857038, upload-time = "2025-09-08T23:07:51.234Z" }, + { url = "https://files.pythonhosted.org/packages/cb/eb/bfdcb41d0db9cd233d6fb22dc131583774135505ada800ebf14dfb0a7c40/pyzmq-27.1.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:15c8bd0fe0dabf808e2d7a681398c4e5ded70a551ab47482067a572c054c8e2e", size = 1657531, upload-time = "2025-09-08T23:07:52.795Z" }, + { url = "https://files.pythonhosted.org/packages/ab/21/e3180ca269ed4a0de5c34417dfe71a8ae80421198be83ee619a8a485b0c7/pyzmq-27.1.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:bafcb3dd171b4ae9f19ee6380dfc71ce0390fefaf26b504c0e5f628d7c8c54f2", size = 2034786, upload-time = "2025-09-08T23:07:55.047Z" }, + { url = "https://files.pythonhosted.org/packages/3b/b1/5e21d0b517434b7f33588ff76c177c5a167858cc38ef740608898cd329f2/pyzmq-27.1.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:e829529fcaa09937189178115c49c504e69289abd39967cd8a4c215761373394", size = 1894220, upload-time = "2025-09-08T23:07:57.172Z" }, + { url = "https://files.pythonhosted.org/packages/03/f2/44913a6ff6941905efc24a1acf3d3cb6146b636c546c7406c38c49c403d4/pyzmq-27.1.0-cp311-cp311-win32.whl", hash = "sha256:6df079c47d5902af6db298ec92151db82ecb557af663098b92f2508c398bb54f", size = 567155, upload-time = "2025-09-08T23:07:59.05Z" }, + { url = "https://files.pythonhosted.org/packages/23/6d/d8d92a0eb270a925c9b4dd039c0b4dc10abc2fcbc48331788824ef113935/pyzmq-27.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:190cbf120fbc0fc4957b56866830def56628934a9d112aec0e2507aa6a032b97", size = 633428, upload-time = "2025-09-08T23:08:00.663Z" }, + { url = "https://files.pythonhosted.org/packages/ae/14/01afebc96c5abbbd713ecfc7469cfb1bc801c819a74ed5c9fad9a48801cb/pyzmq-27.1.0-cp311-cp311-win_arm64.whl", hash = "sha256:eca6b47df11a132d1745eb3b5b5e557a7dae2c303277aa0e69c6ba91b8736e07", size = 559497, upload-time = "2025-09-08T23:08:02.15Z" }, + { url = "https://files.pythonhosted.org/packages/92/e7/038aab64a946d535901103da16b953c8c9cc9c961dadcbf3609ed6428d23/pyzmq-27.1.0-cp312-abi3-macosx_10_15_universal2.whl", hash = "sha256:452631b640340c928fa343801b0d07eb0c3789a5ffa843f6e1a9cee0ba4eb4fc", size = 1306279, upload-time = "2025-09-08T23:08:03.807Z" }, + { url = "https://files.pythonhosted.org/packages/e8/5e/c3c49fdd0f535ef45eefcc16934648e9e59dace4a37ee88fc53f6cd8e641/pyzmq-27.1.0-cp312-abi3-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:1c179799b118e554b66da67d88ed66cd37a169f1f23b5d9f0a231b4e8d44a113", size = 895645, upload-time = "2025-09-08T23:08:05.301Z" }, + { url = "https://files.pythonhosted.org/packages/f8/e5/b0b2504cb4e903a74dcf1ebae157f9e20ebb6ea76095f6cfffea28c42ecd/pyzmq-27.1.0-cp312-abi3-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3837439b7f99e60312f0c926a6ad437b067356dc2bc2ec96eb395fd0fe804233", size = 652574, upload-time = "2025-09-08T23:08:06.828Z" }, + { url = "https://files.pythonhosted.org/packages/f8/9b/c108cdb55560eaf253f0cbdb61b29971e9fb34d9c3499b0e96e4e60ed8a5/pyzmq-27.1.0-cp312-abi3-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:43ad9a73e3da1fab5b0e7e13402f0b2fb934ae1c876c51d0afff0e7c052eca31", size = 840995, upload-time = "2025-09-08T23:08:08.396Z" }, + { url = "https://files.pythonhosted.org/packages/c2/bb/b79798ca177b9eb0825b4c9998c6af8cd2a7f15a6a1a4272c1d1a21d382f/pyzmq-27.1.0-cp312-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:0de3028d69d4cdc475bfe47a6128eb38d8bc0e8f4d69646adfbcd840facbac28", size = 1642070, upload-time = "2025-09-08T23:08:09.989Z" }, + { url = "https://files.pythonhosted.org/packages/9c/80/2df2e7977c4ede24c79ae39dcef3899bfc5f34d1ca7a5b24f182c9b7a9ca/pyzmq-27.1.0-cp312-abi3-musllinux_1_2_i686.whl", hash = "sha256:cf44a7763aea9298c0aa7dbf859f87ed7012de8bda0f3977b6fb1d96745df856", size = 2021121, upload-time = "2025-09-08T23:08:11.907Z" }, + { url = "https://files.pythonhosted.org/packages/46/bd/2d45ad24f5f5ae7e8d01525eb76786fa7557136555cac7d929880519e33a/pyzmq-27.1.0-cp312-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:f30f395a9e6fbca195400ce833c731e7b64c3919aa481af4d88c3759e0cb7496", size = 1878550, upload-time = "2025-09-08T23:08:13.513Z" }, + { url = "https://files.pythonhosted.org/packages/e6/2f/104c0a3c778d7c2ab8190e9db4f62f0b6957b53c9d87db77c284b69f33ea/pyzmq-27.1.0-cp312-abi3-win32.whl", hash = "sha256:250e5436a4ba13885494412b3da5d518cd0d3a278a1ae640e113c073a5f88edd", size = 559184, upload-time = "2025-09-08T23:08:15.163Z" }, + { url = "https://files.pythonhosted.org/packages/fc/7f/a21b20d577e4100c6a41795842028235998a643b1ad406a6d4163ea8f53e/pyzmq-27.1.0-cp312-abi3-win_amd64.whl", hash = "sha256:9ce490cf1d2ca2ad84733aa1d69ce6855372cb5ce9223802450c9b2a7cba0ccf", size = 619480, upload-time = "2025-09-08T23:08:17.192Z" }, + { url = "https://files.pythonhosted.org/packages/78/c2/c012beae5f76b72f007a9e91ee9401cb88c51d0f83c6257a03e785c81cc2/pyzmq-27.1.0-cp312-abi3-win_arm64.whl", hash = "sha256:75a2f36223f0d535a0c919e23615fc85a1e23b71f40c7eb43d7b1dedb4d8f15f", size = 552993, upload-time = "2025-09-08T23:08:18.926Z" }, + { url = "https://files.pythonhosted.org/packages/60/cb/84a13459c51da6cec1b7b1dc1a47e6db6da50b77ad7fd9c145842750a011/pyzmq-27.1.0-cp313-cp313-android_24_arm64_v8a.whl", hash = "sha256:93ad4b0855a664229559e45c8d23797ceac03183c7b6f5b4428152a6b06684a5", size = 1122436, upload-time = "2025-09-08T23:08:20.801Z" }, + { url = "https://files.pythonhosted.org/packages/dc/b6/94414759a69a26c3dd674570a81813c46a078767d931a6c70ad29fc585cb/pyzmq-27.1.0-cp313-cp313-android_24_x86_64.whl", hash = "sha256:fbb4f2400bfda24f12f009cba62ad5734148569ff4949b1b6ec3b519444342e6", size = 1156301, upload-time = "2025-09-08T23:08:22.47Z" }, + { url = "https://files.pythonhosted.org/packages/a5/ad/15906493fd40c316377fd8a8f6b1f93104f97a752667763c9b9c1b71d42d/pyzmq-27.1.0-cp313-cp313t-macosx_10_15_universal2.whl", hash = "sha256:e343d067f7b151cfe4eb3bb796a7752c9d369eed007b91231e817071d2c2fec7", size = 1341197, upload-time = "2025-09-08T23:08:24.286Z" }, + { url = "https://files.pythonhosted.org/packages/14/1d/d343f3ce13db53a54cb8946594e567410b2125394dafcc0268d8dda027e0/pyzmq-27.1.0-cp313-cp313t-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:08363b2011dec81c354d694bdecaef4770e0ae96b9afea70b3f47b973655cc05", size = 897275, upload-time = "2025-09-08T23:08:26.063Z" }, + { url = "https://files.pythonhosted.org/packages/69/2d/d83dd6d7ca929a2fc67d2c3005415cdf322af7751d773524809f9e585129/pyzmq-27.1.0-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d54530c8c8b5b8ddb3318f481297441af102517602b569146185fa10b63f4fa9", size = 660469, upload-time = "2025-09-08T23:08:27.623Z" }, + { url = "https://files.pythonhosted.org/packages/3e/cd/9822a7af117f4bc0f1952dbe9ef8358eb50a24928efd5edf54210b850259/pyzmq-27.1.0-cp313-cp313t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6f3afa12c392f0a44a2414056d730eebc33ec0926aae92b5ad5cf26ebb6cc128", size = 847961, upload-time = "2025-09-08T23:08:29.672Z" }, + { url = "https://files.pythonhosted.org/packages/9a/12/f003e824a19ed73be15542f172fd0ec4ad0b60cf37436652c93b9df7c585/pyzmq-27.1.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:c65047adafe573ff023b3187bb93faa583151627bc9c51fc4fb2c561ed689d39", size = 1650282, upload-time = "2025-09-08T23:08:31.349Z" }, + { url = "https://files.pythonhosted.org/packages/d5/4a/e82d788ed58e9a23995cee70dbc20c9aded3d13a92d30d57ec2291f1e8a3/pyzmq-27.1.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:90e6e9441c946a8b0a667356f7078d96411391a3b8f80980315455574177ec97", size = 2024468, upload-time = "2025-09-08T23:08:33.543Z" }, + { url = "https://files.pythonhosted.org/packages/d9/94/2da0a60841f757481e402b34bf4c8bf57fa54a5466b965de791b1e6f747d/pyzmq-27.1.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:add071b2d25f84e8189aaf0882d39a285b42fa3853016ebab234a5e78c7a43db", size = 1885394, upload-time = "2025-09-08T23:08:35.51Z" }, + { url = "https://files.pythonhosted.org/packages/4f/6f/55c10e2e49ad52d080dc24e37adb215e5b0d64990b57598abc2e3f01725b/pyzmq-27.1.0-cp313-cp313t-win32.whl", hash = "sha256:7ccc0700cfdf7bd487bea8d850ec38f204478681ea02a582a8da8171b7f90a1c", size = 574964, upload-time = "2025-09-08T23:08:37.178Z" }, + { url = "https://files.pythonhosted.org/packages/87/4d/2534970ba63dd7c522d8ca80fb92777f362c0f321900667c615e2067cb29/pyzmq-27.1.0-cp313-cp313t-win_amd64.whl", hash = "sha256:8085a9fba668216b9b4323be338ee5437a235fe275b9d1610e422ccc279733e2", size = 641029, upload-time = "2025-09-08T23:08:40.595Z" }, + { url = "https://files.pythonhosted.org/packages/f6/fa/f8aea7a28b0641f31d40dea42d7ef003fded31e184ef47db696bc74cd610/pyzmq-27.1.0-cp313-cp313t-win_arm64.whl", hash = "sha256:6bb54ca21bcfe361e445256c15eedf083f153811c37be87e0514934d6913061e", size = 561541, upload-time = "2025-09-08T23:08:42.668Z" }, + { url = "https://files.pythonhosted.org/packages/87/45/19efbb3000956e82d0331bafca5d9ac19ea2857722fa2caacefb6042f39d/pyzmq-27.1.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:ce980af330231615756acd5154f29813d553ea555485ae712c491cd483df6b7a", size = 1341197, upload-time = "2025-09-08T23:08:44.973Z" }, + { url = "https://files.pythonhosted.org/packages/48/43/d72ccdbf0d73d1343936296665826350cb1e825f92f2db9db3e61c2162a2/pyzmq-27.1.0-cp314-cp314t-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:1779be8c549e54a1c38f805e56d2a2e5c009d26de10921d7d51cfd1c8d4632ea", size = 897175, upload-time = "2025-09-08T23:08:46.601Z" }, + { url = "https://files.pythonhosted.org/packages/2f/2e/a483f73a10b65a9ef0161e817321d39a770b2acf8bcf3004a28d90d14a94/pyzmq-27.1.0-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7200bb0f03345515df50d99d3db206a0a6bee1955fbb8c453c76f5bf0e08fb96", size = 660427, upload-time = "2025-09-08T23:08:48.187Z" }, + { url = "https://files.pythonhosted.org/packages/f5/d2/5f36552c2d3e5685abe60dfa56f91169f7a2d99bbaf67c5271022ab40863/pyzmq-27.1.0-cp314-cp314t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:01c0e07d558b06a60773744ea6251f769cd79a41a97d11b8bf4ab8f034b0424d", size = 847929, upload-time = "2025-09-08T23:08:49.76Z" }, + { url = "https://files.pythonhosted.org/packages/c4/2a/404b331f2b7bf3198e9945f75c4c521f0c6a3a23b51f7a4a401b94a13833/pyzmq-27.1.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:80d834abee71f65253c91540445d37c4c561e293ba6e741b992f20a105d69146", size = 1650193, upload-time = "2025-09-08T23:08:51.7Z" }, + { url = "https://files.pythonhosted.org/packages/1c/0b/f4107e33f62a5acf60e3ded67ed33d79b4ce18de432625ce2fc5093d6388/pyzmq-27.1.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:544b4e3b7198dde4a62b8ff6685e9802a9a1ebf47e77478a5eb88eca2a82f2fd", size = 2024388, upload-time = "2025-09-08T23:08:53.393Z" }, + { url = "https://files.pythonhosted.org/packages/0d/01/add31fe76512642fd6e40e3a3bd21f4b47e242c8ba33efb6809e37076d9b/pyzmq-27.1.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:cedc4c68178e59a4046f97eca31b148ddcf51e88677de1ef4e78cf06c5376c9a", size = 1885316, upload-time = "2025-09-08T23:08:55.702Z" }, + { url = "https://files.pythonhosted.org/packages/c4/59/a5f38970f9bf07cee96128de79590bb354917914a9be11272cfc7ff26af0/pyzmq-27.1.0-cp314-cp314t-win32.whl", hash = "sha256:1f0b2a577fd770aa6f053211a55d1c47901f4d537389a034c690291485e5fe92", size = 587472, upload-time = "2025-09-08T23:08:58.18Z" }, + { url = "https://files.pythonhosted.org/packages/70/d8/78b1bad170f93fcf5e3536e70e8fadac55030002275c9a29e8f5719185de/pyzmq-27.1.0-cp314-cp314t-win_amd64.whl", hash = "sha256:19c9468ae0437f8074af379e986c5d3d7d7bfe033506af442e8c879732bedbe0", size = 661401, upload-time = "2025-09-08T23:08:59.802Z" }, + { url = "https://files.pythonhosted.org/packages/81/d6/4bfbb40c9a0b42fc53c7cf442f6385db70b40f74a783130c5d0a5aa62228/pyzmq-27.1.0-cp314-cp314t-win_arm64.whl", hash = "sha256:dc5dbf68a7857b59473f7df42650c621d7e8923fb03fa74a526890f4d33cc4d7", size = 575170, upload-time = "2025-09-08T23:09:01.418Z" }, + { url = "https://files.pythonhosted.org/packages/4c/c6/c4dcdecdbaa70969ee1fdced6d7b8f60cfabe64d25361f27ac4665a70620/pyzmq-27.1.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:18770c8d3563715387139060d37859c02ce40718d1faf299abddcdcc6a649066", size = 836265, upload-time = "2025-09-08T23:09:49.376Z" }, + { url = "https://files.pythonhosted.org/packages/3e/79/f38c92eeaeb03a2ccc2ba9866f0439593bb08c5e3b714ac1d553e5c96e25/pyzmq-27.1.0-pp311-pypy311_pp73-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:ac25465d42f92e990f8d8b0546b01c391ad431c3bf447683fdc40565941d0604", size = 800208, upload-time = "2025-09-08T23:09:51.073Z" }, + { url = "https://files.pythonhosted.org/packages/49/0e/3f0d0d335c6b3abb9b7b723776d0b21fa7f3a6c819a0db6097059aada160/pyzmq-27.1.0-pp311-pypy311_pp73-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:53b40f8ae006f2734ee7608d59ed661419f087521edbfc2149c3932e9c14808c", size = 567747, upload-time = "2025-09-08T23:09:52.698Z" }, + { url = "https://files.pythonhosted.org/packages/a1/cf/f2b3784d536250ffd4be70e049f3b60981235d70c6e8ce7e3ef21e1adb25/pyzmq-27.1.0-pp311-pypy311_pp73-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f605d884e7c8be8fe1aa94e0a783bf3f591b84c24e4bc4f3e7564c82ac25e271", size = 747371, upload-time = "2025-09-08T23:09:54.563Z" }, + { url = "https://files.pythonhosted.org/packages/01/1b/5dbe84eefc86f48473947e2f41711aded97eecef1231f4558f1f02713c12/pyzmq-27.1.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:c9f7f6e13dff2e44a6afeaf2cf54cee5929ad64afaf4d40b50f93c58fc687355", size = 544862, upload-time = "2025-09-08T23:09:56.509Z" }, +] + [[package]] name = "referencing" version = "0.36.2" @@ -2326,6 +2748,20 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/3a/e2/745aeba88a8513017fbac2fd2f9f07b8a36065e51695f818541eb795ec0c/srsly-2.5.1-cp313-cp313-win_amd64.whl", hash = "sha256:e73712be1634b5e1de6f81c273a7d47fe091ad3c79dc779c03d3416a5c117cee", size = 630634, upload-time = "2025-01-17T09:26:10.018Z" }, ] +[[package]] +name = "stack-data" +version = "0.6.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "asttokens" }, + { name = "executing" }, + { name = "pure-eval" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/28/e3/55dcc2cfbc3ca9c29519eb6884dd1415ecb53b0e934862d3559ddcb7e20b/stack_data-0.6.3.tar.gz", hash = "sha256:836a778de4fec4dcd1dcd89ed8abff8a221f58308462e1c4aa2a3cf30148f0b9", size = 44707, upload-time = "2023-09-30T13:58:05.479Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f1/7b/ce1eafaf1a76852e2ec9b22edecf1daa58175c090266e9f6c64afcd81d91/stack_data-0.6.3-py3-none-any.whl", hash = "sha256:d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695", size = 24521, upload-time = "2023-09-30T13:58:03.53Z" }, +] + [[package]] name = "streamlit" version = "1.50.0" @@ -2527,6 +2963,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/d0/30/dc54f88dd4a2b5dc8a0279bdd7270e735851848b762aeb1c1184ed1f6b14/tqdm-4.67.1-py3-none-any.whl", hash = "sha256:26445eca388f82e72884e0d580d5464cd801a3ea01e63e5601bdff9ba6a48de2", size = 78540, upload-time = "2024-11-24T20:12:19.698Z" }, ] +[[package]] +name = "traitlets" +version = "5.14.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/eb/79/72064e6a701c2183016abbbfedaba506d81e30e232a68c9f0d6f6fcd1574/traitlets-5.14.3.tar.gz", hash = "sha256:9ed0579d3502c94b4b3732ac120375cda96f923114522847de4b3bb98b96b6b7", size = 161621, upload-time = "2024-04-19T11:11:49.746Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/00/c0/8f5d070730d7836adc9c9b6408dec68c6ced86b304a9b26a14df072a6e8c/traitlets-5.14.3-py3-none-any.whl", hash = "sha256:b74e89e397b1ed28cc831db7aea759ba6640cb3de13090ca145426688ff1ac4f", size = 85359, upload-time = "2024-04-19T11:11:46.763Z" }, +] + [[package]] name = "typer" version = "0.19.2" @@ -2611,6 +3056,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/33/e8/e40370e6d74ddba47f002a32919d91310d6074130fe4e17dabcafc15cbf1/watchdog-6.0.0-py3-none-win_ia64.whl", hash = "sha256:a1914259fa9e1454315171103c6a30961236f508b9b623eae470268bbcc6a22f", size = 79067, upload-time = "2024-11-01T14:07:11.845Z" }, ] +[[package]] +name = "wcwidth" +version = "0.2.14" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/24/30/6b0809f4510673dc723187aeaf24c7f5459922d01e2f794277a3dfb90345/wcwidth-0.2.14.tar.gz", hash = "sha256:4d478375d31bc5395a3c55c40ccdf3354688364cd61c4f6adacaa9215d0b3605", size = 102293, upload-time = "2025-09-22T16:29:53.023Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/af/b5/123f13c975e9f27ab9c0770f514345bd406d0e8d3b7a0723af9d43f710af/wcwidth-0.2.14-py2.py3-none-any.whl", hash = "sha256:a7bb560c8aee30f9957e5f9895805edd20602f2d7f720186dfd906e82b4982e1", size = 37286, upload-time = "2025-09-22T16:29:51.641Z" }, +] + [[package]] name = "weasel" version = "0.4.1"