data_engineering.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "mount_file_id": "1mS8-Ddi19cWTQBFOyaXRRHx6zJT5LmZd",
      "authorship_tag": "ABX9TyOCExZWVKLKE1+N3LIqWwvA",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/jbloewencolon/Creating-Dataset-for-The-Demographics-of-Faerun/blob/main/data_engineering.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Imports"
      ],
      "metadata": {
        "id": "-J9kmiEOdKeZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "import random\n",
        "import ast"
      ],
      "metadata": {
        "id": "GRaC-zagdQGq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# File path\n",
        "df_file_path = '/content/drive/MyDrive/Colab Notebooks/DnD/updated_dataset.csv'\n",
        "idf_file_path = '/content/drive/MyDrive/Colab Notebooks/DnD/idf_dataset.csv'\n",
        "\n",
        "# Read the CSV files into a DataFrame\n",
        "df = pd.read_csv(df_file_path)\n",
        "idf = pd.read_csv(idf_file_path)\n",
        "\n",
        "# Write the DataFrames to new CSV files\n",
        "#df.to_csv(df_file_path, index=False)  # index=False to exclude the index column\n",
        "#idf.to_csv(idf_file_path, index=False)"
      ],
      "metadata": {
        "id": "f9oTk0_21QW2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "df.info()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7cpMqvCW3ggV",
        "outputId": "56d3ae60-b372-49e8-e448-46722bbf7a5f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'pandas.core.frame.DataFrame'>\n",
            "RangeIndex: 849 entries, 0 to 848\n",
            "Data columns (total 27 columns):\n",
            " #   Column                      Non-Null Count  Dtype  \n",
            "---  ------                      --------------  -----  \n",
            " 0   settlement                  849 non-null    object \n",
            " 1   region                      849 non-null    object \n",
            " 2   settlement_population       849 non-null    int64  \n",
            " 3   settlement_economy          849 non-null    float64\n",
            " 4   rumored_treasure_value      849 non-null    int64  \n",
            " 5   demographic_breakdown       849 non-null    object \n",
            " 6   average_age                 849 non-null    int64  \n",
            " 7   most_likely_cause_of_death  849 non-null    object \n",
            " 8   government_type             849 non-null    object \n",
            " 9   class_density               849 non-null    object \n",
            " 10  tax_rate                    849 non-null    int64  \n",
            " 11  exports                     545 non-null    object \n",
            " 12  imports                     523 non-null    object \n",
            " 13  military                    441 non-null    object \n",
            " 14  magic_academy               849 non-null    object \n",
            " 15  capital                     530 non-null    object \n",
            " 16  languages                   849 non-null    object \n",
            " 17  religions                   849 non-null    object \n",
            " 18  region_area                 833 non-null    float64\n",
            " 19  region_population           849 non-null    int64  \n",
            " 20  region_economy              849 non-null    int64  \n",
            " 21  average_temperature         849 non-null    float64\n",
            " 22  annual_rainfall             849 non-null    float64\n",
            " 23  magical_climate             849 non-null    float64\n",
            " 24  dragon_sightings            849 non-null    int64  \n",
            " 25  average_debt_by_household   849 non-null    float64\n",
            " 26  development_index           849 non-null    object \n",
            "dtypes: float64(6), int64(7), object(14)\n",
            "memory usage: 179.2+ KB\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Data Understanding"
      ],
      "metadata": {
        "id": "H7M_GS3BdTfN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df['class_density'].tail()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lQLufd0ODKIs",
        "outputId": "810f5776-9022-46b0-d9bc-65633f8a29da"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "844    {'Aristocratic': 17, 'Wealthy': 403, 'Comforta...\n",
              "845    {'Aristocratic': 0, 'Wealthy': 2, 'Comfortable...\n",
              "846    {'Aristocratic': 0, 'Wealthy': 5, 'Comfortable...\n",
              "847    {'Aristocratic': 0, 'Wealthy': 18, 'Comfortabl...\n",
              "848    {'Aristocratic': 0, 'Wealthy': 23, 'Comfortabl...\n",
              "Name: class_density, dtype: object"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Assuming you have a DataFrame 'df' with columns containing float values\n",
        "columns_to_convert = ['settlement_population', 'region_population', 'settlement_economy', 'rumored_treasure_value', 'region_economy']\n",
        "\n",
        "# Fill NaN values with 0 and convert infinity values to a large integer\n",
        "for column in columns_to_convert:\n",
        "    df[column] = df[column].fillna(0).replace([np.inf, -np.inf], np.nan).astype(int)\n",
        "\n",
        "# Use astype(int) to convert specified columns to integers\n",
        "df[columns_to_convert] = df[columns_to_convert].astype(int)"
      ],
      "metadata": {
        "id": "yhElEWm3ktdD"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Generate random percentages between 3% and 7%\n",
        "random_percentages = np.random.uniform(0.03, 0.07, size=len(df))\n",
        "\n",
        "# Randomly choose to add or subtract the percentage\n",
        "change_factors = 1 + np.random.choice([-1, 1], size=len(df)) * random_percentages\n",
        "\n",
        "# Apply the change factors to the 'settlement_population' column\n",
        "df['settlement_population'] = np.rint(np.nan_to_num(df['settlement_population']) * change_factors).astype(int)"
      ],
      "metadata": {
        "id": "mbXQT5Fi7MLu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Determing Class Density and Generating Economy"
      ],
      "metadata": {
        "id": "b4HUaHkLNayy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "lifestyle_costs = {\n",
        "    'Wretched': 0,          # No cost\n",
        "    'Squalid': .1,           # 1 silver piece (sp) per day\n",
        "    'Poor': .2,              # 2 silver pieces (sp) per day\n",
        "    'Modest': 1,            # 1 gold piece (gp) per day\n",
        "    'Comfortable': 2,       # 2 gold pieces (gp) per day\n",
        "    'Wealthy': 4,           # 4 gold pieces (gp) per day\n",
        "    'Aristocratic': 10      # 10 gold pieces (gp) minimum per day\n",
        "}\n",
        "\n",
        "lifestyle_ranges = {\n",
        "    'tiny_settlement': {'Aristocratic': (0, 0.0001), 'Wealthy': (0, .05), 'Comfortable': (1, 10), 'Modest': (1, 20), 'Poor': (30, 35), 'Squalid': (10, 30), 'Wretched': (0, 0.001)},\n",
        "    'small_settlement': {'Aristocratic': (0, .005), 'Wealthy': (.05, 1), 'Comfortable': (4, 7), 'Modest': (7, 20),'Poor': (30, 35), 'Squalid': (15, 30), 'Wretched': (1, 2)},\n",
        "    'medium_settlement': {'Aristocratic': (0, .05), 'Wealthy': (1, 2), 'Comfortable': (6, 8), 'Modest': (10, 25),'Poor': (30, 35), 'Squalid': (18, 30), 'Wretched': (3, 8)},\n",
        "    'large_settlement': {'Aristocratic': (0, .5), 'Wealthy': (1, 3), 'Comfortable': (7, 13), 'Modest': (10, 20),'Poor': (30, 35), 'Squalid': (20, 40), 'Wretched': (5, 10)},\n",
        "    'mega_settlement': {'Aristocratic': (0, .8), 'Wealthy': (2, 3), 'Comfortable': (10, 15), 'Modest': (15, 30),'Poor': (30, 35), 'Squalid': (35, 50), 'Wretched': (8, 10)}\n",
        "}"
      ],
      "metadata": {
        "id": "vssyN2JLn6QV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def assign_lifestyle_demographics(population):\n",
        "    total_economy = 0\n",
        "\n",
        "    # Step 1: Determine settlement_size\n",
        "    if population < 100:\n",
        "        city_size = 'tiny_settlement'\n",
        "    elif 100 <= population < 1000:\n",
        "        city_size = 'small_settlement'\n",
        "    elif 1000 <= population < 10000:\n",
        "        city_size = 'medium_settlement'\n",
        "    elif 10000 <= population < 100000:\n",
        "        city_size = 'large_settlement'\n",
        "    else:\n",
        "        city_size = 'mega_settlement'\n",
        "\n",
        "    # Step 2: Calculate class_density and total_economy\n",
        "    class_density = {}\n",
        "    for lifestyle, (start, end) in lifestyle_ranges[city_size].items():\n",
        "        percentage = random.uniform(start, end)\n",
        "        count = int(population * (percentage / 100))\n",
        "        class_density[lifestyle] = count\n",
        "        total_economy += count * lifestyle_costs[lifestyle] * 365\n",
        "\n",
        "    return class_density, total_economy\n",
        "\n",
        "# Apply the function to the 'settlement_population' column and directly assign the results to new DataFrame columns\n",
        "results = df['settlement_population'].apply(assign_lifestyle_demographics)\n",
        "df['class_density'] = results.apply(lambda x: x[0])\n",
        "df['settlement_economy'] = results.apply(lambda x: x[1])\n",
        "\n",
        "# Convert the dictionary in 'class_density' to a string representation if necessary\n",
        "df['class_density'] = df['class_density'].apply(str)"
      ],
      "metadata": {
        "id": "99VCBCBn-Qyz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Create an empty dictionary to store the total sum of each lifestyle category\n",
        "total_class_density = {}\n",
        "\n",
        "# Assuming you have a DataFrame 'df' with columns containing float values\n",
        "for _, row in df.iterrows():\n",
        "    class_density, _ = assign_lifestyle_demographics(row['settlement_population'])\n",
        "\n",
        "    # Add the counts to the total_class_density dictionary\n",
        "    for lifestyle, count in class_density.items():\n",
        "        total_class_density[lifestyle] = total_class_density.get(lifestyle, 0) + count\n",
        "\n",
        "# Print the total sum of each lifestyle category across all settlements\n",
        "for lifestyle, total_count in total_class_density.items():\n",
        "    print(f\"Total {lifestyle} count: {total_count}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7DNdK2qUlf0D",
        "outputId": "77d3d22f-d88d-4af6-c6d6-bf41ad0791f2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Total Aristocratic count: 30427\n",
            "Total Wealthy count: 216312\n",
            "Total Comfortable count: 1163190\n",
            "Total Modest count: 2020999\n",
            "Total Poor count: 3378371\n",
            "Total Squalid count: 3456607\n",
            "Total Wretched count: 812652\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "df['class_density'].tail()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "U9GJHYbWBRKu",
        "outputId": "11b32399-dc2e-4162-9a14-7b1a8faf9f21"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "844    {'Aristocratic': 32, 'Wealthy': 350, 'Comforta...\n",
              "845    {'Aristocratic': 0, 'Wealthy': 4, 'Comfortable...\n",
              "846    {'Aristocratic': 0, 'Wealthy': 3, 'Comfortable...\n",
              "847    {'Aristocratic': 0, 'Wealthy': 11, 'Comfortabl...\n",
              "848    {'Aristocratic': 0, 'Wealthy': 35, 'Comfortabl...\n",
              "Name: class_density, dtype: object"
            ]
          },
          "metadata": {},
          "execution_count": 40
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Calculate the total economy across all settlements\n",
        "total_economy = df['settlement_economy'].sum()\n",
        "print(f\"Total Economy: {total_economy}\")\n",
        "\n",
        "# Find the top 10 settlements with the highest settlement economy\n",
        "top_10_settlements = df.nlargest(10, 'settlement_economy')\n",
        "\n",
        "# Print the top 10 settlements\n",
        "print(\"Top 10 Settlements by Economy:\")\n",
        "print(top_10_settlements[['settlement', 'settlement_economy', 'settlement_population']])\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QGU6RGFMBxiw",
        "outputId": "1047dad8-12b0-4d86-d5f3-9f0a002f41b8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Total Economy: 2312632298.5\n",
            "Top 10 Settlements by Economy:\n",
            "        settlement  settlement_economy  settlement_population\n",
            "764      Waterdeep         318359752.5                1281544\n",
            "426       Darromar         286637383.5                 948080\n",
            "478      Thaymount         237367128.5                 882633\n",
            "186        Elturel          63093352.5                 220794\n",
            "324       Skyclave          41056222.0                 168838\n",
            "798        Thindar          40242491.0                 160543\n",
            "832      Unthalass          40016665.5                 168076\n",
            "114         Suzail          37615111.5                 135464\n",
            "351     Skalnaedyr          33931239.5                 120196\n",
            "676  Baldur's Gate          31273747.5                 114273\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Group by 'Region' and sum up the 'settlement_economy'\n",
        "region_economy_sum = df.groupby('region')['settlement_economy'].sum().reset_index()\n",
        "\n",
        "# Rename the columns for easier merging\n",
        "region_economy_sum.columns = ['region', 'new_region_economy']\n",
        "\n",
        "# Merge the DataFrame to include the new region economy sums\n",
        "df = pd.merge(df, region_economy_sum, on='region', how='left')\n",
        "\n",
        "# Update the 'region_economy' column with the newly computed sums\n",
        "df['region_economy'] = df['new_region_economy']\n",
        "\n",
        "# Drop the temporary column used for merging\n",
        "df.drop(columns=['new_region_economy'], inplace=True)\n"
      ],
      "metadata": {
        "id": "R8K18tGyDHvb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "df['region_economy'].tail()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hDeXVXvDQfL1",
        "outputId": "ae80fad8-56f8-45cd-a5fc-9e13405b4b3e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "844    7301752.0\n",
              "845     727737.0\n",
              "846     727737.0\n",
              "847     727737.0\n",
              "848     727737.0\n",
              "Name: region_economy, dtype: float64"
            ]
          },
          "metadata": {},
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "idf = df.copy()\n",
        "\n",
        "def determine_settlement_size(population):\n",
        "    if population < 100:\n",
        "        return 'tiny_settlement'\n",
        "    elif 100 <= population < 1000:\n",
        "        return 'small_settlement'\n",
        "    elif 1000 <= population < 10000:\n",
        "        return 'medium_settlement'\n",
        "    elif 10000 <= population < 100000:\n",
        "        return 'large_settlement'\n",
        "    else:\n",
        "        return 'mega_settlement'\n",
        "\n",
        "def adjust_settlement_economy(row):\n",
        "    size_to_divisor = {\n",
        "        'tiny_settlement': 10000,\n",
        "        'small_settlement': 1000,\n",
        "        'medium_settlement': 100,\n",
        "        'large_settlement': 10,\n",
        "        'mega_settlement': 1  # No adjustment needed for 'mega_settlement'\n",
        "    }\n",
        "    divisor = size_to_divisor.get(row['settlement_size'], 1)  # Default to no adjustment\n",
        "    return row['settlement_economy'] / divisor\n",
        "\n",
        "# Create 'settlement_size' column by applying 'determine_settlement_size'\n",
        "idf['settlement_size'] = df['settlement_population'].apply(determine_settlement_size)\n",
        "\n",
        "# Adjust the 'settlement_economy' column\n",
        "idf['settlement_economy'] = idf.apply(adjust_settlement_economy, axis=1)\n"
      ],
      "metadata": {
        "id": "Cz2eo2NFxTuZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "idf.info()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ha5ZtP-fP0Cv",
        "outputId": "32146f3e-bb7e-488f-c301-fff89109d60b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'pandas.core.frame.DataFrame'>\n",
            "RangeIndex: 849 entries, 0 to 848\n",
            "Data columns (total 28 columns):\n",
            " #   Column                      Non-Null Count  Dtype  \n",
            "---  ------                      --------------  -----  \n",
            " 0   settlement                  849 non-null    object \n",
            " 1   region                      849 non-null    object \n",
            " 2   settlement_population       849 non-null    int64  \n",
            " 3   settlement_economy          849 non-null    float64\n",
            " 4   rumored_treasure_value      849 non-null    int64  \n",
            " 5   demographic_breakdown       849 non-null    object \n",
            " 6   average_age                 849 non-null    int64  \n",
            " 7   most_likely_cause_of_death  849 non-null    object \n",
            " 8   government_type             849 non-null    object \n",
            " 9   class_density               849 non-null    object \n",
            " 10  tax_rate                    849 non-null    int64  \n",
            " 11  exports                     545 non-null    object \n",
            " 12  imports                     523 non-null    object \n",
            " 13  military                    441 non-null    object \n",
            " 14  magic_academy               849 non-null    object \n",
            " 15  capital                     530 non-null    object \n",
            " 16  languages                   849 non-null    object \n",
            " 17  religions                   849 non-null    object \n",
            " 18  region_area                 833 non-null    float64\n",
            " 19  region_population           849 non-null    int64  \n",
            " 20  region_economy              849 non-null    int64  \n",
            " 21  average_temperature         849 non-null    float64\n",
            " 22  annual_rainfall             849 non-null    float64\n",
            " 23  magical_climate             849 non-null    float64\n",
            " 24  dragon_sightings            849 non-null    int64  \n",
            " 25  average_debt_by_household   849 non-null    float64\n",
            " 26  development_index           849 non-null    object \n",
            " 27  settlement_size             849 non-null    object \n",
            "dtypes: float64(6), int64(7), object(15)\n",
            "memory usage: 185.8+ KB\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Calculating Hidden Economy"
      ],
      "metadata": {
        "id": "8xW7oM3YNlru"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Convert 'class_density' from string to dictionary using ast.literal_eval safely\n",
        "idf['class_density_dict'] = idf['class_density'].apply(lambda x: ast.literal_eval(x) if isinstance(x, str) else x)\n",
        "\n",
        "# Create separate columns for each class density for vectorized operations\n",
        "for lifestyle in ['Squalid', 'Wretched', 'Poor', 'Wealthy', 'Aristocratic']:\n",
        "    idf[f\"{lifestyle}_count\"] = idf['class_density_dict'].apply(lambda x: x.get(lifestyle, 0))\n",
        "\n",
        "# Calculate the multipliers directly using vectorized operations\n",
        "idf['squalid_multiplier'] = idf['Squalid_count'] * 0.0000005\n",
        "idf['wretched_multiplier'] = idf['Wretched_count'] * 0.0000003\n",
        "idf['poor_multiplier'] = idf['Poor_count'] * 0.0000001\n",
        "idf['wealthy_multiplier'] = idf['Wealthy_count'] * 0.000004\n",
        "idf['aristocratic_multiplier'] = idf['Aristocratic_count'] * 0.00001\n",
        "\n",
        "# Calculate hidden_multiplier and hidden_economy in a vectorized way\n",
        "idf['hidden_multiplier'] = idf[['wealthy_multiplier', 'aristocratic_multiplier', 'squalid_multiplier', 'wretched_multiplier', 'poor_multiplier']].sum(axis=1)\n",
        "idf['hidden_economy'] = idf.apply(lambda row: row['settlement_economy'] * row['hidden_multiplier'] if row['hidden_multiplier'] != 0 else row['settlement_economy'], axis=1)\n",
        "\n",
        "# Convert the 'hidden_economy' column to integers\n",
        "idf['hidden_economy'] = idf['hidden_economy'].fillna(0).astype(int)\n",
        "\n",
        "# Drop the intermediate columns if they are no longer needed\n",
        "idf.drop(columns=['class_density_dict', 'Squalid_count', 'Wretched_count', 'Poor_count', 'Wealthy_count', 'Aristocratic_count', 'squalid_multiplier', 'wretched_multiplier', 'poor_multiplier', 'wealthy_multiplier', 'aristocratic_multiplier'], inplace=True)"
      ],
      "metadata": {
        "id": "nTJneENwpgVc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "df['hidden_economy'] = idf['hidden_economy']"
      ],
      "metadata": {
        "id": "taycruFhVrua"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Handle potential division by zero\n",
        "idf['settlement_population'] = idf['settlement_population'].replace(0, np.nan)\n",
        "\n",
        "# Calculate hidden economy per capita\n",
        "idf['hidden_economy_per_capita'] = idf['hidden_economy'] / idf['settlement_population']\n",
        "\n",
        "# Replace NaN values with 0 (if there were any divisions by zero)\n",
        "idf['hidden_economy_per_capita'] = idf['hidden_economy_per_capita'].fillna(0)\n",
        "\n",
        "# Get the top 10 settlements with the highest hidden economy per capita\n",
        "top_10_hidden_economies = idf.nlargest(10, 'hidden_economy_per_capita')[['settlement', 'hidden_economy_per_capita']]\n",
        "\n",
        "# Print the top 10 hidden economies per capita\n",
        "print(\"Top 10 Settlements with Highest Hidden Economy Per Capita:\")\n",
        "print(top_10_hidden_economies)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jlkbaOJqeLEc",
        "outputId": "1c73c8bf-f1a5-417c-d41f-dc800318681d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Top 10 Settlements with Highest Hidden Economy Per Capita:\n",
            "        settlement  hidden_economy_per_capita\n",
            "764      Waterdeep                 136.450217\n",
            "426       Darromar                 122.643570\n",
            "478      Thaymount                  89.292798\n",
            "186        Elturel                  22.421606\n",
            "324       Skyclave                  16.627187\n",
            "114         Suzail                  16.188958\n",
            "832      Unthalass                  15.477611\n",
            "798        Thindar                  14.532891\n",
            "351     Skalnaedyr                  13.648433\n",
            "676  Baldur's Gate                  13.445661\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "idf['hidden_economy'].head()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tkvrcFgCrWUP",
        "outputId": "abd640cc-4a19-47ce-fb23-78bbd1660345"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0        0\n",
              "1        0\n",
              "2        0\n",
              "3        0\n",
              "4    10665\n",
              "Name: hidden_economy, dtype: int64"
            ]
          },
          "metadata": {},
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "idf['settlement_economy'] = idf['settlement_economy'].astype(int)\n",
        "\n",
        "# Calculate the total economy of all settlements\n",
        "total_economy = idf['settlement_economy'].sum() + idf['hidden_economy'].sum()\n",
        "\n",
        "print(f\"The total economy of all settlements is {total_economy}\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Exkx3cD4mrbR",
        "outputId": "63185116-f4f4-4b08-87d1-0dda3005eb3b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The total economy of all settlements is 1686084948\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Function to adjust hidden economy based on the number of unique imports and exports\n",
        "def adjust_hidden_economy(row):\n",
        "    # Get the number of unique exports and imports\n",
        "    unique_exports = len(set(row['exports'])) if isinstance(row['exports'], list) else 0\n",
        "    unique_imports = len(set(row['imports'])) if isinstance(row['imports'], list) else 0\n",
        "\n",
        "    # Calculate adjustment value\n",
        "    adjustment_value = (unique_exports + unique_imports) / 100 * row['settlement_economy']\n",
        "\n",
        "    # Update hidden_economy value\n",
        "    return row['hidden_economy'] + adjustment_value\n",
        "\n",
        "# Assuming 'hidden_economy' is already initialized. If not, initialize it first.\n",
        "if 'hidden_economy' not in idf.columns:\n",
        "    idf['hidden_economy'] = 0.0  # Initialize to 0\n",
        "\n",
        "# Now adjust the 'hidden_economy' column\n",
        "idf['hidden_economy'] = idf.apply(adjust_hidden_economy, axis=1)\n",
        "idf['hidden_economy'] = idf['hidden_economy'].astype(int)"
      ],
      "metadata": {
        "id": "oQg29ZZG09PP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Demographics"
      ],
      "metadata": {
        "id": "Acrq0zr5Nxjd"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Define the default population breakdown\n",
        "default_population_breakdown = {'Humans': 80, 'Halflings': 7, 'Misc': 13}\n",
        "\n",
        "# Function to calculate demographic_breakdown if it's not already provided\n",
        "def calculate_demographic_breakdown(row):\n",
        "    # Proceed only if demographic_breakdown is NaN or empty\n",
        "    if pd.isna(row['demographic_breakdown']) or not row['demographic_breakdown']:\n",
        "        population_breakdown = default_population_breakdown\n",
        "        demographic_breakdown = {\n",
        "            species: int(row['settlement_population'] * (percentage / 100))\n",
        "            for species, percentage in population_breakdown.items()\n",
        "        }\n",
        "        return demographic_breakdown\n",
        "    else:\n",
        "        # Return the existing demographic_breakdown if it's already filled\n",
        "        return row['demographic_breakdown']\n",
        "\n",
        "# Apply the function conditionally\n",
        "df['demographic_breakdown'] = df.apply(lambda row: calculate_demographic_breakdown(row)\n",
        "                                       if pd.isna(row['demographic_breakdown']) or not row['demographic_breakdown']\n",
        "                                       else row['demographic_breakdown'], axis=1)"
      ],
      "metadata": {
        "id": "3_Xtv9TJ3DFq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Calculate the total economy of all settlements\n",
        "total_population = df['settlement_population'].sum()\n",
        "print(f\"The total population of all settlements is {total_population}\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lMehJn_U6cxC",
        "outputId": "d3932cae-7fc8-428f-9b25-cad8c0a1a955"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The total population of all settlements is 10341403\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Average Age"
      ],
      "metadata": {
        "id": "lxztWlrlN2kF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Define Constants\n",
        "species = [\"humans\", \"halflings\", \"half-orcs\", \"half-drow\", \"half-elves\", \"elves\", \"dwarves\", \"gnomes\", \"goblins\", \"lizardfolk\", \"yuan-ti\", \"orcs\", \"ogres\", \"asabi\", \"gnolls\",\n",
        "           \"pterafolk\", \"drow\", \"centaurs\", \"wemics\", \"humanoids\"]\n",
        "\n",
        "species_age_ranges = {\n",
        "    \"humans\": [1, 100],\n",
        "    \"halflings\": [1, 150],\n",
        "    \"half-elves\": [1, 180],\n",
        "    \"half-orcs\": [1, 75],\n",
        "    \"orcs\": [1, 50],\n",
        "    \"elves\": [1, 750],\n",
        "    \"dwarves\": [1, 350],\n",
        "    \"gnomes\": [1, 400],\n",
        "    \"goblins\": [1, 60],  # Goblins generally have short lifespans.\n",
        "    \"lizardfolk\": [1, 80],  # Lizardfolk have lifespans comparable to or slightly longer than humans.\n",
        "    \"yuan-ti\": [1, 120],  # Yuan-ti have longer lifespans due to their snake-like nature.\n",
        "    \"ogres\": [1, 100],  # Ogres have lifespans similar to humans but can occasionally live longer.\n",
        "    \"asabi\": [1, 60],  # Also known as 'ashworms', Asabis have shorter lifespans.\n",
        "    \"gnolls\": [1, 30],  # Gnolls have relatively short lifespans due to their chaotic and violent lives.\n",
        "    \"pterafolk\": [1, 60],  # Pterafolk have lifespans similar to other humanoid species.\n",
        "    \"drow\": [1, 750],  # Drow, or dark elves, have lifespans similar to other elves.\n",
        "    \"centaurs\": [1, 120],  # Centaurs tend to live longer than humans but not as long as elves.\n",
        "    \"wemics\": [1, 60],  # Wemics have lifespans similar to or slightly longer than humans.\n",
        "    \"half-drow\": [1, 180],  # Half-drow might have lifespans in between humans and drow.\n",
        "    \"humanoids\": [1, 80],  # Generic humanoid lifespan, individual species may vary.\n",
        "    \"misc.\": [1, 80],  # Generic humanoid lifespan, individual species may vary.\n",
        "}\n",
        "\n",
        "# Lifestyle modifiers\n",
        "lifestyle_modifier= {\n",
        "    'Wretched': -80,\n",
        "    'Squalid': -30,\n",
        "    'Poor': -10,\n",
        "    'Modest': 0,\n",
        "    'Comfortable': 3,\n",
        "    'Wealthy': 5,\n",
        "    'Aristocratic': 10\n",
        "}\n",
        "\n",
        "# Custom function to calculate average_age with lifestyle modifiers\n",
        "def calculate_average_age(row):\n",
        "    try:\n",
        "        # Initialize variables\n",
        "        weighted_ages = 0\n",
        "        total_population = row['settlement_population']\n",
        "        lifestyle_adjustment = 0\n",
        "\n",
        "        # Convert strings to dictionaries if necessary\n",
        "        demographic_breakdown = ast.literal_eval(row['demographic_breakdown']) if isinstance(row['demographic_breakdown'], str) else row['demographic_breakdown']\n",
        "        class_density = ast.literal_eval(row['class_density']) if isinstance(row['class_density'], str) else row['class_density']\n",
        "\n",
        "        # Loop over each species in the demographic breakdown\n",
        "        for species, count in demographic_breakdown.items():\n",
        "            # Get the age range for this species\n",
        "            age_range = species_age_ranges.get(species, [1, 100])  # default to human age range if species is not found\n",
        "\n",
        "            # Calculate the average age for this species\n",
        "            avg_age_species = sum(age_range) / 2\n",
        "\n",
        "            # Calculate the weighted age for this species\n",
        "            weighted_age_species = avg_age_species * (count / total_population)\n",
        "\n",
        "            # Add to the total weighted ages\n",
        "            weighted_ages += weighted_age_species\n",
        "\n",
        "        # Calculate lifestyle adjustment\n",
        "        for lifestyle, count in class_density.items():\n",
        "            modifier = lifestyle_modifier.get(lifestyle, 0)\n",
        "            lifestyle_adjustment += (count / total_population) * modifier\n",
        "\n",
        "        # Apply lifestyle adjustment to weighted ages\n",
        "        average_age = weighted_ages + lifestyle_adjustment\n",
        "\n",
        "        return average_age\n",
        "    except Exception as e:\n",
        "        print(f\"Error calculating average age for row: {e}\")\n",
        "        return None\n",
        "\n",
        "# Make sure to apply the function again\n",
        "df['average_age'] = df.apply(calculate_average_age, axis=1)\n",
        "\n",
        "# Handle the None values before casting to int\n",
        "df['average_age'] = df['average_age'].fillna(0).astype(int)\n",
        "\n",
        "# Apply the function across the DataFrame rows\n",
        "df['average_age'] = df.apply(calculate_average_age, axis=1)\n",
        "df['average_age'] = df['average_age'].astype(int)"
      ],
      "metadata": {
        "id": "N7AqeWGGu6KJ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "df['average_age'].head(25)"
      ],
      "metadata": {
        "id": "IVVu-gA_WZKv",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d05ad6ee-8fc8-4da5-edc9-e4784c1fd9e0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0     76\n",
              "1     53\n",
              "2     90\n",
              "3     67\n",
              "4     40\n",
              "5     91\n",
              "6     35\n",
              "7     38\n",
              "8     36\n",
              "9     67\n",
              "10    66\n",
              "11    41\n",
              "12    45\n",
              "13    42\n",
              "14    34\n",
              "15    36\n",
              "16    47\n",
              "17    41\n",
              "18    54\n",
              "19    37\n",
              "20    30\n",
              "21    45\n",
              "22    32\n",
              "23    42\n",
              "24    42\n",
              "Name: average_age, dtype: int64"
            ]
          },
          "metadata": {},
          "execution_count": 28
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Rumored Treasure Value"
      ],
      "metadata": {
        "id": "2RnTT-HOOB5Z"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "size_modifier = {\n",
        "    'tiny_settlement': 0.09,\n",
        "    'small_settlement': 0.09,\n",
        "    'medium_settlement': 0.1,\n",
        "    'large_settlement': 0.2,\n",
        "    'mega_settlement': 0.5\n",
        "}\n",
        "\n",
        "# Calculate the base_value\n",
        "idf['base_value'] = idf['settlement_economy'] / 1000\n",
        "\n",
        "# Apply size_modifier based on 'settlement_size', use .get() to handle cases where 'settlement_size' might be None\n",
        "idf['modified_hidden_economy'] = idf['hidden_economy'] * idf['settlement_size'].map(size_modifier).fillna(1)\n",
        "\n",
        "# Calculate the rumored_treasure_value\n",
        "idf['rumored_treasure_value'] = idf['base_value'] + idf['modified_hidden_economy']\n",
        "\n",
        "# Cast to int, ensuring no None values\n",
        "idf['rumored_treasure_value'] = idf['rumored_treasure_value'].astype(int)\n",
        "\n",
        "# Drop the intermediate columns if they are no longer needed\n",
        "idf.drop(columns=['base_value', 'modified_hidden_economy'], inplace=True)"
      ],
      "metadata": {
        "id": "syVJqtOXEsv8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "comparison_df = idf[['rumored_treasure_value', 'settlement_economy', 'hidden_economy']].tail()\n",
        "print(comparison_df)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1gjaluBl7szm",
        "outputId": "5a976b95-553d-478b-e4a2-9d0a5c3591b9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "     rumored_treasure_value  settlement_economy  hidden_economy\n",
            "844                    1357              503539            4268\n",
            "845                       0                  95               0\n",
            "846                       0                  72               0\n",
            "847                       1                1549               0\n",
            "848                       3                3259               1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Goverment Types"
      ],
      "metadata": {
        "id": "oKSsUgyeOOi5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# List of government types\n",
        "government_types = [\"Autocracy\", \"Bureaucracy\", \"Confederacy\", \"Democracy\", \"Dictatorship\", \"Feudalism\", \"Gerontocracy\", \"Hierarchy\",\n",
        "                    \"Monarchy\", \"Magocracy\", \"Militocracy\", \"Matriarchy\", \"Oligarchy\", \"Patriarchy\", \"Meritocracy\", \"Plutocracy\",\n",
        "                    \"Republic\", \"Kleptocracy\", \"Satrapy\", \"Theocracy\"]\n",
        "\n",
        "# Add a new column \"government_type\" with random values\n",
        "df['government_type'] = [random.choice(government_types) for _ in range(len(df))]\n",
        "\n",
        "# Print the DataFrame to verify the new column\n",
        "print(df[['region', 'government_type']])\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "A5l-kjSMfq-7",
        "outputId": "f24b9460-08b2-44ec-e959-10c955284079"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "       region government_type\n",
            "0    Aglarond     Kleptocracy\n",
            "1    Aglarond     Meritocracy\n",
            "2    Aglarond     Militocracy\n",
            "3    Aglarond       Theocracy\n",
            "4    Aglarond      Plutocracy\n",
            "..        ...             ...\n",
            "844     Vaasa    Dictatorship\n",
            "845  Vesperin    Gerontocracy\n",
            "846  Vesperin     Meritocracy\n",
            "847  Vesperin     Confederacy\n",
            "848  Vesperin     Confederacy\n",
            "\n",
            "[849 rows x 2 columns]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Cause of Death"
      ],
      "metadata": {
        "id": "-e2dHCKJOSFf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Define causes of death for each settlement size\n",
        "causes_of_death_by_size = {\n",
        "    'tiny_settlement': ['Old age', 'Wildlife attacks', 'Starvation', 'Disease', 'Exposure', 'Accidental falls', 'Lack of healers', 'Poisonous plants', 'Isolation', 'Necromancy'],\n",
        "    'small_settlement': ['Disease', 'Poison', 'Old age', 'Starvation', 'Banditry', 'Elementals', 'Cursed artifacts', 'Fey mischief'],\n",
        "    'medium_settlement': [ 'Old age', 'Assassination', 'Alchemy accidents', 'Guild conflicts', 'Dragonfire', 'Orc raids', 'Dark magic', 'Cult activities'],\n",
        "    'large_settlement': [ 'Assassination', 'Necromancy', 'Old age', 'Arcane experiments', 'Thieves guilds', 'Political intrigue', 'Demonic incursions',  'Tavern brawls'],\n",
        "    'mega_settlement': ['Political assassinations', 'Dark sorcery', 'Starvation', 'Disease', 'Exposure', 'Arcane disasters', 'Underdark creatures', 'Urban crime', 'Gang wars', 'Demonic pacts',]\n",
        "}\n",
        "\n",
        "# Define regional causes of death that are likely to affect multiple settlements in the same region\n",
        "regional_causes_of_death = ['Plague', 'War', 'Goblin hordes', 'Famine', 'Dragon attacks', 'Undead uprisings', 'Necromantic disasters', 'Elemental storms']\n",
        "\n",
        "# Select one primary regional cause for each region\n",
        "primary_regional_cause = {\n",
        "    region: np.random.choice(regional_causes_of_death)\n",
        "    for region in df['region'].unique()\n",
        "}\n",
        "\n",
        "# Function to pick causes of death based on settlement size and the primary regional cause\n",
        "def pick_causes_of_death(size, region, primary_regional_cause):\n",
        "    # Get size-specific causes\n",
        "    size_specific_causes = causes_of_death_by_size[size]\n",
        "\n",
        "    # Combine size-specific causes with the primary regional cause\n",
        "    combined_causes = size_specific_causes + [primary_regional_cause[region]]\n",
        "\n",
        "    # Normalize the weights to give the primary regional cause a higher chance\n",
        "    weights = [1] * len(size_specific_causes) + [5]  # Adjust the weight for the primary regional cause as needed\n",
        "\n",
        "    # Pick 5 unique causes, ensuring the primary regional cause has a higher likelihood\n",
        "    chosen_causes = np.random.choice(combined_causes, size=5, replace=False, p=np.array(weights) / sum(weights)).tolist()\n",
        "\n",
        "    return chosen_causes\n",
        "\n",
        "# Add a new column \"settlement_size\" based on population if not already present\n",
        "if 'settlement_size' not in df.columns:\n",
        "    df['settlement_size'] = df['settlement_population'].apply(determine_settlement_size)\n",
        "\n",
        "# Apply the function to assign causes of death to each settlement\n",
        "df['most_likely_cause_of_death'] = df.apply(lambda x: pick_causes_of_death(x['settlement_size'], x['region'], primary_regional_cause), axis=1)\n",
        "\n",
        "# Verify the results\n",
        "print(df[['settlement', 'region', 'settlement_size', 'most_likely_cause_of_death']])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tBfWVRYPhWxR",
        "outputId": "4bfe7c13-6cff-4bf6-fa5a-48cae7330cef"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "       settlement    region    settlement_size  \\\n",
            "0           Corth  Aglarond   small_settlement   \n",
            "1           Dahst  Aglarond   small_settlement   \n",
            "2           Dlusk  Aglarond   small_settlement   \n",
            "3          Findar  Aglarond   small_settlement   \n",
            "4    Furthinghome  Aglarond   large_settlement   \n",
            "..            ...       ...                ...   \n",
            "844    Telos City     Vaasa   large_settlement   \n",
            "845  Dragon Falls  Vesperin   small_settlement   \n",
            "846       Galaunt  Vesperin   small_settlement   \n",
            "847  Ravens Bluff  Vesperin  medium_settlement   \n",
            "848       Tantras  Vesperin  medium_settlement   \n",
            "\n",
            "                            most_likely_cause_of_death  \n",
            "0    [Undead uprisings, Disease, Fey mischief, Old ...  \n",
            "1    [Undead uprisings, Banditry, Old age, Fey misc...  \n",
            "2    [Fey mischief, Old age, Undead uprisings, Pois...  \n",
            "3    [Cursed artifacts, Undead uprisings, Poison, D...  \n",
            "4    [Assassination, Undead uprisings, Tavern brawl...  \n",
            "..                                                 ...  \n",
            "844  [Tavern brawls, Famine, Necromancy, Political ...  \n",
            "845  [Elementals, Starvation, Plague, Disease, Fey ...  \n",
            "846  [Cursed artifacts, Fey mischief, Poison, Starv...  \n",
            "847  [Old age, Cult activities, Plague, Orc raids, ...  \n",
            "848  [Guild conflicts, Alchemy accidents, Cult acti...  \n",
            "\n",
            "[849 rows x 4 columns]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Trade Deficit\n"
      ],
      "metadata": {
        "id": "03pLtGz-oTY4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Define a function to safely convert string representations of lists into actual lists\n",
        "def convert_to_list(column):\n",
        "    # Check if the column is a string and attempt to parse it\n",
        "    if isinstance(column, str):\n",
        "        try:\n",
        "            # Interpret the string as a list\n",
        "            return ast.literal_eval(column)\n",
        "        except (ValueError, SyntaxError):\n",
        "            # In case of error, return an empty list\n",
        "            return []\n",
        "    elif isinstance(column, list):\n",
        "        # If it's already a list, just return it as is\n",
        "        return column\n",
        "    else:\n",
        "        # If it's neither (e.g., NaN or some other type), return an empty list\n",
        "        return []\n",
        "\n",
        "# Apply the conversion function to 'exports' and 'imports'\n",
        "idf['exports'] = idf['exports'].apply(convert_to_list)\n",
        "idf['imports'] = idf['imports'].apply(convert_to_list)\n",
        "\n",
        "# Count the items in 'exports' and 'imports' if they represent trade volume\n",
        "# Make sure to only count if the item is a list\n",
        "idf['exports_value'] = idf['exports'].apply(lambda x: len(x) if isinstance(x, list) else 0)\n",
        "idf['imports_value'] = idf['imports'].apply(lambda x: len(x) if isinstance(x, list) else 0)\n",
        "\n",
        "# Calculate the trade balance now that 'exports_value' and 'imports_value' are numerical\n",
        "idf['trade_balance'] = idf['exports_value'] - idf['imports_value']\n",
        "\n",
        "# Normalize the 'trade_balance' between 0 and 1\n",
        "max_trade_balance = idf['trade_balance'].max()\n",
        "min_trade_balance = idf['trade_balance'].min()\n",
        "idf['normalized_trade_balance'] = (idf['trade_balance'] - min_trade_balance) / (max_trade_balance - min_trade_balance)"
      ],
      "metadata": {
        "id": "NIcrpBPemvZf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Inequality Score"
      ],
      "metadata": {
        "id": "i5IlbXUEOYMs"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Define weights for factors\n",
        "weights = {\n",
        "    'wealth_distribution': 0.4,\n",
        "    'trade_balance': 0.1,\n",
        "    'hidden_economy': 0.4,\n",
        "    'average_age': 0.1\n",
        "}\n",
        "\n",
        "# Function to convert 'class_density' from string to dictionary if necessary\n",
        "def parse_class_density(x):\n",
        "    try:\n",
        "        return ast.literal_eval(x)\n",
        "    except (SyntaxError, ValueError):\n",
        "        return {}\n",
        "\n",
        "# Parse the 'class_density' column into dictionaries\n",
        "idf['class_density'] = idf['class_density'].apply(parse_class_density)\n",
        "\n",
        "# Normalize 'hidden_economy' between 0 and 1\n",
        "max_hidden_economy = idf['hidden_economy'].max()\n",
        "min_hidden_economy = idf['hidden_economy'].min()\n",
        "idf['normalized_hidden_economy'] = (idf['hidden_economy'] - min_hidden_economy) / (max_hidden_economy - min_hidden_economy)\n",
        "\n",
        "# normalize average age\n",
        "max_age = idf['average_age'].max()\n",
        "min_age = idf['average_age'].min()\n",
        "idf['normalized_age'] = (idf['average_age'] - min_age) / (max_age - min_age)\n",
        "\n",
        "# Calculate the inverted normalized age\n",
        "idf['inverted_normalized_age'] = 1 - idf['normalized_age']\n",
        "\n",
        "# Normalize 'wealth' between 0 and 1 (assuming 'wealth' is a column in your DataFrame)\n",
        "max_wealth = idf['settlement_economy'].max()\n",
        "min_wealth = idf['settlement_economy'].min()\n",
        "idf['normalized_wealth'] = (idf['settlement_economy'] - min_wealth) / (max_wealth - min_wealth)\n",
        "\n",
        "# Now calculate the inequality score\n",
        "idf['inequality_score'] = (\n",
        "    weights['wealth_distribution'] * idf['normalized_wealth'] +\n",
        "    weights['trade_balance'] * idf['normalized_trade_balance'] +\n",
        "    weights['hidden_economy'] * idf['normalized_hidden_economy'] +\n",
        "    weights['average_age'] * idf['inverted_normalized_age']\n",
        ")\n",
        "\n",
        "# Fill NaN values with 0 before converting to int\n",
        "idf['inequality_score'] = idf['inequality_score'].fillna(0) * 100\n",
        "\n",
        "# Now safely convert to int\n",
        "idf['inequality_score'] = idf['inequality_score'].astype(int)\n",
        "\n",
        "# Generate random factors as a numpy array for performance\n",
        "random_factors = np.random.uniform(0.95, 1.05, idf.shape[0])\n",
        "\n",
        "# Multiply inequality_score by the random factor for each row, vectorized operation\n",
        "idf['inequality_score'] *= random_factors\n",
        "\n",
        "# Convert inequality score to a more manageable range if necessary, e.g., 0-100\n",
        "#idf['inequality_score'] = (idf['inequality_score'] * 100).astype(int)\n",
        "\n",
        "# Check the head of the updated DataFrame\n",
        "idf[['class_density', 'normalized_wealth', 'inequality_score']].head()"
      ],
      "metadata": {
        "id": "ubauBdW5MPB6",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 206
        },
        "outputId": "ecf9db7b-5756-4957-8baf-020144a383a6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "                                       class_density  normalized_wealth  \\\n",
              "0  {'Aristocratic': 0, 'Wealthy': 3, 'Comfortable...       2.355825e-07   \n",
              "1  {'Aristocratic': 0, 'Wealthy': 2, 'Comfortable...       1.225029e-07   \n",
              "2  {'Aristocratic': 0, 'Wealthy': 7, 'Comfortable...       3.360978e-07   \n",
              "3  {'Aristocratic': 0, 'Wealthy': 2, 'Comfortable...       1.225029e-07   \n",
              "4  {'Aristocratic': 197, 'Wealthy': 1003, 'Comfor...       2.497216e-03   \n",
              "\n",
              "   inequality_score  \n",
              "0          7.990880  \n",
              "1          8.222365  \n",
              "2          8.291196  \n",
              "3          7.632881  \n",
              "4          8.588761  "
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-cc21184e-176b-4c74-9775-e121c5b862e6\" class=\"colab-df-container\">\n",
              "    <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>class_density</th>\n",
              "      <th>normalized_wealth</th>\n",
              "      <th>inequality_score</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>{'Aristocratic': 0, 'Wealthy': 3, 'Comfortable...</td>\n",
              "      <td>2.355825e-07</td>\n",
              "      <td>7.990880</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>{'Aristocratic': 0, 'Wealthy': 2, 'Comfortable...</td>\n",
              "      <td>1.225029e-07</td>\n",
              "      <td>8.222365</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>{'Aristocratic': 0, 'Wealthy': 7, 'Comfortable...</td>\n",
              "      <td>3.360978e-07</td>\n",
              "      <td>8.291196</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>{'Aristocratic': 0, 'Wealthy': 2, 'Comfortable...</td>\n",
              "      <td>1.225029e-07</td>\n",
              "      <td>7.632881</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>{'Aristocratic': 197, 'Wealthy': 1003, 'Comfor...</td>\n",
              "      <td>2.497216e-03</td>\n",
              "      <td>8.588761</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "    <div class=\"colab-df-buttons\">\n",
              "\n",
              "  <div class=\"colab-df-container\">\n",
              "    <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-cc21184e-176b-4c74-9775-e121c5b862e6')\"\n",
              "            title=\"Convert this dataframe to an interactive table.\"\n",
              "            style=\"display:none;\">\n",
              "\n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\" viewBox=\"0 -960 960 960\">\n",
              "    <path d=\"M120-120v-720h720v720H120Zm60-500h600v-160H180v160Zm220 220h160v-160H400v160Zm0 220h160v-160H400v160ZM180-400h160v-160H180v160Zm440 0h160v-160H620v160ZM180-180h160v-160H180v160Zm440 0h160v-160H620v160Z\"/>\n",
              "  </svg>\n",
              "    </button>\n",
              "\n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    .colab-df-buttons div {\n",
              "      margin-bottom: 4px;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "    <script>\n",
              "      const buttonEl =\n",
              "        document.querySelector('#df-cc21184e-176b-4c74-9775-e121c5b862e6 button.colab-df-convert');\n",
              "      buttonEl.style.display =\n",
              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "      async function convertToInteractive(key) {\n",
              "        const element = document.querySelector('#df-cc21184e-176b-4c74-9775-e121c5b862e6');\n",
              "        const dataTable =\n",
              "          await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                    [key], {});\n",
              "        if (!dataTable) return;\n",
              "\n",
              "        const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "          '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "          + ' to learn more about interactive tables.';\n",
              "        element.innerHTML = '';\n",
              "        dataTable['output_type'] = 'display_data';\n",
              "        await google.colab.output.renderOutput(dataTable, element);\n",
              "        const docLink = document.createElement('div');\n",
              "        docLink.innerHTML = docLinkHtml;\n",
              "        element.appendChild(docLink);\n",
              "      }\n",
              "    </script>\n",
              "  </div>\n",
              "\n",
              "\n",
              "<div id=\"df-c8ebffce-c948-47af-aff7-862354a9f7ee\">\n",
              "  <button class=\"colab-df-quickchart\" onclick=\"quickchart('df-c8ebffce-c948-47af-aff7-862354a9f7ee')\"\n",
              "            title=\"Suggest charts\"\n",
              "            style=\"display:none;\">\n",
              "\n",
              "<svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "     width=\"24px\">\n",
              "    <g>\n",
              "        <path d=\"M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z\"/>\n",
              "    </g>\n",
              "</svg>\n",
              "  </button>\n",
              "\n",
              "<style>\n",
              "  .colab-df-quickchart {\n",
              "      --bg-color: #E8F0FE;\n",
              "      --fill-color: #1967D2;\n",
              "      --hover-bg-color: #E2EBFA;\n",
              "      --hover-fill-color: #174EA6;\n",
              "      --disabled-fill-color: #AAA;\n",
              "      --disabled-bg-color: #DDD;\n",
              "  }\n",
              "\n",
              "  [theme=dark] .colab-df-quickchart {\n",
              "      --bg-color: #3B4455;\n",
              "      --fill-color: #D2E3FC;\n",
              "      --hover-bg-color: #434B5C;\n",
              "      --hover-fill-color: #FFFFFF;\n",
              "      --disabled-bg-color: #3B4455;\n",
              "      --disabled-fill-color: #666;\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart {\n",
              "    background-color: var(--bg-color);\n",
              "    border: none;\n",
              "    border-radius: 50%;\n",
              "    cursor: pointer;\n",
              "    display: none;\n",
              "    fill: var(--fill-color);\n",
              "    height: 32px;\n",
              "    padding: 0;\n",
              "    width: 32px;\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart:hover {\n",
              "    background-color: var(--hover-bg-color);\n",
              "    box-shadow: 0 1px 2px rgba(60, 64, 67, 0.3), 0 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "    fill: var(--button-hover-fill-color);\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart-complete:disabled,\n",
              "  .colab-df-quickchart-complete:disabled:hover {\n",
              "    background-color: var(--disabled-bg-color);\n",
              "    fill: var(--disabled-fill-color);\n",
              "    box-shadow: none;\n",
              "  }\n",
              "\n",
              "  .colab-df-spinner {\n",
              "    border: 2px solid var(--fill-color);\n",
              "    border-color: transparent;\n",
              "    border-bottom-color: var(--fill-color);\n",
              "    animation:\n",
              "      spin 1s steps(1) infinite;\n",
              "  }\n",
              "\n",
              "  @keyframes spin {\n",
              "    0% {\n",
              "      border-color: transparent;\n",
              "      border-bottom-color: var(--fill-color);\n",
              "      border-left-color: var(--fill-color);\n",
              "    }\n",
              "    20% {\n",
              "      border-color: transparent;\n",
              "      border-left-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "    }\n",
              "    30% {\n",
              "      border-color: transparent;\n",
              "      border-left-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "      border-right-color: var(--fill-color);\n",
              "    }\n",
              "    40% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "    }\n",
              "    60% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "    }\n",
              "    80% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "      border-bottom-color: var(--fill-color);\n",
              "    }\n",
              "    90% {\n",
              "      border-color: transparent;\n",
              "      border-bottom-color: var(--fill-color);\n",
              "    }\n",
              "  }\n",
              "</style>\n",
              "\n",
              "  <script>\n",
              "    async function quickchart(key) {\n",
              "      const quickchartButtonEl =\n",
              "        document.querySelector('#' + key + ' button');\n",
              "      quickchartButtonEl.disabled = true;  // To prevent multiple clicks.\n",
              "      quickchartButtonEl.classList.add('colab-df-spinner');\n",
              "      try {\n",
              "        const charts = await google.colab.kernel.invokeFunction(\n",
              "            'suggestCharts', [key], {});\n",
              "      } catch (error) {\n",
              "        console.error('Error during call to suggestCharts:', error);\n",
              "      }\n",
              "      quickchartButtonEl.classList.remove('colab-df-spinner');\n",
              "      quickchartButtonEl.classList.add('colab-df-quickchart-complete');\n",
              "    }\n",
              "    (() => {\n",
              "      let quickchartButtonEl =\n",
              "        document.querySelector('#df-c8ebffce-c948-47af-aff7-862354a9f7ee button');\n",
              "      quickchartButtonEl.style.display =\n",
              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "    })();\n",
              "  </script>\n",
              "</div>\n",
              "    </div>\n",
              "  </div>\n"
            ]
          },
          "metadata": {},
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "idf['inequality_score'].describe()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8WENYKEyMppW",
        "outputId": "cfb75683-581f-4039-f153-c269e1fa322f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "count    849.000000\n",
              "mean       9.193708\n",
              "std        4.466732\n",
              "min        0.000000\n",
              "25%        8.154383\n",
              "50%        8.763610\n",
              "75%        9.157462\n",
              "max       91.627572\n",
              "Name: inequality_score, dtype: float64"
            ]
          },
          "metadata": {},
          "execution_count": 33
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Tax Rate"
      ],
      "metadata": {
        "id": "P-zVxTEPOe7T"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Calculate a base tax rate for each region based on the number of aristocrats\n",
        "def calculate_base_tax_rate(aristocrats_per_region):\n",
        "    # You can introduce more sophisticated logic here based on your dataset\n",
        "    return aristocrats_per_region.apply(lambda x: 10 if x < 50 else (20 if x < 100 else 30))\n",
        "\n",
        "base_tax_rate_per_region = calculate_base_tax_rate(aristocrats_per_region)\n",
        "\n",
        "def calculate_tax_rate(row, aristocrats_per_region, base_tax_rate_per_region):\n",
        "    # Check if the region has a capital\n",
        "    has_capital = pd.notnull(row['capital'])\n",
        "\n",
        "    # Use the regional base tax rate if there's no capital, else use the detailed calculation\n",
        "    if not has_capital:\n",
        "        # Introduce zero tax for some settlements randomly or based on a condition\n",
        "        return 0 if np.random.rand() < 0.1 else base_tax_rate_per_region[row['region']]\n",
        "\n",
        "    region_imports = len(row['imports']) if isinstance(row['imports'], list) else 0\n",
        "    region_exports = len(row['exports']) if isinstance(row['exports'], list) else 0\n",
        "    region_aristocrats = aristocrats_per_region[row['region']]\n",
        "\n",
        "    # Base tax rate conditions\n",
        "    base_conditions = [\n",
        "        row['military'] and region_aristocrats >= 50,\n",
        "        region_aristocrats >= 100\n",
        "    ]\n",
        "\n",
        "    # Base tax rates corresponding to the above conditions\n",
        "    base_tax_rates = [\n",
        "        np.random.randint(20, 61),\n",
        "        np.random.randint(10, 31)\n",
        "    ]\n",
        "\n",
        "    # If conditions are not met, use the region's base tax rate\n",
        "    tax_rate = np.select(base_conditions, base_tax_rates, default=base_tax_rate_per_region[row['region']])\n",
        "\n",
        "    # Calculate multiplier based on trade volume\n",
        "    trade_volume = region_imports + region_exports\n",
        "    trade_multiplier = 1 + (trade_volume / 100)\n",
        "\n",
        "    # Apply the multiplier to the tax rate\n",
        "    return round(tax_rate * trade_multiplier)\n",
        "\n",
        "# Apply the calculate_tax_rate function to create the tax_rate column\n",
        "df['tax_rate'] = df.apply(lambda row: calculate_tax_rate(row, aristocrats_per_region, base_tax_rate_per_region), axis=1)"
      ],
      "metadata": {
        "id": "Lxjpkuz5NqP5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "df['tax_rate'].describe()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "76K2fllfU-7n",
        "outputId": "2f0726f8-ce8d-4d96-d5bf-e7ed7a29ff88"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "count    849.000000\n",
              "mean      30.480565\n",
              "std       15.561500\n",
              "min        0.000000\n",
              "25%       21.000000\n",
              "50%       30.000000\n",
              "75%       42.000000\n",
              "max       60.000000\n",
              "Name: tax_rate, dtype: float64"
            ]
          },
          "metadata": {},
          "execution_count": 38
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Group by 'region' and sum the 'inequality_score' for each region\n",
        "region_inequality_sum = idf.groupby('region')['inequality_score'].sum()\n",
        "\n",
        "# Sort the regions by the summed inequality score in descending order and take the top 10\n",
        "top_10_inequal_regions = region_inequality_sum.sort_values(ascending=False).head(10)\n",
        "\n",
        "# Print the top 10 most unequal regions\n",
        "print(\"Top 10 Most Unequal Regions:\")\n",
        "print(top_10_inequal_regions)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UqqXdKHorafi",
        "outputId": "153acec0-427f-40dd-a0f5-108f826b9657"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Top 10 Most Unequal Regions:\n",
            "region\n",
            "The Sword Coast               985.994628\n",
            "The Eastern Shaar             468.745737\n",
            "Halruaa                       355.320586\n",
            "Thay                          327.485620\n",
            "Dambrath                      288.172063\n",
            "Murghom                       269.368888\n",
            "Damara                        263.404874\n",
            "Tethyr                        258.069974\n",
            "The Moonshae Isles            253.114499\n",
            "The Great Glaciar Pelvuria    250.354155\n",
            "Name: inequality_score, dtype: float64\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Group by 'region' and sum the 'inequality_score' for each region\n",
        "region_inequality_sum = idf.groupby('settlement')['inequality_score'].sum()\n",
        "\n",
        "# Sort the regions by the summed inequality score in descending order and take the top 10\n",
        "top_10_inequal_regions = region_inequality_sum.sort_values(ascending=False).head(10)\n",
        "\n",
        "# Print the top 10 most unequal regions\n",
        "print(\"Top 10 Most Unequal Settlements:\")\n",
        "print(top_10_inequal_regions)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qH3FhmFH-UgV",
        "outputId": "cab2ab18-7fb6-459a-ed42-2bc9a957695f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Top 10 Most Unequal Settlements:\n",
            "settlement\n",
            "Waterdeep             91.627572\n",
            "Darromar              71.991158\n",
            "Thaymount             57.833094\n",
            "Cathyr                22.941688\n",
            "Bloodstone Village    21.443902\n",
            "Taruin                21.316120\n",
            "Rassatan              20.858166\n",
            "Elveswatch            19.689059\n",
            "Prastuil              19.627946\n",
            "Purl                  19.509598\n",
            "Name: inequality_score, dtype: float64\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Adjusting Average Age"
      ],
      "metadata": {
        "id": "XQvZB8rcOlKg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Calculate the regional average of the inequality score\n",
        "region_inequality_avg = idf.groupby('region')['inequality_score'].mean()\n",
        "\n",
        "# Define the minimum and maximum age for each region\n",
        "idf['region_min_age'] = idf.groupby('region')['average_age'].transform('min')\n",
        "idf['region_max_age'] = idf.groupby('region')['average_age'].transform('max')\n",
        "\n",
        "# Define a function to adjust average_age based on regional inequality score\n",
        "def adjust_average_age(row):\n",
        "    # Access the region's average inequality score\n",
        "    avg_inequality_score = region_inequality_avg[row['region']]\n",
        "\n",
        "    # Define a scaling factor to control the adjustment\n",
        "    scaling_factor = 2  # Adjust this value as needed\n",
        "\n",
        "    # Calculate the adjusted average age\n",
        "    adjusted_age = row['average_age'] - scaling_factor * (row['inequality_score'] - avg_inequality_score)\n",
        "\n",
        "    # Ensure the adjusted age is within the reasonable range for the region\n",
        "    adjusted_age = max(min(adjusted_age, row['region_max_age']), row['region_min_age'])\n",
        "\n",
        "    return adjusted_age\n",
        "\n",
        "# Apply the adjustment function to the DataFrame\n",
        "idf['adjusted_average_age'] = idf.apply(adjust_average_age, axis=1)\n",
        "\n",
        "# Ensure the 'capital' column is a string for comparison\n",
        "idf['capital'] = idf['capital'].astype(str)\n",
        "\n",
        "# List of all unique capitals\n",
        "capitals = idf['capital'].unique()\n",
        "\n",
        "# Filter out the capitals from the settlements\n",
        "non_capital_settlements = idf[~idf['settlement'].isin(capitals)]\n",
        "\n",
        "# Randomly choose 10 settlements to add +50, ensuring they are not capitals\n",
        "add_settlements = non_capital_settlements.sample(n=10, random_state=1).index\n",
        "\n",
        "# Randomly choose 5 settlements to subtract -30, ensuring they are not capitals and not in the add_settlements\n",
        "subtract_settlements = non_capital_settlements.drop(index=add_settlements).sample(n=5, random_state=1).index\n",
        "\n",
        "# Add +50 to the chosen settlements' 'adjusted_average_age'\n",
        "idf.loc[add_settlements, 'adjusted_average_age'] += 50\n",
        "\n",
        "# Subtract 30 from the chosen settlements' 'adjusted_average_age'\n",
        "idf.loc[subtract_settlements, 'adjusted_average_age'] -= 30\n",
        "\n",
        "# Convert the 'adjusted_average_age' column to integers\n",
        "idf['adjusted_average_age'] = idf['adjusted_average_age'].astype(int)\n"
      ],
      "metadata": {
        "id": "7hWlEqrX3guH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "idf['adjusted_average_age'].head(50)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uINb0lw749x7",
        "outputId": "c3884f3f-93bc-4aa5-a7fc-2e404b9ec962"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0     73.965063\n",
              "1     49.502092\n",
              "2     89.364432\n",
              "3     69.681061\n",
              "4     39.769302\n",
              "5     93.000000\n",
              "6     34.000000\n",
              "7     36.818603\n",
              "8     37.532320\n",
              "9     64.836528\n",
              "10    65.068506\n",
              "11    38.749634\n",
              "12    45.154504\n",
              "13    40.429589\n",
              "14    34.000000\n",
              "15    36.456795\n",
              "16    51.149453\n",
              "17    39.556512\n",
              "18    46.679196\n",
              "19    35.310185\n",
              "20    27.158501\n",
              "21    43.538021\n",
              "22    36.137848\n",
              "23    46.000000\n",
              "24    42.897852\n",
              "25    38.820286\n",
              "26    41.580232\n",
              "27    41.990093\n",
              "28    30.000000\n",
              "29    39.084224\n",
              "30    52.000000\n",
              "31    23.922251\n",
              "32    52.000000\n",
              "33    45.236065\n",
              "34    40.129527\n",
              "35    31.691232\n",
              "36    52.000000\n",
              "37    44.772581\n",
              "38    21.000000\n",
              "39    40.363313\n",
              "40    36.411043\n",
              "41    35.315342\n",
              "42    37.058807\n",
              "43    37.696814\n",
              "44    33.994193\n",
              "45    41.022458\n",
              "46    34.993388\n",
              "47    41.197285\n",
              "48    49.474776\n",
              "49    43.060545\n",
              "Name: adjusted_average_age, dtype: float64"
            ]
          },
          "metadata": {},
          "execution_count": 49
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "df['average_age'] = idf['adjusted_average_age']"
      ],
      "metadata": {
        "id": "7NeBtJnYEbRe"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Temperature and Climate"
      ],
      "metadata": {
        "id": "Lu91TlfdOqkE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "region_climate = {\n",
        "    'Aglarond': 'Temperate',\n",
        "    'Akanul': 'Temperate',\n",
        "    'Altumbel': 'Temperate',\n",
        "    'Amn': 'Temperate',\n",
        "    'Anauroch': 'Arid',\n",
        "    'Calimshan': 'Arid',\n",
        "    'Chessenta': 'Temperate',\n",
        "    'Cormanthyr': 'Temperate',\n",
        "    'Cormyr': 'Temperate',\n",
        "    'Dalelands': 'Temperate',\n",
        "    'Damara': 'Cold',\n",
        "    'Dambrath': 'Temperate',\n",
        "    'The Sword Coast': 'Temperate',\n",
        "    'Elturgard': 'Temperate',\n",
        "    'Erlkazar': 'Temperate',\n",
        "    'Evereska': 'Temperate',\n",
        "    'Halruaa': 'Temperate',\n",
        "    'Hartsvale': 'Cold',\n",
        "    'Icewind Dale': 'Frigid',\n",
        "    'Impiltur': 'Temperate',\n",
        "    'Jungles of Chult': 'Jungle/Marsh',\n",
        "    'Lantan': 'Temperate',\n",
        "    'Luiren': 'Temperate',\n",
        "    'Mulhorand': 'Arid',\n",
        "    'Muranndin': 'Temperate',\n",
        "    'Murghom': 'Arid',\n",
        "    'Najara': 'Temperate',\n",
        "    'Narfell': 'Cold',\n",
        "    'Nelanther Isles': 'Temperate',\n",
        "    'Okoth': 'Arid',\n",
        "    'The Eastern Shaar': 'Arid',\n",
        "    'Rashemen': 'Cold',\n",
        "    'Ruathym': 'Cold',\n",
        "    'Samarach': 'Jungle/Marsh',\n",
        "    'Sembia': 'Temperate',\n",
        "    'Serpentes': 'Temperate',\n",
        "    'Sespech': 'Temperate',\n",
        "    'Tashalar': 'Temperate',\n",
        "    'Tethyr': 'Temperate',\n",
        "    'Tharsult': 'Arid',\n",
        "    'Thay': 'Arid',\n",
        "    'The Endless Wastes': 'Arid',\n",
        "    'Sossal': 'Cold',\n",
        "    'The Great Dale': 'Temperate',\n",
        "    'The Great Glacier Pelvuria': 'Frigid',\n",
        "    'The Lake of Steam': 'Temperate',\n",
        "    'The Moonshae Isles': 'Jungle/Marsh',\n",
        "    'The Purple Rocks': 'Temperate',\n",
        "    'The Ride': 'Temperate',\n",
        "    'Thar': 'Arid',\n",
        "    'The Sea of Fallen Stars': 'Temperate',\n",
        "    'The Shining Lands': 'Temperate',\n",
        "    'The Shining Sea': 'Temperate',\n",
        "    'Thesk': 'Temperate',\n",
        "    'Thindol': 'Temperate',\n",
        "    'Tuern': 'Cold',\n",
        "    'Turmish': 'Temperate',\n",
        "    'Tymanther': 'Arid',\n",
        "    'Unther': 'Arid',\n",
        "    'Vaasa': 'Cold',\n",
        "    'Vesperin': 'Temperate'\n",
        "}\n",
        "climate_temperature_range = {\n",
        "    'Arid': [65, 100],  # Temperature range in Fahrenheit\n",
        "    'Cold': [0, 40],\n",
        "    'Frigid':[-40, 10],\n",
        "    'Temperate': [45, 70],\n",
        "    'Jungle/Marsh': [65, 90]\n",
        "}\n",
        "\n",
        "average_rainfall = {\n",
        "    'Arid': [0, 10],  # Rainfall range in inches per year\n",
        "    'Cold': [20, 40],\n",
        "    'Frigid':[0, 20],\n",
        "    'Temperate': [30, 50],\n",
        "    'Jungle/Marsh': [45, 65]\n",
        "}\n",
        "\n",
        "def assign_climate_attributes(row):\n",
        "    try:\n",
        "        # Extract climate from region\n",
        "        climate = region_climate.get(row['region'], 'Temperate')  # Default to 'Temperate' if region is not found\n",
        "\n",
        "        # Get temperature and rainfall ranges for the climate\n",
        "        temp_range = climate_temperature_range[climate]\n",
        "        rainfall_range = average_rainfall[climate]\n",
        "\n",
        "        # Randomly assign values within the ranges\n",
        "        average_temp = random.uniform(temp_range[0], temp_range[1])\n",
        "        annual_rainfall = random.uniform(rainfall_range[0], rainfall_range[1])\n",
        "\n",
        "        return average_temp, annual_rainfall\n",
        "\n",
        "    except Exception as e:\n",
        "        print(f\"Error assigning climate attributes for row: {e}\")\n",
        "        return None\n",
        "\n",
        "# Apply the function to the DataFrame\n",
        "df['average_temperature'], df['annual_rainfall'] = zip(*df.apply(assign_climate_attributes, axis=1))\n"
      ],
      "metadata": {
        "id": "JOfZZ0c76Bqa"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Magic Academies"
      ],
      "metadata": {
        "id": "-FzPPKHOOv97"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "wizard_schools = {\n",
        "    'Arrabar': 'Academia Vilhonus',\n",
        "    'Chondath': 'Academia Vilhonus',\n",
        "    'Thay': 'Academy of Shapers and Binders',\n",
        "    ' Waterdeep': 'Academy of Stargazers',\n",
        "    'Mintar': 'Academy of the Drawn Sword',\n",
        "    ' Lake of Steam': 'Academy of the Drawn Sword',\n",
        "    'Seventon': \"Alimon's Mental Academy\",\n",
        "    'Netheril': \"Alimon's Mental Academy\",\n",
        "    'Sundabar': 'Anstruth',\n",
        "    'Gheldaneth': 'Arcanum of Magic',\n",
        "    'Mulhorand': 'Arcanum of Magic',\n",
        "    'Silverymoon': \"Arkhen's Invocatorium\",\n",
        "    'Huzuz': \"Al-Bidir Sallah (Home of the Seekers of Knowledge)\",\n",
        "    'Zakhara': \"Al-Bidir Sallah (Home of the Seekers of Knowledge)\",\n",
        "    'Waterdeep': 'Blackstaff Academy',\n",
        "    'Luskan': 'Blackstaff Academy',\n",
        "    'Baldurs Gate': \"Briel's School of the Arcane\",\n",
        "    'The Sword Coast': \"Briels School of the Arcane\",\n",
        "    'Zazesspur': 'Canaith',\n",
        "    'Tethyr': 'Canaith',\n",
        "    'Evereska': 'College of Magic and Arms',\n",
        "    'The Sword Coast Faerûn': 'College of Magic and Arms',\n",
        "    'Heralds Holdfast': 'College of the Herald',\n",
        "    'Berdusk': 'College of Doss',\n",
        "    'Myth Nantar': \"Dukars' Academy\",\n",
        "    'Waterdeep': 'Dweomercore',\n",
        "    'Waterdeep': 'Eltorchul Academy',\n",
        "    'Loudwater': \"Enalin's Shop of Adventurers' Supplies\",\n",
        "    'Delimbiyr Vale': \"Enalin's Shop of Adventurers' Supplies\",\n",
        "    'Heliogabalus': 'Ends Rest',\n",
        "    'Heldapan': 'Gathering of Magicians',\n",
        "    'Durpar': 'Gathering of Magicians',\n",
        "    'Akkaido': 'Golden Fox Martial Arts School',\n",
        "    'Huzuz': 'Grand University of Huzuz',\n",
        "    'Medina al-Afyal': 'Great Mosque of Selan',\n",
        "    'Island of Afyal': 'Great Mosque of Selan',\n",
        "    'Almorel': 'Great School of Deneir',\n",
        "    'Waterdeep': 'Halasters Heirs',\n",
        "    'Evereska': 'Hall of the Kaliesherai',\n",
        "    'Waterdeep': 'House of Healing'\n",
        "}\n",
        "\n",
        "def assign_magic_academy(row):\n",
        "    settlement = row['settlement']\n",
        "    if settlement in wizard_schools:\n",
        "        return wizard_schools[settlement]\n",
        "    else:\n",
        "        return 'None'  # Fill with 'None' if there's no school\n",
        "\n",
        "# Assuming you have a DataFrame named df\n",
        "df['magic_academy'] = df.apply(assign_magic_academy, axis=1)\n",
        "\n",
        "# To keep track of schools that do not get placed\n",
        "unplaced_schools = [school for school in wizard_schools.values() if school not in df['magic_academy'].unique()]\n",
        "\n",
        "# Print unplaced schools\n",
        "print(\"Unplaced Schools:\", unplaced_schools)"
      ],
      "metadata": {
        "id": "ZUQM9qK5unBb",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "16c509c4-a668-4175-f075-20267d4a9b78"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Unplaced Schools: ['Academia Vilhonus', 'Academia Vilhonus', 'Academy of Shapers and Binders', 'Academy of Stargazers', \"Alimon's Mental Academy\", \"Alimon's Mental Academy\", 'Arcanum of Magic', 'Arcanum of Magic', 'Grand University of Huzuz', 'Al-Bidir Sallah (Home of the Seekers of Knowledge)', \"Briel's School of the Arcane\", 'Briels School of the Arcane', 'College of Magic and Arms', 'College of the Herald', \"Dukars' Academy\", \"Enalin's Shop of Adventurers' Supplies\", \"Enalin's Shop of Adventurers' Supplies\", 'Gathering of Magicians', 'Gathering of Magicians', 'Golden Fox Martial Arts School', 'Great Mosque of Selan', 'Great Mosque of Selan']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def add_magic_academy(df):\n",
        "    def check_population(row):\n",
        "        if row['settlement_population'] > 15000 and row['magic_academy'] == 'None':\n",
        "            # If population is over 10000 and academy is 'None', replace it with 'guilds'\n",
        "            return 'guilds'\n",
        "        return row['magic_academy']\n",
        "\n",
        "    df['magic_academy'] = df.apply(lambda row: check_population(row), axis=1)\n",
        "    return df\n",
        "df = add_magic_academy(df)"
      ],
      "metadata": {
        "id": "g9JMpsJEyncC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Check the count of each unique value in the 'magic_academy' column\n",
        "academy_counts = df['magic_academy'].value_counts()\n",
        "\n",
        "# Check if 'guilds' is in the index of unique values\n",
        "if 'guilds' in academy_counts.index:\n",
        "    # 'guilds' was added, and you can access its count using academy_counts['guilds']\n",
        "    guilds_count = academy_counts['guilds']\n",
        "    print(f\"'guilds' was added {guilds_count} times.\")\n",
        "else:\n",
        "    # 'guilds' was not added\n",
        "    print(\"'guilds' was not added.\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9bRhxTeJPjCv",
        "outputId": "86b9af26-cdb1-4c6e-a8a5-e880af21531d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "'guilds' was added 117 times.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Magical Climate"
      ],
      "metadata": {
        "id": "uhZ76sHwO2Ap"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Helper function to parse demographic breakdown\n",
        "def parse_demographic_breakdown(x):\n",
        "    if isinstance(x, dict):\n",
        "        return x\n",
        "    try:\n",
        "        return ast.literal_eval(x)\n",
        "    except (ValueError, SyntaxError):\n",
        "        return {}\n",
        "\n",
        "# Apply the helper function to the 'demographic_breakdown' column\n",
        "idf['demographic_breakdown'] = idf['demographic_breakdown'].apply(parse_demographic_breakdown)\n",
        "\n",
        "# Vectorized calculations for non-human count and total population\n",
        "demographics = pd.DataFrame(idf['demographic_breakdown'].tolist()).fillna(0)\n",
        "idf['non_human_count'] = demographics.apply(lambda row: row.drop('Human', errors='ignore').sum(), axis=1)\n",
        "idf['total_population_from_demo'] = demographics.sum(axis=1)\n",
        "\n",
        "# Vectorized calculation for non-human proportion\n",
        "idf['non_human_proportion'] = np.divide(idf['non_human_count'], idf['total_population_from_demo'], out=np.zeros_like(idf['non_human_count']), where=idf['total_population_from_demo'] != 0)\n",
        "\n",
        "# Score for magic academy presence\n",
        "idf['academy_score'] = idf['magic_academy'].notna().astype(int) * 30\n",
        "\n",
        "# Normalize and score calculations with vectorized operations\n",
        "min_age, max_age = idf['average_age'].min(), idf['average_age'].max()\n",
        "mean_inequality, std_inequality = idf['inequality_score'].mean(), idf['inequality_score'].std()\n",
        "min_non_human_proportion, max_non_human_proportion = idf['non_human_proportion'].min(), idf['non_human_proportion'].max()\n",
        "\n",
        "random_factors = np.random.uniform(1, 5, (len(idf), 4))\n",
        "\n",
        "moderate_temp = 70\n",
        "\n",
        "idf['age_score'] = random_factors[:, 0] * ((idf['average_age'] - min_age) / (max_age - min_age))\n",
        "idf['inequality_score'] = random_factors[:, 1] * ((idf['inequality_score'] - mean_inequality) / std_inequality)\n",
        "idf['temperature_score'] = random_factors[:, 2] * (idf.get('average_temperature', 0) - moderate_temp)\n",
        "idf['non_human_score'] = random_factors[:, 3] * ((idf['non_human_proportion'] - min_non_human_proportion) / (max_non_human_proportion - min_non_human_proportion))\n",
        "\n",
        "# Normalize each score to be between 1 and its respective scale factor\n",
        "scales = np.array([24, 19, 34, 29])  # Subtracting one because we add one below\n",
        "idf[['age_score', 'inequality_score', 'temperature_score', 'non_human_score']] = (\n",
        "    1 + scales * (idf[['age_score', 'inequality_score', 'temperature_score', 'non_human_score']] -\n",
        "    idf[['age_score', 'inequality_score', 'temperature_score', 'non_human_score']].min()) /\n",
        "    (idf[['age_score', 'inequality_score', 'temperature_score', 'non_human_score']].max() -\n",
        "    idf[['age_score', 'inequality_score', 'temperature_score', 'non_human_score']].min())\n",
        ")\n",
        "\n",
        "# Sum up the normalized scores to get the magical_climate\n",
        "idf['magical_climate'] = idf[['academy_score', 'age_score', 'inequality_score', 'temperature_score', 'non_human_score']].sum(axis=1)\n",
        "\n",
        "# Optional: Clip the total score if necessary\n",
        "idf['magical_climate'] = idf['magical_climate'].round().clip(lower=4, upper=100)"
      ],
      "metadata": {
        "id": "h0r0dk0BC3iu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "df['magical_climate'] = idf['magical_climate']"
      ],
      "metadata": {
        "id": "zTmJYfEDR7gy"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Dragon Sightings"
      ],
      "metadata": {
        "id": "B_X8piFrPehC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Step 1: Calculate Region Totals\n",
        "region_totals = idf.groupby('region')['hidden_economy', 'magical_climate'].sum().reset_index()\n",
        "\n",
        "# Step 2: Allocate Dragon Sightings to Regions\n",
        "total_dragon_sightings = 1000\n",
        "region_totals['total_score'] = region_totals['hidden_economy'] + region_totals['magical_climate']\n",
        "region_totals['allocated_dragon_sightings'] = (region_totals['total_score'] / region_totals['total_score'].sum()) * total_dragon_sightings\n",
        "\n",
        "# Step 3: Merge the allocated_dragon_sightings to the original DataFrame\n",
        "idf = idf.merge(region_totals[['region', 'allocated_dragon_sightings']], on='region', how='left')\n",
        "\n",
        "# Step 4: Allocate Dragon Sightings to Settlements\n",
        "idf['settlement_dragon_sightings'] = (idf['magical_climate'] / idf.groupby('region')['magical_climate'].transform('sum')) * idf['allocated_dragon_sightings']\n",
        "\n",
        "# Apply Random Factor to Magical Climate and Allocate Dragon Sightings\n",
        "random_factor = np.random.uniform(0.1, 2, size=len(idf))\n",
        "idf['adjusted_magical_climate'] = idf['magical_climate'] * random_factor\n",
        "idf['settlement_dragon_sightings'] = (idf['adjusted_magical_climate'] / idf.groupby('region')['adjusted_magical_climate'].transform('sum')) * idf['allocated_dragon_sightings']\n",
        "\n",
        "# Optional: Round the dragon sightings\n",
        "idf['settlement_dragon_sightings'] = idf['settlement_dragon_sightings'].round().astype(int)"
      ],
      "metadata": {
        "id": "-vBZbUNkktEL",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "48ccad1f-3c89-49c1-9012-9555bb4ae976"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-57-6069af074382>:2: FutureWarning: Indexing with multiple keys (implicitly converted to a tuple of keys) will be deprecated, use a list instead.\n",
            "  region_totals = idf.groupby('region')['hidden_economy', 'magical_climate'].sum().reset_index()\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "df['dragon_sightings'] = idf['settlement_dragon_sightings']"
      ],
      "metadata": {
        "id": "49wXqrpySlPd"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Group by 'region' and sum 'settlement_dragon_sightings'\n",
        "total_dragon_sightings_by_region = idf.groupby('region')['settlement_dragon_sightings'].sum().reset_index()\n",
        "\n",
        "# Optional: Sort values for better visualization\n",
        "total_dragon_sightings_by_region = total_dragon_sightings_by_region.sort_values(by='settlement_dragon_sightings', ascending=False).reset_index(drop=True)\n",
        "\n",
        "# Display the result\n",
        "print(total_dragon_sightings_by_region)"
      ],
      "metadata": {
        "id": "v7Z06YEeSDb8",
        "outputId": "35eb789f-51f6-4dcc-ecc4-bad1d46f05dd",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "             region  settlement_dragon_sightings\n",
            "0   The Sword Coast                          469\n",
            "1            Tethyr                          267\n",
            "2              Thay                          205\n",
            "3         Elturgard                           16\n",
            "4         Mulhorand                            9\n",
            "..              ...                          ...\n",
            "56          Narfell                            0\n",
            "57  Nelanther Isles                            0\n",
            "58            Okoth                            0\n",
            "59         Rashemen                            0\n",
            "60         Vesperin                            0\n",
            "\n",
            "[61 rows x 2 columns]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Step 1\n",
        "# Define a function to get random numbers for settlement sizes\n",
        "def get_random_settlement_size(settlement_type):\n",
        "    size_ranges = {\n",
        "        'tiny_settlement': (5, 15),\n",
        "        'small_settlement': (5, 11),\n",
        "        'medium_settlement': (4, 10),\n",
        "        'large_settlement': (2, 7),\n",
        "        'mega_settlement': (1, 8)\n",
        "    }\n",
        "    return np.random.uniform(*size_ranges[settlement_type])\n",
        "\n",
        "# Apply the function to each settlement_size\n",
        "idf['average_household_size'] = idf['settlement_size'].apply(get_random_settlement_size)\n",
        "idf['average_household_size'].fillna(idf['average_household_size'].mean(), inplace=True)\n",
        "idf['total_households'] = (idf['settlement_population'] / idf['average_household_size']).astype(int)\n",
        "\n",
        "# Step 2\n",
        "# Filter out rows where class_density is not a dictionary\n",
        "idf = idf[idf['class_density'].apply(lambda x: isinstance(x, dict))]\n",
        "\n",
        "# Now you can use dictionary methods to extract values\n",
        "idf[['Wealthy', 'Poor', 'Squalid']] = idf['class_density'].apply(\n",
        "    lambda density: pd.Series((density.get('Wealthy', 0), density.get('Poor', 0), density.get('Squalid', 0)))\n",
        ")\n",
        "\n",
        "# Step 3\n",
        "debt_base = idf['Poor'] * 7 + idf['Squalid'] * 15 - idf['Wealthy'] * 5\n",
        "idf['average_debt_by_household'] = (1 + debt_base * idf['tax_rate'] / idf['total_households']).clip(lower=0)\n",
        "\n",
        "# Ensure the total debt doesn't exceed hidden_economy\n",
        "idf['average_debt_by_household'] = np.where(\n",
        "    idf['average_debt_by_household'] * idf['total_households'] <= idf['hidden_economy'],\n",
        "    idf['average_debt_by_household'],\n",
        "    idf['hidden_economy'] / idf['total_households']\n",
        ")\n",
        "\n",
        "# Drop temporary columns if necessary\n",
        "idf.drop(columns=['Wealthy', 'Poor', 'Squalid', 'total_households'], inplace=True)"
      ],
      "metadata": {
        "id": "Mu5eRvdhbQe-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "idf['average_debt_by_household'].describe()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OUqTmfL7hpUc",
        "outputId": "603e05a8-63aa-455d-94c6-805a73b90682"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "count    849.000000\n",
              "mean       0.515758\n",
              "std        7.617958\n",
              "min        0.000000\n",
              "25%        0.000000\n",
              "50%        0.000000\n",
              "75%        0.018754\n",
              "max      208.831010\n",
              "Name: average_debt_by_household, dtype: float64"
            ]
          },
          "metadata": {},
          "execution_count": 60
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "df['average_debt_by_household'] = idf['average_debt_by_household']"
      ],
      "metadata": {
        "id": "I2vicXa3kGZU"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "idf['military'] = df['military']\n",
        "\n",
        "# Function to determine development_index based on conditions\n",
        "def assign_development_index(row):\n",
        "    options = ['region improvement', 'administration']\n",
        "    if row['military'] != 'None':\n",
        "        options.append('military support')\n",
        "\n",
        "    return random.choice(options)\n",
        "\n",
        "# Applying the function to each row in the DataFrame\n",
        "idf['development_index'] = idf.apply(assign_development_index, axis=1)\n",
        "\n",
        "# If you want each region to have the same development_index, you can group by region and then transform:\n",
        "idf['development_index'] = idf.groupby('region')['development_index'].transform('first')"
      ],
      "metadata": {
        "id": "T2lF-orzncir"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "df['development_index'] = idf['development_index']"
      ],
      "metadata": {
        "id": "OBY0gFeOnjcO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Export DataFrame to Excel\n",
        "df.to_csv(df_file_path, index=False)\n",
        "\n",
        "# Export the idf dataset to a CSV file\n",
        "#idf.to_csv('/content/drive/MyDrive/Colab Notebooks/DnD/idf_dataset.csv', index=False)\n",
        "\n",
        "print(f'DataFrame exported to: {df_file_path}')"
      ],
      "metadata": {
        "id": "bJoLExXu-Iu4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "134acac1-54b3-40a2-fcd8-88457e8bd5e0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "DataFrame exported to: /content/drive/MyDrive/Colab Notebooks/DnD/updated_dataset.csv\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "    data = {\n",
        "            \"Number of Landowners\": np.random.randint(1, 200),\n",
        "            \"Number of Homeowners\": np.random.randint(10, 10000),\n",
        "            \"Average Rent\": np.random.randint(1, 5000),\n",
        "            \"Likelihood of Getting Cursed\": np.random.randint(0, 10),\n",
        "            \"Danger Level\": np.random.randint(0, 10),\n",
        "            \"Openness to Strangers\": np.random.randint(0, 100),\n",
        "            \"Political Climate\": np.random.randint(0, 100),\n",
        "            \"Fate Ranking\": np.random.randint(0, 10),\n",
        "        }\n"
      ],
      "metadata": {
        "id": "uXEXqTrhm8oW"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Adjusting Danger Level\n",
        "df['Danger Level'] = (\n",
        "    df['Dragon Sightings']\n",
        "    + df['Political Climate']\n",
        "    + df['Magical Climate']\n",
        "    + df['Likelihood of Getting Cursed']\n",
        "    + df['Tax Rate']\n",
        "    + df['Average Debt by Household']\n",
        "    + df['Rumored Treasure Value']\n",
        "    + df['Openness to Strangers'].apply(lambda x: 10 if x <= 2.5 or x >= 7.5 else 0)\n",
        ").astype(int)\n",
        "\n",
        "# Increase \"Danger Level\" if Orcs are present\n",
        "df.loc[df['Percentage of population Orcs'] > 0, 'Danger Level'] += 1\n",
        "\n",
        "# Decrease \"Danger Level\" if Elves are present\n",
        "df.loc[df['Percentage of population Elves'] > 0, 'Danger Level'] -= 1\n",
        "\n",
        "# Adjusting Danger Level based on the presence of Orcs and Elves\n",
        "df['Danger Level'] = df.apply(lambda row: np.random.randint(1, 11)\n",
        "                                          + (3 if row['Percentage of population Orcs'] > 0 else 0)\n",
        "                                          - (2 if row['Percentage of population Elves'] > 0 else 0), axis=1)\n",
        "\n",
        "# Adjusting Openness to Strangers\n",
        "df['Openness to Strangers'] = df.apply(lambda row: np.random.randint(0, 11)\n",
        "                                                   - (3 if row['Percentage of population Elves'] > 0\n",
        "                                                       or row['Percentage of population Orcs'] > 0 else 0), axis=1)\n",
        "\n",
        "# Adjusting Magical Climate\n",
        "df['Magical Climate'] = df.apply(lambda row: row['Magical Climate']\n",
        "                                             + (row['Percentage of population Elves'] / 100 * 2)\n",
        "                                             + (row['Dragon Sightings'] / 10)\n",
        "                                             + row['Number of Active Wizards'], axis=1)\n",
        "\n",
        "# Pre-calculation of sum values\n",
        "grouped = df.groupby('Region')\n",
        "region_gold_mapping = grouped[['Active Economy (Gold)', 'Hidden Economy (Gold)']].sum(numeric_only=True).sum(axis=1)\n",
        "df['Total Gold in Region'] = df['Region'].map(region_gold_mapping)\n",
        "\n",
        "# Main DataFrame Manipulations\n",
        "df['Dragon Sightings'] = df.apply(calculate_dragon_sightings, axis=1)\n",
        "df['Dragon Sightings'] = ((df['Dragon Sightings'] - df['Dragon Sightings'].min()) /\n",
        "                          (df['Dragon Sightings'].max() - df['Dragon Sightings'].min()) * 50).astype(int)\n",
        "\n",
        "df['Average Age of Population'] = df.apply(lambda row: calculate_average_age(row, species_age_ranges), axis=1)\n",
        "df['Average Age of Population'] -= df['Danger Level'] * 0.5\n",
        "df['Average Age of Population'] = df['Average Age of Population'].clip(lower=1)\n",
        "\n",
        "df['Hidden Economy (Gold)'] = df['Number of Nobility'] * 1e4\n",
        "df['Openness to Strangers'] = df.apply(calculate_openness_to_strangers, axis=1)\n",
        "\n",
        "# Adjusting population distribution for specific species across cities\n",
        "def adjust_population_distribution(df, species, percentage, city_count):\n",
        "    total_population = df['Population of City'].sum()\n",
        "    target_population = int(total_population * (percentage / 100))\n",
        "    selected_cities = df.sample(city_count)\n",
        "    each_city_population = target_population // city_count\n",
        "    for i, city in selected_cities.iterrows():\n",
        "        df.at[i, f'Percentage of population {species}'] = (each_city_population / city['Population of City']) * 100\n",
        "\n",
        "# Adjusting Economy Distribution\n",
        "total_active_economy = np.sum(df['Active Economy (Gold)'])\n",
        "top_10_cities_active_economy = total_active_economy * 0.50\n",
        "next_100_cities_active_economy = total_active_economy * 0.25\n",
        "remaining_cities_active_economy = total_active_economy * 0.25\n",
        "\n",
        "# Known Treasure and Rumored Treasure Calculations\n",
        "df['Known Treasure'] = df['Active Economy (Gold)'] * 0.50\n",
        "df['Rumored Treasure'] = (df['Active Economy (Gold)'] * 0.50) + df['Hidden Economy (Gold)']\n",
        "\n",
        "# Adjusting Political Climate and Fate Ranking\n",
        "df['Wizarding School'] = np.random.choice(['yes', 'no'], num_cities)\n",
        "df['Number of Homeowners'] = (df['Population of City'] * np.random.uniform(0.5, 0.7)).astype(int)\n",
        "df['Average Rent'] = np.random.uniform(500, 2000, num_cities)\n",
        "df['Average Age of Population'] = np.random.uniform(25, 70, num_cities)\n",
        "df['Known Treasure Value'] = np.random.uniform(0, 1e6, num_cities)\n",
        "\n",
        "# Adjust the tax rate based on the number of nobility\n",
        "df['Tax Rate'] = df.apply(lambda row: 0 if row['Number of Nobility'] == 0 else row['Tax Rate'], axis=1)\n",
        "\n",
        "# (You need to define 'Average Debt by Household' and 'Rumored Treasure Value' before using them in the next formula)\n",
        "df['Political Climate'] = (df['Tax Rate'] + df['Number of Homeowners']/df['Population of City'] +\n",
        "                              df['Average Rent']/2000 + df['Average Debt by Household']/1e4 +\n",
        "                              df['Average Age of Population']/70 + df['Hidden Economy (Gold)']/1e6 +\n",
        "                              df['Known Treasure Value']/1e6 + df['Rumored Treasure Value']/1e6) / 8\n",
        "\n",
        "df['Fate ranking'] = (df['Rumored Treasure Value'] / 1e6) + np.where(df['Wizarding School'] == 'yes', 1, 0) + df['Political Climate']"
      ],
      "metadata": {
        "id": "fDLKtPU2fbHB",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 511
        },
        "outputId": "af8008e9-8096-43da-d2f4-7ab4ec9c74dd"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "KeyError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/core/indexes/base.py\u001b[0m in \u001b[0;36mget_loc\u001b[0;34m(self, key, method, tolerance)\u001b[0m\n\u001b[1;32m   3801\u001b[0m             \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3802\u001b[0;31m                 \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_engine\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_loc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcasted_key\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   3803\u001b[0m             \u001b[0;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0merr\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/_libs/index.pyx\u001b[0m in \u001b[0;36mpandas._libs.index.IndexEngine.get_loc\u001b[0;34m()\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/_libs/index.pyx\u001b[0m in \u001b[0;36mpandas._libs.index.IndexEngine.get_loc\u001b[0;34m()\u001b[0m\n",
            "\u001b[0;32mpandas/_libs/hashtable_class_helper.pxi\u001b[0m in \u001b[0;36mpandas._libs.hashtable.PyObjectHashTable.get_item\u001b[0;34m()\u001b[0m\n",
            "\u001b[0;32mpandas/_libs/hashtable_class_helper.pxi\u001b[0m in \u001b[0;36mpandas._libs.hashtable.PyObjectHashTable.get_item\u001b[0;34m()\u001b[0m\n",
            "\u001b[0;31mKeyError\u001b[0m: 'Dragon Sightings'",
            "\nThe above exception was the direct cause of the following exception:\n",
            "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-67-f5ec6583b737>\u001b[0m in \u001b[0;36m<cell line: 3>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# Adjusting Danger Level\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m df['Danger Level'] = (\n\u001b[0;32m----> 3\u001b[0;31m     \u001b[0mdf\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Dragon Sightings'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m     \u001b[0;34m+\u001b[0m \u001b[0mdf\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Political Climate'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m     \u001b[0;34m+\u001b[0m \u001b[0mdf\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Magical Climate'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/core/frame.py\u001b[0m in \u001b[0;36m__getitem__\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m   3805\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcolumns\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnlevels\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   3806\u001b[0m                 \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_getitem_multilevel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3807\u001b[0;31m             \u001b[0mindexer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcolumns\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_loc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   3808\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mis_integer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mindexer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   3809\u001b[0m                 \u001b[0mindexer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mindexer\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pandas/core/indexes/base.py\u001b[0m in \u001b[0;36mget_loc\u001b[0;34m(self, key, method, tolerance)\u001b[0m\n\u001b[1;32m   3802\u001b[0m                 \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_engine\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_loc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcasted_key\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   3803\u001b[0m             \u001b[0;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0merr\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3804\u001b[0;31m                 \u001b[0;32mraise\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0merr\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   3805\u001b[0m             \u001b[0;32mexcept\u001b[0m \u001b[0mTypeError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   3806\u001b[0m                 \u001b[0;31m# If we have a listlike key, _check_indexing_error will raise\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mKeyError\u001b[0m: 'Dragon Sightings'"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# File path\n",
        "df_file_path = '/content/drive/MyDrive/Colab Notebooks/DnD/fictional_data.xlsx'\n",
        "pf_file_path = '/content/drive/MyDrive/Colab Notebooks/DnD/points.xlsx'\n",
        "\n",
        "# Read the Excel file into a DataFrame\n",
        "df = pd.read_excel(df_file_path)\n",
        "# Read the Excel file into a DataFrame\n",
        "pf = pd.read_excel(pf_file_path)"
      ],
      "metadata": {
        "id": "Ohj-o8AXWwfj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "df.info()"
      ],
      "metadata": {
        "id": "Xcz_-3Zn7pL4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "24495fa5-6bc2-418d-a104-5fced6eeb702"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'pandas.core.frame.DataFrame'>\n",
            "Int64Index: 849 entries, 0 to 848\n",
            "Data columns (total 25 columns):\n",
            " #   Column                      Non-Null Count  Dtype  \n",
            "---  ------                      --------------  -----  \n",
            " 0   settlement                  849 non-null    object \n",
            " 1   region                      849 non-null    object \n",
            " 2   settlement_population       849 non-null    int64  \n",
            " 3   settlement_economy          849 non-null    float64\n",
            " 4   rumored_treasure_value      849 non-null    int64  \n",
            " 5   demographic_breakdown       849 non-null    object \n",
            " 6   average_age                 849 non-null    int64  \n",
            " 7   most_likely_cause_of_death  849 non-null    object \n",
            " 8   government_type             849 non-null    object \n",
            " 9   class_density               849 non-null    object \n",
            " 10  tax_rate                    849 non-null    float64\n",
            " 11  exports                     545 non-null    object \n",
            " 12  imports                     523 non-null    object \n",
            " 13  military                    441 non-null    object \n",
            " 14  magic_academy               849 non-null    object \n",
            " 15  capital                     530 non-null    object \n",
            " 16  languages                   849 non-null    object \n",
            " 17  religions                   849 non-null    object \n",
            " 18  region_area                 833 non-null    float64\n",
            " 19  region_population           849 non-null    int64  \n",
            " 20  region_economy              849 non-null    float64\n",
            " 21  average_temperature         849 non-null    float64\n",
            " 22  annual_rainfall             849 non-null    float64\n",
            " 23  magical_climate             367 non-null    float64\n",
            " 24  dragon_sightings            367 non-null    float64\n",
            "dtypes: float64(8), int64(4), object(13)\n",
            "memory usage: 172.5+ KB\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "columns_to_drop = [\n",
        "    'size',\n",
        "    'scale_factor',\n",
        "    'scale_factor_normalized',\n",
        "    'settlement_size'\n",
        "]\n",
        "\n",
        "# Dropping the columns from the DataFrame\n",
        "df = df.drop(columns=columns_to_drop)\n"
      ],
      "metadata": {
        "id": "xHjJ3B2KOPnq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "1XCWw4YrOolT"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}