test

.gitattributes

@@ -57,6 +57,3 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
-release_2025_09_15/**/*.csv filter=lfs diff=lfs merge=lfs -text
-release_2025_09_15/**/*.xlsx filter=lfs diff=lfs merge=lfs -text
-release_2025_09_15/**/*.json filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -1 +0,0 @@
-.DS_Store

README.md

@@ -9,14 +9,10 @@ tags:
 viewer: true
 license: mit
 configs:
-- config_name: release_2025_09_15
+- config_name: default
   data_files:
-  - split: raw_claude_ai
-    path: "release_2025_09_15/data/intermediate/aei_raw_claude_ai_2025-08-04_to_2025-08-11.csv"
-  - split: raw_1p_api
-    path: "release_2025_09_15/data/intermediate/aei_raw_1p_api_2025-08-04_to_2025-08-11.csv"
-  - split: enriched_claude_ai
-    path: "release_2025_09_15/data/output/aei_enriched_claude_ai_2025-08-04_to_2025-08-11.csv"
+  - split: train
+    path: "release_2025_03_27/automation_vs_augmentation_by_task.csv"
 ---
 
 # The Anthropic Economic Index
@@ -29,17 +25,13 @@ The Anthropic Economic Index provides insights into how AI is being incorporated
 
 This repository contains multiple data releases, each with its own documentation:
 
-- **[2025-09-15 Release](https://huggingface.co/datasets/Anthropic/EconomicIndex/tree/main/release_2025_09_15)**: Updated analysis with geographic and first-party API data using Sonnet 4
-- **[2025-03-27 Release](https://huggingface.co/datasets/Anthropic/EconomicIndex/tree/main/release_2025_03_27)**: Updated analysis with Claude 3.7 Sonnet data and cluster-level insights
 - **[2025-02-10 Release](https://huggingface.co/datasets/Anthropic/EconomicIndex/tree/main/release_2025_02_10)**: Initial release with O*NET task mappings, automation vs. augmentation data, and more
-
+- **[2025-03-27 Release](https://huggingface.co/datasets/Anthropic/EconomicIndex/tree/main/release_2025_03_27)**: Updated analysis with Claude 3.7 Sonnet data and cluster-level insights
 
 ## Resources
 
 - [Index Home Page](https://www.anthropic.com/economic-index)
-- [3rd report](https://www.anthropic.com/research/anthropic-economic-index-september-2025-report)
-- [2nd report](https://www.anthropic.com/news/anthropic-economic-index-insights-from-claude-sonnet-3-7)
-- [1st report](https://www.anthropic.com/news/the-anthropic-economic-index)
+- [Research Paper](https://assets.anthropic.com/m/2e23255f1e84ca97/original/Economic_Tasks_AI_Paper.pdf)
 
 
 ## License
@@ -48,24 +40,10 @@ Data released under CC-BY, code released under MIT License
 
 ## Contact
 
-For inquiries, contact econ-research@anthropic.com.
+For inquiries, contact kunal@anthropic.com or atamkin@anthropic.com. We invite researchers to provide input on potential future data releases using [this form](https://docs.google.com/forms/d/e/1FAIpQLSfDEdY-mT5lcXPaDSv-0Ci1rSXGlbIJierxkUbNB7_07-kddw/viewform?usp=dialog).
 
 ## Citation
 
-### Third release
-
-```
-@online{appelmccrorytamkin2025geoapi,
-        author = {Ruth Appel and Peter McCrory and Alex Tamkin and Michael Stern and Miles McCain and Tyler Neylon],
-        title = {Anthropic Economic Index Report: Uneven Geographic and Enterprise AI Adoption},
-        date = {2025-09-15},
-        year = {2025},
-        url = {www.anthropic.com/research/anthropic-economic-index-september-2025-report},
-}
-```
-
-### Second release
-
 ```
 @misc{handa2025economictasksperformedai,
       title={Which Economic Tasks are Performed with AI? Evidence from Millions of Claude Conversations}, 

release_2025_09_15/README.md

@@ -1,72 +0,0 @@
-# Anthropic Economic Index September 2025 Report Replication
-
-## Folder Structure
-
-```
-.
-├── code/                  # Analysis scripts
-├── data/
-│   ├── input/             # Raw data files (from external sources or prior releases)
-│   ├── intermediate/      # Processed data files
-│   └── output/            # Final outputs (plots, tables, etc.)
-├── data_documentation.md  # Documentation of all data sources and datasets
-└── README.md
-```
-
-## Data Processing Pipeline
-
-**Note:** Since all preprocessed data files are provided, you can skip directly to the Analysis section (Section 2) if you want to replicate the results without re-running the preprocessing steps. Please refer to `data_documentation.md` for details on the different data used.
-
-Run the following scripts in order from the `code/` directory:
-
-### 1. Data Preprocessing
-
-1. **`preprocess_iso_codes.py`**
-   - Processes ISO country codes
-   - Creates standardized country code mappings
-
-2. **`preprocess_population.py`**
-   - Processes country-level population data
-   - Processes US state-level population data
-   - Outputs working age population statistics
-
-3. **`preprocess_gdp.py`**
-   - Downloads and processes IMF country GDP data
-   - Processes BEA US state GDP data
-   - Creates standardized GDP datasets
-
-4. **`preprocess_onet.py`**
-   - Processes O*NET occupation and task data
-   - Creates SOC occupation mappings
-
-5. **`aei_report_v3_preprocessing_1p_api.ipynb`**
-   - Jupyter notebook for preprocessing API and Claude.ai usage data
-   - Prepares data for analysis
-
-### 2. Analysis
-
-#### Analysis Scripts
-
-1. **`aei_report_v3_change_over_time_claude_ai.py`**
-   - Analyzes automation trends across report versions (V1, V2, V3)
-   - Generates comparison figures showing evolution of automation estimates
-
-2. **`aei_report_v3_analysis_claude_ai.ipynb`**
-   - Analysis notebook for Claude.ai usage patterns
-   - Generates figures specific to Claude.ai usage
-   - Uses functions from `aei_analysis_functions_claude_ai.py`
-
-3. **`aei_report_v3_analysis_1p_api.ipynb`**
-   - Main analysis notebook for API usage patterns
-   - Generates figures for occupational usage, collaboration patterns, and regression analyses
-   - Uses functions from `aei_analysis_functions_1p_api.py`
-
-#### Supporting Function Files
-
-- **`aei_analysis_functions_claude_ai.py`**
-  - Core analysis functions for Claude.ai data
-  - Platform-specific analysis and visualization functions
-
-- **`aei_analysis_functions_1p_api.py`**
-  - Core analysis functions for API data
-  - Includes regression models, plotting functions, and data transformations

release_2025_09_15/code/aei_analysis_functions_1p_api.py

@@ -1,2339 +0,0 @@
-# AEI 1P API Analysis Functions
-# This module contains the core analysis functions for the AEI report API chapter
-
-from pathlib import Path
-from textwrap import wrap
-
-import matplotlib.pyplot as plt
-import numpy as np
-import pandas as pd
-import plotly.graph_objects as go
-import statsmodels.api as sm
-from plotly.subplots import make_subplots
-
-# Define the tier colors
-CUSTOM_COLORS_LIST = ["#E6DBD0", "#E5C5AB", "#E4AF86", "#E39961", "#D97757"]
-
-# Define the color cycle for charts
-COLOR_CYCLE = [
-    "#D97757",
-    "#656565",
-    "#40668C",
-    "#E39961",
-    "#E4AF86",
-    "#C65A3F",
-    "#8778AB",
-    "#E5C5AB",
-    "#B04F35",
-]
-
-
-def setup_plot_style():
-    """Configure matplotlib for publication-quality figures."""
-    plt.style.use("default")
-    plt.rcParams.update(
-        {
-            "figure.dpi": 100,
-            "savefig.dpi": 300,
-            "font.size": 10,
-            "axes.labelsize": 11,
-            "axes.titlesize": 12,
-            "xtick.labelsize": 9,
-            "ytick.labelsize": 9,
-            "legend.fontsize": 9,
-            "figure.facecolor": "white",
-            "axes.facecolor": "white",
-            "savefig.facecolor": "white",
-            "axes.edgecolor": "#333333",
-            "axes.linewidth": 0.8,
-            "axes.grid": True,
-            "grid.alpha": 0.3,
-            "grid.linestyle": "-",
-            "grid.linewidth": 0.5,
-            "axes.axisbelow": True,
-            "text.usetex": False,
-            "mathtext.default": "regular",
-            "axes.titlecolor": "#B86046",
-            "figure.titlesize": 16,
-        }
-    )
-
-
-# Initialize style
-setup_plot_style()
-
-
-def load_preprocessed_data(input_file):
-    """
-    Load preprocessed API data from CSV or Parquet file.
-
-    Args:
-        input_file: Path to preprocessed data file
-
-    Returns:
-        DataFrame with preprocessed API data
-    """
-    input_path = Path(input_file)
-
-    if not input_path.exists():
-        raise FileNotFoundError(f"Input file not found: {input_path}")
-
-    df = pd.read_csv(input_path)
-    return df
-
-
-def create_top_requests_bar_chart(df, output_dir):
-    """
-    Create bar chart showing top 15 request categories (level 2) by count share.
-
-    Args:
-        df: Preprocessed data DataFrame
-        output_dir: Directory to save the figure
-    """
-    # Get request data at level 2 (global only) using percentages
-    request_data = df[
-        (df["facet"] == "request")
-        & (df["geo_id"] == "GLOBAL")
-        & (df["level"] == 2)
-        & (df["variable"] == "request_pct")
-    ].copy()
-
-    # Filter out not_classified (but don't renormalize)
-    request_data = request_data[request_data["cluster_name"] != "not_classified"]
-
-    # Use the percentage values directly (already calculated in preprocessing)
-    request_data["request_pct"] = request_data["value"]
-
-    # Get top 15 requests by percentage share
-    top_requests = request_data.nlargest(15, "request_pct").sort_values(
-        "request_pct", ascending=True
-    )
-
-    # Create figure
-    fig, ax = plt.subplots(figsize=(14, 10))
-
-    # Create horizontal bar chart with tier color gradient
-    y_pos = np.arange(len(top_requests))
-
-    # Use tier colors based on ranking (top categories get darker colors)
-    colors = []
-    for i in range(len(top_requests)):
-        # Map position to tier color (top bars = darker, bottom bars = lighter)
-        # Since bars are sorted ascending, higher index = higher value = darker color
-        rank_position = i / (len(top_requests) - 1)
-        tier_index = int(rank_position * (len(CUSTOM_COLORS_LIST) - 1))
-        colors.append(CUSTOM_COLORS_LIST[tier_index])
-
-    ax.barh(
-        y_pos,
-        top_requests["request_pct"],
-        color=colors,
-        alpha=0.9,
-        edgecolor="#333333",
-        linewidth=0.5,
-    )
-
-    # Add value labels on bars
-    for i, (idx, row) in enumerate(top_requests.iterrows()):
-        ax.text(
-            row["request_pct"] + 0.1,
-            i,
-            f"{row['request_pct']:.1f}%",
-            va="center",
-            fontsize=11,
-            fontweight="bold",
-        )
-
-    # Clean up request names for y-axis labels
-    labels = []
-    for name in top_requests["cluster_name"]:
-        # Truncate long names and add line breaks
-        if len(name) > 60:
-            # Find good break point around middle
-            mid = len(name) // 2
-            break_point = name.find(" ", mid)
-            if break_point == -1:  # No space found, just break at middle
-                break_point = mid
-            clean_name = name[:break_point] + "\n" + name[break_point:].strip()
-        else:
-            clean_name = name
-        labels.append(clean_name)
-
-    ax.set_yticks(y_pos)
-    ax.set_yticklabels(labels, fontsize=10)
-
-    # Formatting
-    ax.set_xlabel("Percentage of total request count", fontsize=14)
-    ax.set_title(
-        "Top use cases among 1P API transcripts by usage share \n (broad grouping, bottom-up classification)",
-        fontsize=14,
-        fontweight="bold",
-        pad=20,
-    )
-
-    # Add grid
-    ax.grid(True, alpha=0.3, axis="x")
-    ax.set_axisbelow(True)
-
-    # Remove top and right spines
-    ax.spines["top"].set_visible(False)
-    ax.spines["right"].set_visible(False)
-
-    # Increase tick label font size
-    ax.tick_params(axis="x", which="major", labelsize=12)
-
-    plt.tight_layout()
-
-    # Save plot
-    output_path = Path(output_dir) / "top_requests_level2_bar_chart.png"
-    plt.savefig(output_path, dpi=300, bbox_inches="tight")
-    plt.show()
-    return str(output_path)
-
-
-def load_onet_mappings():
-    """
-    Load ONET task statements and SOC structure for occupational category mapping.
-
-    Returns:
-        Tuple of (task_statements_df, soc_structure_df)
-    """
-    # Load from local files
-    task_path = Path("../data/intermediate/onet_task_statements.csv")
-    soc_path = Path("../data/intermediate/soc_structure.csv")
-
-    # Load CSV files directly
-    task_statements = pd.read_csv(task_path)
-    soc_structure = pd.read_csv(soc_path)
-
-    return task_statements, soc_structure
-
-
-def map_to_occupational_categories(df, task_statements, soc_structure):
-    """
-    Map ONET task data to major occupational categories.
-
-    Args:
-        df: Preprocessed data DataFrame
-        task_statements: ONET task statements DataFrame
-        soc_structure: SOC structure DataFrame
-
-    Returns:
-        DataFrame with occupational category mappings
-    """
-    # Filter for ONET task data
-    onet_data = df[df["facet"] == "onet_task"].copy()
-
-    # Handle not_classified and none tasks first
-    not_classified_mask = onet_data["cluster_name"].isin(["not_classified", "none"])
-    not_classified_data = onet_data[not_classified_mask].copy()
-    not_classified_data["soc_major"] = "99"
-    not_classified_data["occupational_category"] = "Not Classified"
-
-    # Process regular tasks
-    regular_data = onet_data[~not_classified_mask].copy()
-
-    # Standardize task descriptions for matching
-    # Create standardized task mapping from ONET statements
-    task_statements["task_standardized"] = (
-        task_statements["Task"].str.strip().str.lower()
-    )
-    regular_data["cluster_name_standardized"] = (
-        regular_data["cluster_name"].str.strip().str.lower()
-    )
-
-    # Create mapping from standardized task to major groups (allowing multiple)
-    task_to_major_groups = {}
-    for _, row in task_statements.iterrows():
-        if pd.notna(row["Task"]) and pd.notna(row["soc_major_group"]):
-            std_task = row["task_standardized"]
-            major_group = str(int(row["soc_major_group"]))
-            if std_task not in task_to_major_groups:
-                task_to_major_groups[std_task] = []
-            if major_group not in task_to_major_groups[std_task]:
-                task_to_major_groups[std_task].append(major_group)
-
-    # Expand rows for tasks that belong to multiple groups
-    expanded_rows = []
-    for _, row in regular_data.iterrows():
-        std_task = row["cluster_name_standardized"]
-        if std_task in task_to_major_groups:
-            groups = task_to_major_groups[std_task]
-            # Assign full value to each group (creates duplicates)
-            for group in groups:
-                new_row = row.copy()
-                new_row["soc_major"] = group
-                new_row["value"] = row["value"]  # Keep full value for each group
-                expanded_rows.append(new_row)
-
-    # Create new dataframe from expanded rows
-    if expanded_rows:
-        regular_data = pd.DataFrame(expanded_rows)
-    else:
-        regular_data["soc_major"] = None
-
-    # Get major occupational groups from SOC structure
-    # Filter for rows where 'Major Group' is not null (these are the major groups)
-    major_groups = soc_structure[soc_structure["Major Group"].notna()].copy()
-
-    # Extract major group code and title
-    major_groups["soc_major"] = major_groups["Major Group"].astype(str).str[:2]
-    major_groups["title"] = major_groups["SOC or O*NET-SOC 2019 Title"]
-
-    # Create a clean mapping from major group code to title
-    major_group_mapping = (
-        major_groups[["soc_major", "title"]]
-        .drop_duplicates()
-        .set_index("soc_major")["title"]
-        .to_dict()
-    )
-
-    # Map major group codes to titles for regular data
-    regular_data["occupational_category"] = regular_data["soc_major"].map(
-        major_group_mapping
-    )
-
-    # Keep only successfully mapped regular data
-    regular_mapped = regular_data[regular_data["occupational_category"].notna()].copy()
-
-    # Combine regular mapped data with not_classified data
-    onet_mapped = pd.concat([regular_mapped, not_classified_data], ignore_index=True)
-
-    # Renormalize percentages to sum to 100 since we may have created duplicates
-    total = onet_mapped["value"].sum()
-
-    onet_mapped["value"] = (onet_mapped["value"] / total) * 100
-
-    return onet_mapped
-
-
-def create_platform_occupational_comparison(api_df, cai_df, output_dir):
-    """
-    Create horizontal bar chart comparing occupational categories between Claude.ai and 1P API.
-
-    Args:
-        api_df: API preprocessed data DataFrame
-        cai_df: Claude.ai preprocessed data DataFrame
-        output_dir: Directory to save the figure
-    """
-    # Load ONET mappings for occupational categories
-    task_statements, soc_structure = load_onet_mappings()
-
-    # Process both datasets to get occupational categories
-    def get_occupational_data(df, platform_name):
-        # Get ONET task percentage data (global level only)
-        onet_data = df[
-            (df["facet"] == "onet_task")
-            & (df["geo_id"] == "GLOBAL")
-            & (df["variable"] == "onet_task_pct")
-        ].copy()
-
-        # Map to occupational categories using existing function
-        onet_mapped = map_to_occupational_categories(
-            onet_data, task_statements, soc_structure
-        )
-
-        # Sum percentages by occupational category
-        category_percentages = (
-            onet_mapped.groupby("occupational_category")["value"].sum().reset_index()
-        )
-
-        # Exclude "Not Classified" category from visualization
-        category_percentages = category_percentages[
-            category_percentages["occupational_category"] != "Not Classified"
-        ]
-
-        category_percentages.columns = ["category", f"{platform_name.lower()}_pct"]
-
-        return category_percentages
-
-    # Get data for both platforms
-    api_categories = get_occupational_data(api_df, "API")
-    claude_categories = get_occupational_data(cai_df, "Claude")
-
-    # Merge the datasets
-    category_comparison = pd.merge(
-        claude_categories, api_categories, on="category", how="outer"
-    ).fillna(0)
-
-    # Filter to substantial categories (>0.5% in either platform)
-    category_comparison = category_comparison[
-        (category_comparison["claude_pct"] > 0.5)
-        | (category_comparison["api_pct"] > 0.5)
-    ].copy()
-
-    # Calculate difference and total
-    category_comparison["difference"] = (
-        category_comparison["api_pct"] - category_comparison["claude_pct"]
-    )
-    category_comparison["total_pct"] = (
-        category_comparison["claude_pct"] + category_comparison["api_pct"]
-    )
-
-    # Get top 8 categories by total usage
-    top_categories = category_comparison.nlargest(8, "total_pct").sort_values(
-        "total_pct", ascending=True
-    )
-
-    # Create figure
-    fig, ax = plt.subplots(figsize=(12, 8))
-
-    y_pos = np.arange(len(top_categories))
-    bar_height = 0.35
-
-    # Create side-by-side bars
-    ax.barh(
-        y_pos - bar_height / 2,
-        top_categories["claude_pct"],
-        bar_height,
-        label="Claude.ai",
-        color=COLOR_CYCLE[2],
-        alpha=0.8,
-    )
-    ax.barh(
-        y_pos + bar_height / 2,
-        top_categories["api_pct"],
-        bar_height,
-        label="1P API",
-        color=COLOR_CYCLE[0],
-        alpha=0.8,
-    )
-
-    # Add value labels with difference percentages
-    for i, (idx, row) in enumerate(top_categories.iterrows()):
-        # Claude.ai label
-        if row["claude_pct"] > 0.1:
-            ax.text(
-                row["claude_pct"] + 0.2,
-                i - bar_height / 2,
-                f"{row['claude_pct']:.0f}%",
-                va="center",
-                fontsize=9,
-            )
-
-        # 1P API label with difference
-        if row["api_pct"] > 0.1:
-            ax.text(
-                row["api_pct"] + 0.2,
-                i + bar_height / 2,
-                f"{row['api_pct']:.0f}%",
-                va="center",
-                fontsize=9,
-                color=COLOR_CYCLE[0] if row["difference"] > 0 else COLOR_CYCLE[2],
-            )
-
-    # Clean up category labels
-    labels = []
-    for cat in top_categories["category"]:
-        # Remove "Occupations" suffix and wrap long names
-        clean_cat = cat.replace(" Occupations", "").replace(", and ", " & ")
-        wrapped = "\n".join(wrap(clean_cat, 40))
-        labels.append(wrapped)
-
-    ax.set_yticks(y_pos)
-    ax.set_yticklabels(labels, fontsize=10)
-
-    ax.set_xlabel("Percentage of usage", fontsize=12)
-    ax.set_title(
-        "Usage shares across top occupational categories: Claude.ai vs 1P API",
-        fontsize=14,
-        fontweight="bold",
-        pad=20,
-    )
-    ax.legend(loc="lower right", fontsize=11)
-    ax.grid(True, alpha=0.3, axis="x")
-    ax.set_axisbelow(True)
-
-    # Remove top and right spines
-    ax.spines["top"].set_visible(False)
-    ax.spines["right"].set_visible(False)
-
-    plt.tight_layout()
-
-    # Save plot
-    output_path = Path(output_dir) / "platform_occupational_comparison.png"
-    plt.savefig(output_path, dpi=300, bbox_inches="tight")
-    plt.show()
-    return str(output_path)
-
-
-def create_platform_lorenz_curves(api_df, cai_df, output_dir):
-    """
-    Create Lorenz curves showing task usage concentration by platform.
-
-    Args:
-        api_df: API preprocessed data DataFrame
-        cai_df: Claude.ai preprocessed data DataFrame
-        output_dir: Directory to save the figure
-    """
-
-    def gini_coefficient(values):
-        """Calculate Gini coefficient for a series of values."""
-        sorted_values = np.sort(values)
-        n = len(sorted_values)
-        cumulative = np.cumsum(sorted_values)
-        gini = (2 * np.sum(np.arange(1, n + 1) * sorted_values)) / (
-            n * cumulative[-1]
-        ) - (n + 1) / n
-        return gini
-
-    def get_task_usage_data(df, platform_name):
-        # Get ONET task percentage data (global level only)
-        onet_data = df[
-            (df["facet"] == "onet_task")
-            & (df["geo_id"] == "GLOBAL")
-            & (df["variable"] == "onet_task_pct")
-        ].copy()
-
-        # Filter out none and not_classified
-        onet_data = onet_data[
-            ~onet_data["cluster_name"].isin(["none", "not_classified"])
-        ]
-
-        # Use the percentage values directly
-        onet_data["percentage"] = onet_data["value"]
-
-        return onet_data[["cluster_name", "percentage"]].copy()
-
-    api_tasks = get_task_usage_data(api_df, "1P API")
-    claude_tasks = get_task_usage_data(cai_df, "Claude.ai")
-
-    # Sort by percentage for each platform
-    api_tasks = api_tasks.sort_values("percentage")
-    claude_tasks = claude_tasks.sort_values("percentage")
-
-    # Calculate cumulative percentages of usage
-    api_cumulative = np.cumsum(api_tasks["percentage"])
-    claude_cumulative = np.cumsum(claude_tasks["percentage"])
-
-    # Calculate cumulative percentage of tasks
-    api_task_cumulative = np.arange(1, len(api_tasks) + 1) / len(api_tasks) * 100
-    claude_task_cumulative = (
-        np.arange(1, len(claude_tasks) + 1) / len(claude_tasks) * 100
-    )
-
-    # Interpolate to ensure curves reach 100%
-    # Add final points to reach (100, 100)
-    api_cumulative = np.append(api_cumulative, 100)
-    claude_cumulative = np.append(claude_cumulative, 100)
-    api_task_cumulative = np.append(api_task_cumulative, 100)
-    claude_task_cumulative = np.append(claude_task_cumulative, 100)
-
-    # Calculate Gini coefficients
-    api_gini = gini_coefficient(api_tasks["percentage"].values)
-    claude_gini = gini_coefficient(claude_tasks["percentage"].values)
-
-    # Create panel figure
-    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(16, 8))
-
-    # LEFT PANEL: Lorenz Curves
-    # Plot Lorenz curves
-    ax1.plot(
-        api_task_cumulative,
-        api_cumulative,
-        color=COLOR_CYCLE[1],
-        linewidth=2.5,
-        label=f"1P API (Gini = {api_gini:.3f})",
-    )
-
-    ax1.plot(
-        claude_task_cumulative,
-        claude_cumulative,
-        color=COLOR_CYCLE[0],
-        linewidth=2.5,
-        label=f"Claude.ai (Gini = {claude_gini:.3f})",
-    )
-
-    # Add perfect equality line (diagonal)
-    ax1.plot(
-        [0, 100],
-        [0, 100],
-        "k--",
-        linewidth=1.5,
-        alpha=0.7,
-        label="Perfect Equality",
-    )
-
-    # Calculate 80th percentile values
-    api_80th_usage = np.interp(80, api_task_cumulative, api_cumulative)
-    claude_80th_usage = np.interp(80, claude_task_cumulative, claude_cumulative)
-
-    # Add markers at 80th percentile
-    ax1.scatter(
-        80,
-        api_80th_usage,
-        alpha=0.5,
-        s=100,
-        color=COLOR_CYCLE[1],
-        edgecolors="white",
-        linewidth=1,
-        zorder=5,
-    )
-    ax1.scatter(
-        80,
-        claude_80th_usage,
-        alpha=0.5,
-        s=100,
-        color=COLOR_CYCLE[0],
-        edgecolors="white",
-        linewidth=1,
-        zorder=5,
-    )
-
-    # Add annotations
-    ax1.text(
-        82,
-        api_80th_usage - 2,
-        f"{api_80th_usage:.1f}% of usage",
-        ha="left",
-        va="center",
-        fontsize=10,
-        color=COLOR_CYCLE[1],
-    )
-
-    ax1.text(
-        78.5,
-        claude_80th_usage + 1,
-        f"{claude_80th_usage:.1f}% of usage",
-        ha="right",
-        va="center",
-        fontsize=10,
-        color=COLOR_CYCLE[0],
-    )
-
-    # Add text box
-    ax1.text(
-        0.05,
-        0.95,
-        f"The bottom 80% of tasks account for:\n• 1P API: {api_80th_usage:.1f}% of usage\n• Claude.ai: {claude_80th_usage:.1f}% of usage",
-        transform=ax1.transAxes,
-        va="top",
-        ha="left",
-        bbox=dict(
-            boxstyle="round,pad=0.3",
-            facecolor="white",
-            alpha=0.8,
-            edgecolor="black",
-            linewidth=1,
-        ),
-        fontsize=10,
-    )
-
-    # Styling for Lorenz curves
-    ax1.set_xlabel("Cumulative percentage of tasks", fontsize=12)
-    ax1.set_ylabel("Cumulative percentage of usage", fontsize=12)
-    ax1.set_title("Lorenz curves", fontsize=14, fontweight="bold", pad=20)
-    ax1.set_xlim(0, 100)
-    ax1.set_ylim(0, 100)
-    ax1.grid(True, alpha=0.3, linestyle="--")
-    ax1.set_axisbelow(True)
-    ax1.legend(loc=(0.05, 0.65), fontsize=11, frameon=True, facecolor="white")
-    ax1.spines["top"].set_visible(False)
-    ax1.spines["right"].set_visible(False)
-
-    # RIGHT PANEL: Zipf's Law Analysis
-    min_share = 0.1
-
-    # Filter for minimum share
-    api_filtered = api_tasks[api_tasks["percentage"] > min_share]["percentage"].copy()
-    claude_filtered = claude_tasks[claude_tasks["percentage"] > min_share][
-        "percentage"
-    ].copy()
-
-    # Calculate ranks and log transforms
-    ln_rank_api = np.log(api_filtered.rank(ascending=False))
-    ln_share_api = np.log(api_filtered)
-
-    ln_rank_claude = np.log(claude_filtered.rank(ascending=False))
-    ln_share_claude = np.log(claude_filtered)
-
-    # Fit regressions
-    api_model = sm.OLS(ln_rank_api, sm.add_constant(ln_share_api)).fit()
-    api_slope = api_model.params.iloc[1]
-    api_intercept = api_model.params.iloc[0]
-
-    claude_model = sm.OLS(ln_rank_claude, sm.add_constant(ln_share_claude)).fit()
-    claude_slope = claude_model.params.iloc[1]
-    claude_intercept = claude_model.params.iloc[0]
-
-    # Plot scatter points
-    ax2.scatter(
-        ln_share_api,
-        ln_rank_api,
-        alpha=0.5,
-        s=100,
-        color=COLOR_CYCLE[1],
-        label=f"1P API: y = {api_slope:.2f}x + {api_intercept:.2f}",
-    )
-
-    ax2.scatter(
-        ln_share_claude,
-        ln_rank_claude,
-        alpha=0.5,
-        s=100,
-        color=COLOR_CYCLE[0],
-        label=f"Claude.ai: y = {claude_slope:.2f}x + {claude_intercept:.2f}",
-    )
-
-    # Add Zipf's law reference line (slope = -1)
-    x_range = np.linspace(
-        min(ln_share_api.min(), ln_share_claude.min()),
-        max(ln_share_api.max(), ln_share_claude.max()),
-        100,
-    )
-    avg_intercept = (api_intercept + claude_intercept) / 2
-    y_line = -1 * x_range + avg_intercept
-
-    ax2.plot(
-        x_range,
-        y_line,
-        color="black",
-        linestyle="--",
-        linewidth=2,
-        label=f"Zipf's Law: y = -1.00x + {avg_intercept:.2f}",
-        zorder=0,
-    )
-
-    # Styling for Zipf's law plot
-    ax2.set_xlabel("ln(Share of usage)", fontsize=12)
-    ax2.set_ylabel("ln(Rank by usage)", fontsize=12)
-    ax2.set_title(
-        "Task rank versus usage share", fontsize=14, fontweight="bold", pad=20
-    )
-    ax2.grid(True, alpha=0.3, linestyle="--")
-    ax2.set_axisbelow(True)
-    ax2.legend(fontsize=11)
-    ax2.spines["top"].set_visible(False)
-    ax2.spines["right"].set_visible(False)
-
-    # Overall title
-    fig.suptitle(
-        "Lorenz curves and power law analysis across tasks: 1P API vs Claude.ai",
-        fontsize=16,
-        fontweight="bold",
-        y=0.95,
-        color="#B86046",
-    )
-
-    plt.tight_layout()
-    plt.subplots_adjust(top=0.85)  # More room for suptitle
-
-    # Save plot
-    output_path = Path(output_dir) / "platform_lorenz_zipf_panel.png"
-    plt.savefig(output_path, dpi=300, bbox_inches="tight")
-    plt.show()
-    return str(output_path)
-
-
-def create_collaboration_alluvial(api_df, cai_df, output_dir):
-    """
-    Create alluvial diagram showing collaboration pattern flows between platforms.
-
-    Args:
-        api_df: API preprocessed data DataFrame
-        cai_df: Claude.ai preprocessed data DataFrame
-        output_dir: Directory to save the figure
-    """
-
-    def get_collaboration_data(df, platform_name):
-        # Get collaboration facet data (global level only)
-        collab_data = df[
-            (df["facet"] == "collaboration")
-            & (df["geo_id"] == "GLOBAL")
-            & (df["variable"] == "collaboration_pct")
-        ].copy()
-
-        # Use cluster_name directly as the collaboration pattern
-        collab_data["pattern"] = collab_data["cluster_name"]
-
-        # Filter out not_classified
-        collab_data = collab_data[collab_data["pattern"] != "not_classified"]
-
-        # Use the percentage values directly
-        result = collab_data[["pattern", "value"]].copy()
-        result.columns = ["pattern", "percentage"]
-        result["platform"] = platform_name
-
-        return result
-
-    api_collab = get_collaboration_data(api_df, "1P API")
-    claude_collab = get_collaboration_data(cai_df, "Claude.ai")
-
-    # Combine collaboration data
-    collab_df = pd.concat([claude_collab, api_collab], ignore_index=True)
-
-    # Define categories
-    augmentation_types = ["learning", "task iteration", "validation"]
-    automation_types = ["directive", "feedback loop"]
-
-    # Colors matching the original
-    pattern_colors = {
-        "validation": "#2c3e67",
-        "task iteration": "#4f76c7",
-        "learning": "#79a7e0",
-        "feedback loop": "#614980",
-        "directive": "#8e6bb1",
-    }
-
-    # Extract flows
-    flows_claude = {}
-    flows_api = {}
-
-    for pattern in augmentation_types + automation_types:
-        claude_mask = (collab_df["pattern"] == pattern) & (
-            collab_df["platform"] == "Claude.ai"
-        )
-        if claude_mask.any():
-            flows_claude[pattern] = collab_df.loc[claude_mask, "percentage"].values[0]
-
-        api_mask = (collab_df["pattern"] == pattern) & (
-            collab_df["platform"] == "1P API"
-        )
-        if api_mask.any():
-            flows_api[pattern] = collab_df.loc[api_mask, "percentage"].values[0]
-
-    # Create figure with subplots
-    fig = make_subplots(
-        rows=2,
-        cols=1,
-        row_heights=[0.5, 0.5],
-        vertical_spacing=0.15,
-        subplot_titles=("<b>Augmentation Patterns</b>", "<b>Automation Patterns</b>"),
-    )
-
-    # Update subplot title colors and font
-    for annotation in fig.layout.annotations:
-        annotation.update(font=dict(color="#B86046", size=14, family="Styrene B LC"))
-
-    def create_alluvial_traces(patterns, row):
-        """Create traces for alluvial diagram"""
-        # Sort by size on Claude.ai side
-        patterns_sorted = sorted(
-            [p for p in patterns if p in flows_claude],
-            key=lambda p: flows_claude.get(p, 0),
-            reverse=True,
-        )
-
-        # Calculate total heights first to determine centering
-        total_claude = sum(
-            flows_claude.get(p, 0) for p in patterns if p in flows_claude
-        )
-        total_api = sum(flows_api.get(p, 0) for p in patterns if p in flows_api)
-        gap_count = max(
-            len([p for p in patterns if p in flows_claude and flows_claude[p] > 0]) - 1,
-            0,
-        )
-        gap_count_api = max(
-            len([p for p in patterns if p in flows_api and flows_api[p] > 0]) - 1, 0
-        )
-
-        total_height_claude = total_claude + (gap_count * 2)
-        total_height_api = total_api + (gap_count_api * 2)
-
-        # Calculate offset to center the smaller side
-        offset_claude = 0
-        offset_api = 0
-        if total_height_claude < total_height_api:
-            offset_claude = (total_height_api - total_height_claude) / 2
-        else:
-            offset_api = (total_height_claude - total_height_api) / 2
-
-        # Calculate positions for Claude.ai (left side)
-        y_pos_claude = offset_claude
-        claude_positions = {}
-        for pattern in patterns_sorted:
-            if pattern in flows_claude and flows_claude[pattern] > 0:
-                height = flows_claude[pattern]
-                claude_positions[pattern] = {
-                    "bottom": y_pos_claude,
-                    "top": y_pos_claude + height,
-                    "center": y_pos_claude + height / 2,
-                }
-                y_pos_claude += height + 2  # Add gap
-
-        # Calculate positions for 1P API (right side)
-        patterns_sorted_api = sorted(
-            [p for p in patterns if p in flows_api],
-            key=lambda p: flows_api.get(p, 0),
-            reverse=True,
-        )
-        y_pos_api = offset_api
-        api_positions = {}
-        for pattern in patterns_sorted_api:
-            if pattern in flows_api and flows_api[pattern] > 0:
-                height = flows_api[pattern]
-                api_positions[pattern] = {
-                    "bottom": y_pos_api,
-                    "top": y_pos_api + height,
-                    "center": y_pos_api + height / 2,
-                }
-                y_pos_api += height + 2  # Add gap
-
-        # Create shapes for flows
-        shapes = []
-        for pattern in patterns:
-            if pattern in claude_positions and pattern in api_positions:
-                # Create a quadrilateral connecting the two sides
-                x_left = 0.2
-                x_right = 0.8
-
-                claude_bottom = claude_positions[pattern]["bottom"]
-                claude_top = claude_positions[pattern]["top"]
-                api_bottom = api_positions[pattern]["bottom"]
-                api_top = api_positions[pattern]["top"]
-
-                # Create path for the flow
-                path = f"M {x_left} {claude_bottom} L {x_left} {claude_top} L {x_right} {api_top} L {x_right} {api_bottom} Z"
-
-                hex_color = pattern_colors[pattern]
-                r = int(hex_color[1:3], 16)
-                g = int(hex_color[3:5], 16)
-                b = int(hex_color[5:7], 16)
-
-                shapes.append(
-                    dict(
-                        type="path",
-                        path=path,
-                        fillcolor=f"rgba({r},{g},{b},0.5)",
-                        line=dict(color=f"rgba({r},{g},{b},1)", width=1),
-                    )
-                )
-
-        # Create text annotations
-        annotations = []
-
-        # Claude.ai labels
-        for pattern in patterns_sorted:
-            if pattern in claude_positions:
-                annotations.append(
-                    dict(
-                        x=x_left - 0.02,
-                        y=claude_positions[pattern]["center"],
-                        text=f"{pattern.replace('_', ' ').title()}<br>{flows_claude[pattern]:.1f}%",
-                        showarrow=False,
-                        xanchor="right",
-                        yanchor="middle",
-                        font=dict(size=10),
-                    )
-                )
-
-        # 1P API labels
-        for pattern in patterns_sorted_api:
-            if pattern in api_positions:
-                annotations.append(
-                    dict(
-                        x=x_right + 0.02,
-                        y=api_positions[pattern]["center"],
-                        text=f"{pattern.replace('_', ' ').title()}<br>{flows_api[pattern]:.1f}%",
-                        showarrow=False,
-                        xanchor="left",
-                        yanchor="middle",
-                        font=dict(size=10),
-                    )
-                )
-
-        # Platform labels
-        annotations.extend(
-            [
-                dict(
-                    x=x_left,
-                    y=max(y_pos_claude, y_pos_api) + 5,
-                    text="Claude.ai",
-                    showarrow=False,
-                    xanchor="center",
-                    font=dict(size=14, color="black"),
-                ),
-                dict(
-                    x=x_right,
-                    y=max(y_pos_claude, y_pos_api) + 5,
-                    text="1P API",
-                    showarrow=False,
-                    xanchor="center",
-                    font=dict(size=14, color="black"),
-                ),
-            ]
-        )
-
-        return shapes, annotations, max(y_pos_claude, y_pos_api)
-
-    # Create augmentation diagram
-    aug_shapes, aug_annotations, aug_height = create_alluvial_traces(
-        augmentation_types, 1
-    )
-
-    # Create automation diagram
-    auto_shapes, auto_annotations, auto_height = create_alluvial_traces(
-        automation_types, 2
-    )
-
-    # Add invisible traces to create subplots
-    fig.add_trace(
-        go.Scatter(x=[0], y=[0], mode="markers", marker=dict(size=0)), row=1, col=1
-    )
-    fig.add_trace(
-        go.Scatter(x=[0], y=[0], mode="markers", marker=dict(size=0)), row=2, col=1
-    )
-
-    # Update layout with shapes and annotations
-    fig.update_layout(
-        title=dict(
-            text="<b>Collaboration Modes: Claude.ai Conversations vs 1P API Transcripts</b>",
-            font=dict(size=16, family="Styrene B LC", color="#B86046"),
-            x=0.5,
-            xanchor="center",
-        ),
-        height=800,
-        width=1200,
-        paper_bgcolor="white",
-        plot_bgcolor="white",
-        showlegend=False,
-    )
-
-    # Ensure white background for both subplots
-    fig.update_xaxes(showgrid=False, zeroline=False, showticklabels=False, row=1, col=1)
-    fig.update_xaxes(showgrid=False, zeroline=False, showticklabels=False, row=2, col=1)
-    fig.update_yaxes(showgrid=False, zeroline=False, showticklabels=False, row=1, col=1)
-    fig.update_yaxes(showgrid=False, zeroline=False, showticklabels=False, row=2, col=1)
-
-    # Add shapes and annotations to each subplot
-    for shape in aug_shapes:
-        fig.add_shape(shape, row=1, col=1)
-    for shape in auto_shapes:
-        fig.add_shape(shape, row=2, col=1)
-
-    for ann in aug_annotations:
-        fig.add_annotation(ann, row=1, col=1)
-    for ann in auto_annotations:
-        fig.add_annotation(ann, row=2, col=1)
-
-    # Set axis ranges and ensure white background
-    fig.update_xaxes(
-        range=[0, 1],
-        showgrid=False,
-        zeroline=False,
-        showticklabels=False,
-        row=1,
-        col=1,
-    )
-    fig.update_xaxes(
-        range=[0, 1],
-        showgrid=False,
-        zeroline=False,
-        showticklabels=False,
-        row=2,
-        col=1,
-    )
-
-    fig.update_yaxes(
-        range=[0, aug_height + 10],
-        showgrid=False,
-        zeroline=False,
-        showticklabels=False,
-        row=1,
-        col=1,
-    )
-    fig.update_yaxes(
-        range=[0, auto_height + 10],
-        showgrid=False,
-        zeroline=False,
-        showticklabels=False,
-        row=2,
-        col=1,
-    )
-
-    # Save plot
-    output_path = Path(output_dir) / "collaboration_alluvial.png"
-    fig.write_image(str(output_path), width=1200, height=800, scale=2)
-    fig.show()
-    return str(output_path)
-
-
-def get_collaboration_shares(df):
-    """
-    Extract collaboration mode shares for each ONET task from intersection data.
-
-    Args:
-        df: Preprocessed data DataFrame
-
-    Returns:
-        dict: {task_name: {mode: percentage}}
-    """
-    # Filter to GLOBAL data only and use pre-calculated percentages
-    collab_data = df[
-        (df["geo_id"] == "GLOBAL")
-        & (df["facet"] == "onet_task::collaboration")
-        & (df["variable"] == "onet_task_collaboration_pct")
-    ].copy()
-
-    # Split the cluster_name into task and collaboration mode
-    collab_data[["task", "mode"]] = collab_data["cluster_name"].str.rsplit(
-        "::", n=1, expand=True
-    )
-
-    # Filter out 'none' and 'not_classified' modes
-    collab_data = collab_data[~collab_data["mode"].isin(["none", "not_classified"])]
-
-    # Use pre-calculated percentages directly
-    collaboration_modes = [
-        "directive",
-        "feedback loop",
-        "learning",
-        "task iteration",
-        "validation",
-    ]
-    result = {}
-
-    for _, row in collab_data.iterrows():
-        task = row["task"]
-        mode = row["mode"]
-
-        if mode in collaboration_modes:
-            if task not in result:
-                result[task] = {}
-            result[task][mode] = float(row["value"])
-
-    return result
-
-
-def create_automation_augmentation_panel(api_df, cai_df, output_dir):
-    """
-    Create combined panel figure showing automation vs augmentation for both platforms.
-
-    Args:
-        api_df: API preprocessed data DataFrame
-        cai_df: Claude.ai preprocessed data DataFrame
-        output_dir: Directory to save the figure
-    """
-    # Create figure with subplots
-    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(16, 8))
-
-    def create_automation_augmentation_subplot(df, ax, title, platform_name):
-        """Helper function to create one automation vs augmentation subplot"""
-        # Get collaboration shares for each task
-        collab_shares = get_collaboration_shares(df)
-
-        # Get task usage counts for bubble sizing
-        df_global = df[df["geo_id"] == "GLOBAL"]
-        task_counts = (
-            df_global[
-                (df_global["facet"] == "onet_task")
-                & (df_global["variable"] == "onet_task_count")
-                & (~df_global["cluster_name"].isin(["none", "not_classified"]))
-            ]
-            .set_index("cluster_name")["value"]
-            .to_dict()
-        )
-
-        # Prepare data for plotting
-        tasks = []
-        automation_scores = []
-        augmentation_scores = []
-        bubble_sizes = []
-
-        for task_name, shares in collab_shares.items():
-            if task_name in task_counts:
-                # Calculate automation score (directive + feedback loop)
-                automation = shares.get("directive", 0) + shares.get("feedback loop", 0)
-
-                # Calculate augmentation score (learning + task iteration + validation)
-                augmentation = (
-                    shares.get("learning", 0)
-                    + shares.get("task iteration", 0)
-                    + shares.get("validation", 0)
-                )
-
-                # Only include tasks with some collaboration data
-                if automation + augmentation > 0:
-                    tasks.append(task_name)
-                    automation_scores.append(automation)
-                    augmentation_scores.append(augmentation)
-                    bubble_sizes.append(task_counts[task_name])
-
-        # Convert to numpy arrays for plotting
-        automation_scores = np.array(automation_scores)
-        augmentation_scores = np.array(augmentation_scores)
-        bubble_sizes = np.array(bubble_sizes)
-
-        # Scale bubble sizes
-        bubble_sizes_scaled = (bubble_sizes / bubble_sizes.max()) * 800 + 40
-
-        # Color points based on whether automation or augmentation dominates
-        colors = []
-        for auto, aug in zip(automation_scores, augmentation_scores, strict=True):
-            if auto > aug:
-                colors.append("#8e6bb1")  # Automation dominant
-            else:
-                colors.append("#4f76c7")  # Augmentation dominant
-
-        # Create scatter plot
-        ax.scatter(
-            automation_scores,
-            augmentation_scores,
-            s=bubble_sizes_scaled,
-            c=colors,
-            alpha=0.7,
-            edgecolors="black",
-            linewidth=0.5,
-        )
-
-        # Add diagonal line (automation = augmentation)
-        max_val = max(automation_scores.max(), augmentation_scores.max())
-        ax.plot([0, max_val], [0, max_val], "--", color="gray", alpha=0.5, linewidth=2)
-
-        # Labels and formatting (increased font sizes)
-        ax.set_xlabel("Automation Share (%)", fontsize=14)
-        ax.set_ylabel(
-            "Augmentation Score (%)",
-            fontsize=14,
-        )
-        ax.set_title(title, fontsize=14, fontweight="bold", pad=15)
-
-        # Calculate percentages for legend
-        automation_dominant_count = sum(
-            1
-            for auto, aug in zip(automation_scores, augmentation_scores, strict=True)
-            if auto > aug
-        )
-        augmentation_dominant_count = len(automation_scores) - automation_dominant_count
-        total_tasks = len(automation_scores)
-
-        automation_pct = (automation_dominant_count / total_tasks) * 100
-        augmentation_pct = (augmentation_dominant_count / total_tasks) * 100
-
-        # Add legend with percentages centered at top
-        automation_patch = plt.scatter(
-            [],
-            [],
-            c="#8e6bb1",
-            alpha=0.7,
-            s=100,
-            label=f"Automation dominant ({automation_pct:.1f}% of Tasks)",
-        )
-        augmentation_patch = plt.scatter(
-            [],
-            [],
-            c="#4f76c7",
-            alpha=0.7,
-            s=100,
-            label=f"Augmentation dominant ({augmentation_pct:.1f}% of Tasks)",
-        )
-        ax.legend(
-            handles=[automation_patch, augmentation_patch],
-            loc="upper center",
-            bbox_to_anchor=(0.5, 0.95),
-            fontsize=12,
-            frameon=True,
-            facecolor="white",
-        )
-
-        # Grid and styling
-        ax.grid(True, alpha=0.3)
-        ax.set_axisbelow(True)
-        ax.tick_params(axis="both", which="major", labelsize=12)
-
-        return len(tasks), automation_pct, augmentation_pct
-
-    # Create API subplot
-    create_automation_augmentation_subplot(api_df, ax1, "1P API", "1P API")
-
-    # Create Claude.ai subplot
-    create_automation_augmentation_subplot(cai_df, ax2, "Claude.ai", "Claude.ai")
-
-    # Add overall title
-    fig.suptitle(
-        "Automation and augmentation dominance across tasks: Claude.ai vs. 1P API",
-        fontsize=16,
-        fontweight="bold",
-        y=0.95,
-        color="#B86046",
-    )
-
-    plt.tight_layout()
-    plt.subplots_adjust(top=0.85)  # More room for suptitle
-
-    # Save plot
-    output_path = Path(output_dir) / "automation_vs_augmentation_panel.png"
-    plt.savefig(output_path, dpi=300, bbox_inches="tight")
-    plt.show()
-    return str(output_path)
-
-
-def extract_token_metrics_from_intersections(df):
-    """
-    Extract token metrics from preprocessed intersection data.
-
-    Args:
-        df: Preprocessed dataframe with intersection facets
-
-    Returns:
-        DataFrame with token metrics for analysis
-    """
-    # Extract data using new variable names from mean value intersections
-    cost_data = df[
-        (df.facet == "onet_task::cost") & (df.variable == "cost_index")
-    ].copy()
-    cost_data["base_task"] = cost_data["cluster_name"].str.replace("::index", "")
-    onet_cost = cost_data.set_index("base_task")["value"].copy()
-
-    prompt_data = df[
-        (df.facet == "onet_task::prompt_tokens")
-        & (df.variable == "prompt_tokens_index")
-    ].copy()
-    prompt_data["base_task"] = prompt_data["cluster_name"].str.replace("::index", "")
-    onet_prompt = prompt_data.set_index("base_task")["value"].copy()
-
-    completion_data = df[
-        (df.facet == "onet_task::completion_tokens")
-        & (df.variable == "completion_tokens_index")
-    ].copy()
-    completion_data["base_task"] = completion_data["cluster_name"].str.replace(
-        "::index", ""
-    )
-    onet_completion = completion_data.set_index("base_task")["value"].copy()
-
-    # Get API call counts for bubble sizing and WLS weights
-    api_records_data = df[
-        (df.facet == "onet_task::prompt_tokens")
-        & (df.variable == "prompt_tokens_count")
-    ].copy()
-    api_records_data["base_task"] = api_records_data["cluster_name"].str.replace(
-        "::count", ""
-    )
-    onet_api_records = api_records_data.set_index("base_task")["value"].copy()
-
-    # Create metrics DataFrame - values are already re-indexed during preprocessing
-    metrics = pd.DataFrame(
-        {
-            "cluster_name": onet_cost.index,
-            "cost_per_record": onet_cost,  # Already indexed (1.0 = average)
-            "avg_prompt_tokens": onet_prompt.reindex(
-                onet_cost.index
-            ),  # Already indexed
-            "avg_completion_tokens": onet_completion.reindex(
-                onet_cost.index
-            ),  # Already indexed
-        }
-    )
-
-    # Get task usage percentages
-    usage_pct_data = df[
-        (df.facet == "onet_task") & (df.variable == "onet_task_pct")
-    ].copy()
-    usage_pct_data["base_task"] = usage_pct_data["cluster_name"]
-    onet_usage_pct = usage_pct_data.set_index("base_task")["value"].copy()
-
-    # Add API records and usage percentages
-    metrics["api_records"] = onet_api_records.reindex(onet_cost.index)
-    metrics["usage_pct"] = onet_usage_pct.reindex(onet_cost.index)
-
-    # Calculate derived metrics
-    metrics["output_input_ratio"] = (
-        metrics["avg_completion_tokens"] / metrics["avg_prompt_tokens"]
-    )
-    metrics["total_tokens"] = (
-        metrics["avg_prompt_tokens"] + metrics["avg_completion_tokens"]
-    )
-
-    return metrics
-
-
-def add_occupational_categories_to_metrics(
-    task_metrics, task_statements, soc_structure
-):
-    """
-    Add occupational categories to task metrics based on ONET mappings.
-
-    Args:
-        task_metrics: DataFrame with task metrics
-        task_statements: ONET task statements DataFrame
-        soc_structure: SOC structure DataFrame
-
-    Returns:
-        DataFrame with occupational categories added
-    """
-    # Standardize task descriptions for matching
-    task_statements["task_standardized"] = (
-        task_statements["Task"].str.strip().str.lower()
-    )
-    task_metrics["cluster_name_standardized"] = (
-        task_metrics["cluster_name"].str.strip().str.lower()
-    )
-
-    # Create mapping from standardized task to major group
-    task_to_major_group = {}
-    for _, row in task_statements.iterrows():
-        if pd.notna(row["Task"]) and pd.notna(row["soc_major_group"]):
-            std_task = row["task_standardized"]
-            major_group = str(int(row["soc_major_group"]))
-            task_to_major_group[std_task] = major_group
-
-    # Map cluster names to major groups
-    task_metrics["soc_major"] = task_metrics["cluster_name_standardized"].map(
-        task_to_major_group
-    )
-
-    # Get major occupational groups from SOC structure
-    major_groups = soc_structure[soc_structure["Major Group"].notna()].copy()
-    major_groups["soc_major"] = major_groups["Major Group"].astype(str).str[:2]
-    major_groups["title"] = major_groups["SOC or O*NET-SOC 2019 Title"]
-
-    # Create a clean mapping from major group code to title
-    major_group_mapping = (
-        major_groups[["soc_major", "title"]]
-        .drop_duplicates()
-        .set_index("soc_major")["title"]
-        .to_dict()
-    )
-
-    # Map major group codes to titles
-    task_metrics["occupational_category"] = task_metrics["soc_major"].map(
-        major_group_mapping
-    )
-
-    # Remove unmapped/not classified tasks from analysis
-    task_metrics = task_metrics[task_metrics["occupational_category"].notna()].copy()
-
-    # Find top 6 categories by usage share (API calls) and group others as "All Other"
-    category_usage = (
-        task_metrics.groupby("occupational_category")["api_records"]
-        .sum()
-        .sort_values(ascending=False)
-    )
-    top_6_categories = list(category_usage.head(6).index)
-
-    # Group smaller categories as "All Other"
-    task_metrics["occupational_category"] = task_metrics["occupational_category"].apply(
-        lambda x: x if x in top_6_categories else "All Other"
-    )
-
-    return task_metrics
-
-
-def create_token_output_bar_chart(df, output_dir):
-    """
-    Create bar chart showing average output (completion) tokens by occupational category.
-
-    Args:
-        df: Preprocessed data DataFrame
-        output_dir: Directory to save the figure
-    """
-    # Load ONET mappings for occupational categories
-    task_statements, soc_structure = load_onet_mappings()
-
-    # Use preprocessed intersection data
-    task_metrics = extract_token_metrics_from_intersections(df)
-
-    # Add occupational categories
-    task_metrics = add_occupational_categories_to_metrics(
-        task_metrics, task_statements, soc_structure
-    )
-
-    # Calculate average output tokens by occupational category
-    category_stats = (
-        task_metrics.groupby("occupational_category")
-        .agg(
-            {
-                "avg_completion_tokens": "mean",  # Average across tasks
-                "api_records": "sum",  # Total API calls for ranking
-            }
-        )
-        .reset_index()
-    )
-
-    # Find top 6 categories by total API calls
-    top_6_categories = category_stats.nlargest(6, "api_records")[
-        "occupational_category"
-    ].tolist()
-
-    # Group smaller categories as "All Other"
-    def categorize(cat):
-        return cat if cat in top_6_categories else "All Other"
-
-    task_metrics["category_group"] = task_metrics["occupational_category"].apply(
-        categorize
-    )
-
-    # Recalculate stats with grouped categories
-    final_stats = (
-        task_metrics.groupby("category_group")
-        .agg(
-            {
-                "avg_completion_tokens": "mean",  # Average output tokens across tasks
-                "api_records": "sum",  # Total usage for reference
-            }
-        )
-        .reset_index()
-    )
-
-    # Sort by output tokens (descending)
-    final_stats = final_stats.sort_values("avg_completion_tokens", ascending=True)
-
-    # Create figure
-    fig, ax = plt.subplots(figsize=(12, 8))
-
-    # Create horizontal bar chart
-    y_pos = np.arange(len(final_stats))
-    colors = [COLOR_CYCLE[i % len(COLOR_CYCLE)] for i in range(len(final_stats))]
-
-    ax.barh(
-        y_pos,
-        final_stats["avg_completion_tokens"],
-        color=colors,
-        alpha=0.8,
-        edgecolor="#333333",
-        linewidth=0.5,
-    )
-
-    # Add value labels
-    for i, (idx, row) in enumerate(final_stats.iterrows()):
-        ax.text(
-            row["avg_completion_tokens"] + 0.02,
-            i,
-            f"{row['avg_completion_tokens']:.2f}",
-            va="center",
-            fontsize=11,
-            fontweight="bold",
-        )
-
-    # Clean up category labels
-    labels = []
-    for cat in final_stats["category_group"]:
-        clean_cat = cat.replace(" Occupations", "").replace(", and ", " & ")
-        labels.append(clean_cat)
-
-    ax.set_yticks(y_pos)
-    ax.set_yticklabels(labels, fontsize=10)
-
-    # Formatting
-    ax.set_xlabel(
-        "Average output token index for observed tasks in a given category",
-        fontsize=12,
-    )
-    ax.set_title(
-        "Average output token index across leading occupational categories",
-        fontsize=14,
-        fontweight="bold",
-        pad=20,
-    )
-
-    # Grid and styling
-    ax.grid(True, alpha=0.3, axis="x")
-    ax.set_axisbelow(True)
-    ax.spines["top"].set_visible(False)
-    ax.spines["right"].set_visible(False)
-    ax.tick_params(axis="x", which="major", labelsize=11)
-
-    plt.tight_layout()
-
-    # Save plot
-    output_path = Path(output_dir) / "token_output_bar_chart.png"
-    plt.savefig(output_path, dpi=300, bbox_inches="tight")
-    plt.show()
-    return str(output_path)
-
-
-def create_completion_vs_input_tokens_scatter(df, output_dir):
-    """
-    Create scatter plot of ln(completion tokens) vs ln(input tokens) by occupational category.
-
-    Args:
-        df: Preprocessed data DataFrame
-        output_dir: Directory to save the figure
-    """
-    # Use preprocessed intersection data
-    task_metrics = extract_token_metrics_from_intersections(df)
-
-    # Create figure
-    fig, ax = plt.subplots(figsize=(12, 8))
-
-    # Transform to natural log
-    ln_input = np.log(task_metrics["avg_prompt_tokens"])
-    ln_output = np.log(task_metrics["avg_completion_tokens"])
-
-    # Load ONET mappings for occupational categories
-    task_statements, soc_structure = load_onet_mappings()
-
-    # Add occupational categories
-    # Standardize task descriptions for matching
-    task_statements["task_standardized"] = (
-        task_statements["Task"].str.strip().str.lower()
-    )
-    task_metrics["cluster_name_standardized"] = (
-        task_metrics.index.str.strip().str.lower()
-    )
-
-    # Create mapping from standardized task to major group
-    task_to_major_group = {}
-    for _, row in task_statements.iterrows():
-        if pd.notna(row["Task"]) and pd.notna(row["soc_major_group"]):
-            std_task = row["task_standardized"]
-            major_group = str(int(row["soc_major_group"]))[:2]
-            task_to_major_group[std_task] = major_group
-
-    # Map cluster names to major groups
-    task_metrics["soc_major"] = task_metrics["cluster_name_standardized"].map(
-        task_to_major_group
-    )
-
-    # Get major occupational groups from SOC structure
-    major_groups = soc_structure[soc_structure["Major Group"].notna()].copy()
-    major_groups["soc_major"] = major_groups["Major Group"].astype(str).str[:2]
-    major_groups["title"] = major_groups["SOC or O*NET-SOC 2019 Title"]
-
-    # Create mapping from major group code to title
-    major_group_mapping = (
-        major_groups[["soc_major", "title"]]
-        .drop_duplicates()
-        .set_index("soc_major")["title"]
-        .to_dict()
-    )
-
-    # Map major group codes to titles
-    task_metrics["occupational_category"] = task_metrics["soc_major"].map(
-        major_group_mapping
-    )
-
-    # Remove unmapped tasks
-    task_metrics = task_metrics[task_metrics["occupational_category"].notna()].copy()
-
-    # Find top 6 categories by total API calls and group others as "All Other"
-    category_usage = (
-        task_metrics.groupby("occupational_category")["api_records"]
-        .sum()
-        .sort_values(ascending=False)
-    )
-    top_6_categories = list(category_usage.head(6).index)
-
-    # Group smaller categories as "All Other"
-    task_metrics["occupational_category"] = task_metrics["occupational_category"].apply(
-        lambda x: x if x in top_6_categories else "All Other"
-    )
-
-    # Transform to natural log
-    ln_input = np.log(task_metrics["avg_prompt_tokens"])
-    ln_output = np.log(task_metrics["avg_completion_tokens"])
-
-    # Create scatter plot with same color scheme as bar chart
-    # Use exact same logic as token output bar chart for consistent colors
-    category_stats = (
-        task_metrics.groupby("occupational_category")
-        .agg(
-            {
-                "avg_completion_tokens": "mean",
-                "api_records": "sum",
-            }
-        )
-        .reset_index()
-    )
-
-    # Find top 6 categories by total API calls
-    top_6_categories = category_stats.nlargest(6, "api_records")[
-        "occupational_category"
-    ].tolist()
-
-    # Group smaller categories as "All Other"
-    def categorize(cat):
-        return cat if cat in top_6_categories else "All Other"
-
-    task_metrics["category_group"] = task_metrics["occupational_category"].apply(
-        categorize
-    )
-
-    # Recalculate final stats with grouped categories
-    final_stats = (
-        task_metrics.groupby("category_group")
-        .agg({"avg_completion_tokens": "mean"})
-        .reset_index()
-        .sort_values("avg_completion_tokens", ascending=True)
-    )
-
-    # Use exact same color assignment as bar chart
-    categories_ordered = final_stats["category_group"].tolist()
-    category_colors = {}
-    for i, category in enumerate(categories_ordered):
-        category_colors[category] = COLOR_CYCLE[i % len(COLOR_CYCLE)]
-
-    for category in categories_ordered:
-        category_data = task_metrics[task_metrics["category_group"] == category]
-        if not category_data.empty:
-            ln_input_cat = np.log(category_data["avg_prompt_tokens"])
-            ln_output_cat = np.log(category_data["avg_completion_tokens"])
-            bubble_sizes_cat = np.sqrt(category_data["api_records"]) * 2
-
-            # Clean up category name for legend
-            clean_name = category.replace(" Occupations", "").replace(", and ", " & ")
-
-            ax.scatter(
-                ln_input_cat,
-                ln_output_cat,
-                s=bubble_sizes_cat,
-                alpha=0.8,
-                c=category_colors[category],
-                edgecolors="black",
-                linewidth=0.2,
-            )
-
-    # Create uniform legend entries
-    legend_elements = []
-    for category in categories_ordered:
-        clean_name = category.replace(" Occupations", "").replace(", and ", " & ")
-        # Get count for this category
-        category_count = len(task_metrics[task_metrics["category_group"] == category])
-        legend_elements.append(
-            plt.scatter(
-                [],
-                [],
-                s=100,
-                alpha=0.8,
-                c=category_colors[category],
-                edgecolors="black",
-                linewidth=0.2,
-                label=f"{clean_name} (N={category_count})",
-            )
-        )
-
-    # Add legend for occupational categories with uniform sizes
-    ax.legend(
-        bbox_to_anchor=(1.05, 1), loc="upper left", frameon=True, facecolor="white"
-    )
-
-    # Add line of best fit
-    model = sm.OLS(ln_output, sm.add_constant(ln_input)).fit()
-    slope = model.params.iloc[1]
-    intercept = model.params.iloc[0]
-    r_squared = model.rsquared
-
-    line_x = np.linspace(ln_input.min(), ln_input.max(), 100)
-    line_y = slope * line_x + intercept
-    ax.plot(
-        line_x,
-        line_y,
-        "k--",
-        alpha=0.7,
-        linewidth=2,
-        label=f"Best fit (R² = {r_squared:.3f}, $\\beta$ = {slope:.3f})",
-    )
-    ax.legend()
-
-    # Customize plot
-    ax.set_xlabel("ln(Input Token Index)", fontsize=12)
-    ax.set_ylabel("ln(Output Token Index)", fontsize=12)
-    ax.set_title(
-        "Output Token Index vs Input Token Index across tasks",
-        fontsize=14,
-        fontweight="bold",
-        pad=20,
-    )
-    ax.grid(True, alpha=0.3)
-
-    plt.tight_layout()
-
-    # Save plot
-    output_path = Path(output_dir) / "completion_vs_input_tokens_scatter.png"
-    plt.savefig(output_path, dpi=300, bbox_inches="tight")
-    plt.show()
-    return str(output_path)
-
-
-def create_occupational_usage_cost_scatter(df, output_dir):
-    """
-    Create aggregated scatter plot of usage share vs average cost per API call by occupational category.
-
-    Args:
-        df: Preprocessed data DataFrame
-        output_dir: Directory to save the figure
-    """
-    # Load ONET mappings for occupational categories
-    task_statements, soc_structure = load_onet_mappings()
-
-    # Use preprocessed intersection data
-    task_metrics = extract_token_metrics_from_intersections(df)
-
-    # Add occupational categories without grouping into "All Other"
-    # Standardize task descriptions for matching
-    task_statements["task_standardized"] = (
-        task_statements["Task"].str.strip().str.lower()
-    )
-    task_metrics["cluster_name_standardized"] = (
-        task_metrics["cluster_name"].str.strip().str.lower()
-    )
-
-    # Create mapping from standardized task to major group
-    task_to_major_group = {}
-    for _, row in task_statements.iterrows():
-        if pd.notna(row["Task"]) and pd.notna(row["soc_major_group"]):
-            std_task = row["task_standardized"]
-            major_group = str(int(row["soc_major_group"]))
-            task_to_major_group[std_task] = major_group
-
-    # Map cluster names to major groups
-    task_metrics["soc_major"] = task_metrics["cluster_name_standardized"].map(
-        task_to_major_group
-    )
-
-    # Get major occupational groups from SOC structure
-    major_groups = soc_structure[soc_structure["Major Group"].notna()].copy()
-    major_groups["soc_major"] = major_groups["Major Group"].astype(str).str[:2]
-    major_groups["title"] = major_groups["SOC or O*NET-SOC 2019 Title"]
-
-    # Create a clean mapping from major group code to title
-    major_group_mapping = (
-        major_groups[["soc_major", "title"]]
-        .drop_duplicates()
-        .set_index("soc_major")["title"]
-        .to_dict()
-    )
-
-    # Map major group codes to titles
-    task_metrics["occupational_category"] = task_metrics["soc_major"].map(
-        major_group_mapping
-    )
-
-    # Remove unmapped/not classified tasks from analysis
-    task_metrics = task_metrics[task_metrics["occupational_category"].notna()].copy()
-
-    # Aggregate by occupational category using pre-calculated percentages
-    category_aggregates = (
-        task_metrics.groupby("occupational_category")
-        .agg(
-            {
-                "usage_pct": "sum",  # Sum of pre-calculated task percentages within category
-                "cost_per_record": "mean",  # Average cost per API call for this category
-            }
-        )
-        .reset_index()
-    )
-
-    # Usage share is already calculated from preprocessing
-    category_aggregates["usage_share"] = category_aggregates["usage_pct"]
-
-    # Create figure
-    fig, ax = plt.subplots(figsize=(12, 8))
-
-    # Transform variables to natural log
-    ln_cost = np.log(category_aggregates["cost_per_record"])
-    ln_usage = np.log(category_aggregates["usage_share"])
-
-    # Get colors for each category - use same logic as token output bar chart
-    # Sort by a metric to ensure consistent ordering (using usage_share descending)
-    category_aggregates_sorted = category_aggregates.sort_values(
-        "usage_share", ascending=False
-    )
-
-    category_colors = {}
-    for i, category in enumerate(category_aggregates_sorted["occupational_category"]):
-        category_colors[category] = COLOR_CYCLE[i % len(COLOR_CYCLE)]
-
-    # Create invisible scatter plot to maintain axis limits
-    ax.scatter(
-        ln_cost,
-        ln_usage,
-        s=0,  # Invisible markers
-        alpha=0,
-    )
-
-    # Add line of best fit
-    model = sm.OLS(ln_usage, sm.add_constant(ln_cost)).fit()
-    slope = model.params.iloc[1]
-    intercept = model.params.iloc[0]
-    r_squared = model.rsquared
-
-    # Generate line points
-    x_line = np.linspace(ln_cost.min(), ln_cost.max(), 50)
-    y_line = slope * x_line + intercept
-
-    # Plot the line of best fit
-    ax.plot(
-        x_line,
-        y_line,
-        "--",
-        color="black",
-        linewidth=2,
-        alpha=0.8,
-        label=f"Best fit (R² = {r_squared:.3f}, $\\beta$ = {slope:.3f})",
-    )
-
-    # Add legend
-    legend = ax.legend(loc="best", frameon=True, facecolor="white")
-    legend.get_frame().set_alpha(0.9)
-
-    # Add category labels centered at data points with text wrapping
-    for i, row in category_aggregates.iterrows():
-        # Clean up and wrap category names
-        clean_name = (
-            row["occupational_category"]
-            .replace(" Occupations", "")
-            .replace(", and ", " & ")
-        )
-        # Wrap long category names to multiple lines
-        wrapped_name = "\n".join(wrap(clean_name, 20))
-
-        ax.text(
-            ln_cost.iloc[i],
-            ln_usage.iloc[i],
-            wrapped_name,
-            ha="center",
-            va="center",
-            fontsize=8,
-            alpha=0.9,
-        )
-
-    # Set labels and title
-    ax.set_xlabel("ln(Average API Cost Index across tasks)", fontsize=12)
-    ax.set_ylabel("ln(Usage share (%))", fontsize=12)
-    ax.set_title(
-        "Usage share and average API cost index by occupational category",
-        fontsize=14,
-        fontweight="bold",
-        pad=20,
-    )
-
-    # Add grid
-    ax.grid(True, alpha=0.3)
-
-    # Adjust layout and save
-    plt.tight_layout()
-
-    output_path = Path(output_dir) / "occupational_usage_cost_scatter.png"
-    plt.savefig(output_path, dpi=300, bbox_inches="tight")
-    plt.show()
-    return str(output_path)
-
-
-def get_merged_api_claude_task_data(api_df, cai_df):
-    """
-    Create merged dataset with API cost/usage data and Claude.ai collaboration modes.
-
-    Args:
-        api_df: API preprocessed data DataFrame
-        cai_df: Claude.ai preprocessed data DataFrame
-
-    Returns:
-        DataFrame with API cost data + Claude.ai collaboration patterns for common tasks
-    """
-    # Extract API token metrics
-    api_metrics = extract_token_metrics_from_intersections(api_df)
-
-    # Get Claude.ai collaboration shares
-    claude_collab_shares = get_collaboration_shares(cai_df)
-
-    # Find common tasks between both platforms
-    api_tasks = set(api_metrics.index)
-    claude_tasks = set(claude_collab_shares.keys())
-    common_tasks = api_tasks.intersection(claude_tasks)
-
-    # Create merged dataset
-    merged_data = []
-
-    for task_name in common_tasks:
-        # Get API metrics for this task
-        api_row = api_metrics.loc[task_name]
-
-        # Get Claude.ai collaboration for this task
-        claude_collab = claude_collab_shares[task_name]
-
-        # Create merged row
-        merged_row = {
-            "cluster_name": task_name,
-            "cost_per_record": api_row["cost_per_record"],
-            "avg_prompt_tokens": api_row["avg_prompt_tokens"],
-            "avg_completion_tokens": api_row["avg_completion_tokens"],
-            "api_records": api_row["api_records"],
-            "output_input_ratio": api_row["output_input_ratio"],
-            "total_tokens": api_row["total_tokens"],
-            # Claude.ai collaboration modes
-            "collab_directive": claude_collab.get("directive", 0),
-            "collab_feedback_loop": claude_collab.get("feedback loop", 0),
-            "collab_learning": claude_collab.get("learning", 0),
-            "collab_task_iteration": claude_collab.get("task iteration", 0),
-            "collab_validation": claude_collab.get("validation", 0),
-        }
-        merged_data.append(merged_row)
-
-    merged_df = pd.DataFrame(merged_data)
-    merged_df.set_index("cluster_name", inplace=True)
-
-    return merged_df
-
-
-def reg_build_df(api_df, cai_df):
-    """
-    Build complete regression dataset for partial regression and full regression analysis.
-    Each row is an ONET task with all variables needed for figures and regression.
-
-    Args:
-        api_df: API preprocessed data DataFrame
-        cai_df: Claude.ai preprocessed data DataFrame
-
-    Returns:
-        DataFrame with complete regression dataset
-    """
-    # Load ONET mappings
-    task_statements, soc_structure = load_onet_mappings()
-
-    # Use merged dataset with API metrics + Claude.ai collaboration
-    task_metrics = get_merged_api_claude_task_data(api_df, cai_df)
-
-    # Add occupational categories (includes "All Other" grouping)
-    task_metrics_with_names = task_metrics.reset_index()
-    task_metrics_with_names = add_occupational_categories_to_metrics(
-        task_metrics_with_names, task_statements, soc_structure
-    )
-    task_metrics = task_metrics_with_names.set_index("cluster_name")
-
-    # Add collaboration missing dummies
-    collaboration_modes = [
-        "directive",
-        "feedback_loop",
-        "learning",
-        "task_iteration",
-        "validation",
-    ]
-
-    for mode in collaboration_modes:
-        collab_col = f"collab_{mode}"
-        missing_col = f"collab_{mode}_missing"
-        if collab_col in task_metrics.columns:
-            task_metrics[missing_col] = (task_metrics[collab_col] == 0).astype(int)
-        else:
-            task_metrics[missing_col] = 1
-
-    # Calculate usage variables
-    total_api_records = task_metrics["api_records"].sum()
-    task_metrics["usage_share"] = (
-        task_metrics["api_records"] / total_api_records
-    ) * 100
-    task_metrics["ln_usage_share"] = np.log(task_metrics["usage_share"])
-    task_metrics["ln_cost_per_task"] = np.log(task_metrics["cost_per_record"])
-
-    # Use all data
-    valid_data = task_metrics
-
-    # Create occupational category dummies while preserving original column
-    valid_data = pd.get_dummies(
-        valid_data, columns=["occupational_category"], prefix="occ"
-    )
-
-    # Restore the original occupational_category column for grouping operations
-    # Extract category name from the dummy columns that are 1
-    occ_cols = [col for col in valid_data.columns if col.startswith("occ_")]
-    valid_data["occupational_category"] = ""
-    for col in occ_cols:
-        category_name = col.replace("occ_", "")
-        mask = valid_data[col] == 1
-        valid_data.loc[mask, "occupational_category"] = category_name
-
-    return valid_data
-
-
-def create_partial_regression_plot(api_df, cai_df, output_dir):
-    """
-    Create partial regression scatter plot of usage share vs cost, controlling for occupational categories.
-
-    Args:
-        api_df: API preprocessed data DataFrame
-        cai_df: Claude.ai preprocessed data DataFrame
-        output_dir: Directory to save the figure
-
-    Returns:
-        Tuple of (output_path, regression_results_dict)
-    """
-    # Use centralized data preparation (includes occupational dummies)
-    valid_metrics = reg_build_df(api_df, cai_df)
-
-    # Extract occupational dummies and collaboration variables
-    occ_cols = [col for col in valid_metrics.columns if col.startswith("occ_")]
-    collab_vars = [
-        "collab_directive",
-        "collab_feedback_loop",
-        "collab_learning",
-        "collab_task_iteration",
-        "collab_validation",
-    ]
-    collab_missing_vars = [
-        "collab_directive_missing",
-        "collab_feedback_loop_missing",
-        "collab_learning_missing",
-        "collab_task_iteration_missing",
-        "collab_validation_missing",
-    ]
-
-    # Control variables (all occupational dummies + collaboration modes)
-    control_vars = valid_metrics[occ_cols + collab_vars + collab_missing_vars].astype(
-        float
-    )
-
-    # Ensure dependent variables are float
-    y_usage = valid_metrics["ln_usage_share"].astype(float)
-    y_cost = valid_metrics["ln_cost_per_task"].astype(float)
-
-    # Step 1: Regress ln(usage_share) on controls (no constant)
-    usage_model = sm.OLS(y_usage, control_vars).fit()
-    usage_residuals = usage_model.resid
-
-    # Step 2: Regress ln(cost) on controls (no constant)
-    cost_model = sm.OLS(y_cost, control_vars).fit()
-    cost_residuals = cost_model.resid
-
-    # Find top 6 categories by usage share for coloring
-    category_usage = (
-        valid_metrics.groupby("occupational_category")["api_records"]
-        .sum()
-        .sort_values(ascending=False)
-    )
-    top_6_categories = list(category_usage.head(6).index)
-
-    # Create category grouping for coloring
-    valid_metrics["category_group"] = valid_metrics["occupational_category"].apply(
-        lambda x: x if x in top_6_categories else "All Other"
-    )
-
-    # Create figure
-    fig, ax = plt.subplots(figsize=(14, 10))
-
-    # Create color mapping for top 6 + "All Other"
-    unique_groups = valid_metrics["category_group"].unique()
-    group_colors = {}
-    color_idx = 0
-
-    # Assign colors to top 6 categories first
-    for cat in top_6_categories:
-        if cat in unique_groups:
-            group_colors[cat] = COLOR_CYCLE[color_idx % len(COLOR_CYCLE)]
-            color_idx += 1
-
-    # Assign color to "All Other"
-    if "All Other" in unique_groups:
-        group_colors["All Other"] = "#999999"  # Gray for all other
-
-    # Create single scatter plot (no color by group)
-    ax.scatter(
-        cost_residuals,
-        usage_residuals,
-        s=100,
-        alpha=0.8,
-        color=COLOR_CYCLE[0],
-        edgecolors="black",
-        linewidth=0.2,
-    )
-
-    # Add overall trend line for residuals
-    model = sm.OLS(usage_residuals, sm.add_constant(cost_residuals)).fit()
-    slope = model.params.iloc[1]
-    intercept = model.params.iloc[0]
-    r_squared = model.rsquared
-
-    line_x = np.linspace(cost_residuals.min(), cost_residuals.max(), 100)
-    line_y = slope * line_x + intercept
-    ax.plot(
-        line_x,
-        line_y,
-        "k--",
-        alpha=0.8,
-        linewidth=2,
-        label=f"Partial relationship (R² = {r_squared:.3f})",
-    )
-
-    # Customize plot
-    ax.set_xlabel("Residual ln(API Cost Index)")
-    ax.set_ylabel("Residual ln(Usage share (%))")
-    ax.set_title(
-        "Task usage share vs API Cost Index \n(partial regression after controlling for task characteristics)",
-        fontsize=16,
-        fontweight="bold",
-        pad=20,
-    )
-    ax.grid(True, alpha=0.3)
-
-    # Simple legend with just the trend line
-    ax.legend(loc="best", frameon=True, facecolor="white", framealpha=0.9, fontsize=11)
-
-    plt.tight_layout()
-
-    # Save plot
-    output_path = Path(output_dir) / "partial_regression_plot.png"
-    plt.savefig(output_path, dpi=300, bbox_inches="tight")
-    plt.show()
-
-    # Save regression results
-    regression_results = {
-        "partial_correlation": np.sqrt(r_squared),
-        "partial_r_squared": r_squared,
-        "slope": slope,
-        "intercept": intercept,
-        "n_observations": len(valid_metrics),
-        "usage_model_summary": str(usage_model.summary()),
-        "cost_model_summary": str(cost_model.summary()),
-    }
-
-    # Print regression results instead of saving to file
-    print("Partial Regression Analysis Results")
-    print("=" * 50)
-    print(f"Partial correlation: {np.sqrt(r_squared):.4f}")
-    print(f"Partial R-squared: {r_squared:.4f}")
-    print(f"Slope: {slope:.4f}")
-    print(f"Intercept: {intercept:.4f}")
-    print(f"Number of observations: {len(valid_metrics)}")
-    print("\nUsage Model Summary:")
-    print("-" * 30)
-    print(usage_model.summary())
-    print("\nCost Model Summary:")
-    print("-" * 30)
-    print(cost_model.summary())
-
-    return str(output_path), regression_results
-
-
-def perform_usage_share_regression_unweighted(api_df, cai_df, output_dir):
-    """
-    Perform unweighted usage share regression analysis using Claude.ai collaboration modes.
-
-    Args:
-        api_df: API preprocessed data DataFrame
-        cai_df: Claude.ai preprocessed data DataFrame
-        output_dir: Directory to save regression results
-
-    Returns:
-        OLS model results
-    """
-    # Use centralized data preparation (includes all dummies)
-    valid_data = reg_build_df(api_df, cai_df)
-
-    # Extract all regression variables
-    X_cols = ["ln_cost_per_task"]
-    X_cols.extend(
-        [
-            f"collab_{mode}"
-            for mode in [
-                "directive",
-                "feedback_loop",
-                "learning",
-                "task_iteration",
-                "validation",
-            ]
-        ]
-    )
-    X_cols.extend(
-        [
-            f"collab_{mode}_missing"
-            for mode in [
-                "directive",
-                "feedback_loop",
-                "learning",
-                "task_iteration",
-                "validation",
-            ]
-        ]
-    )
-    X_cols.extend([col for col in valid_data.columns if col.startswith("occ_")])
-
-    # Ensure all columns are numeric
-    X = valid_data[X_cols].astype(float)
-    y = valid_data["ln_usage_share"].astype(float)
-
-    # Run unweighted OLS without constant (to include all occupational dummies)
-    model = sm.OLS(y, X).fit()
-
-    # Get heteroskedasticity-robust standard errors (HC1)
-    model_robust = model.get_robustcov_results(cov_type="HC1")
-
-    return model_robust
-
-
-def create_btos_ai_adoption_chart(btos_df, ref_dates_df, output_dir):
-    """
-    Create BTOS AI adoption time series chart.
-
-    Args:
-        btos_df: BTOS response estimates DataFrame
-        ref_dates_df: Collection and reference dates DataFrame
-        output_dir: Directory to save the figure
-    """
-    # Filter for Question ID 7, Answer ID 1 (Yes response to AI usage)
-    btos_filtered = btos_df[(btos_df["Question ID"] == 7) & (btos_df["Answer ID"] == 1)]
-
-    # Get date columns (string columns that look like YYYYWW)
-    date_columns = [
-        col for col in btos_df.columns[4:] if str(col).isdigit() and len(str(col)) == 6
-    ]
-
-    # Extract time series
-    btos_ts = btos_filtered[date_columns].T
-    btos_ts.columns = ["percentage"]
-
-    # Map to reference end dates
-    ref_dates_df["Ref End"] = pd.to_datetime(ref_dates_df["Ref End"])
-    btos_ts = btos_ts.reset_index()
-    btos_ts["smpdt"] = btos_ts["index"].astype(int)
-    btos_ts = btos_ts.merge(
-        ref_dates_df[["Smpdt", "Ref End"]],
-        left_on="smpdt",
-        right_on="Smpdt",
-        how="left",
-    )
-    btos_ts = btos_ts.set_index("Ref End")[["percentage"]]
-
-    # Convert percentage strings to numeric
-    btos_ts["percentage"] = btos_ts["percentage"].str.rstrip("%").astype(float)
-    btos_ts = btos_ts.sort_index().dropna()
-
-    # Calculate 3-period moving average
-    btos_ts["moving_avg"] = btos_ts["percentage"].rolling(window=3).mean()
-
-    # Create figure
-    fig, ax = plt.subplots(figsize=(14, 8))
-
-    # Plot main line
-    ax.plot(
-        btos_ts.index,
-        btos_ts["percentage"],
-        linewidth=3,
-        marker="o",
-        markersize=6,
-        label="AI Adoption Rate Among US Businesses",
-        zorder=3,
-    )
-
-    # Plot moving average
-    ax.plot(
-        btos_ts.index,
-        btos_ts["moving_avg"],
-        linewidth=2,
-        linestyle="--",
-        alpha=0.8,
-        label="3-Period Moving Average",
-        zorder=2,
-    )
-
-    # Styling
-    ax.set_xlabel("Date", fontsize=14)
-    ax.set_ylabel("AI adoption rate (%)", fontsize=14)
-    ax.set_title(
-        "Census reported AI adoption rates among US businesses from the Business Trends and Outlook Survey",
-        fontsize=16,
-        fontweight="bold",
-        pad=20,
-    )
-
-    # Format y-axis as percentage
-    ax.set_ylim(0, max(btos_ts["percentage"]) * 1.1)
-
-    # Rotate x-axis labels
-    ax.tick_params(axis="x", rotation=45)
-
-    # Grid and styling
-    ax.grid(True, alpha=0.3, linestyle="--")
-    ax.set_axisbelow(True)
-    ax.spines["top"].set_visible(False)
-    ax.spines["right"].set_visible(False)
-
-    # Legend
-    ax.legend(loc="upper left", fontsize=11, frameon=True, facecolor="white")
-
-    plt.tight_layout()
-
-    # Save plot
-    output_path = Path(output_dir) / "btos_ai_adoption_chart.png"
-    plt.savefig(output_path, dpi=300, bbox_inches="tight")
-    plt.show()
-    return str(output_path)

release_2025_09_15/code/aei_analysis_functions_claude_ai.py

@@ -1,2926 +0,0 @@
-#!/usr/bin/env python3
-"""
-Analysis functions for AEI Report v3 Claude.ai chapter
-"""
-
-import textwrap
-
-import geopandas as gpd
-import matplotlib.colors as mcolors
-import matplotlib.patches as mpatches
-import matplotlib.pyplot as plt
-import numpy as np
-import pandas as pd
-import statsmodels.api as sm
-from matplotlib.colors import LinearSegmentedColormap, Normalize, TwoSlopeNorm
-from matplotlib.lines import Line2D
-from matplotlib.patches import FancyBboxPatch, Patch
-from mpl_toolkits.axes_grid1 import make_axes_locatable
-
-# global list of excluded countries (ISO-3 codes)
-EXCLUDED_COUNTRIES = [
-    "AFG",
-    "BLR",
-    "COD",
-    "CAF",
-    "CHN",
-    "CUB",
-    "ERI",
-    "ETH",
-    "HKG",
-    "IRN",
-    "PRK",
-    "LBY",
-    "MLI",
-    "MMR",
-    "MAC",
-    "NIC",
-    "RUS",
-    "SDN",
-    "SOM",
-    "SSD",
-    "SYR",
-    "VEN",
-    "YEM",
-]
-
-# Minimum observation thresholds
-MIN_OBSERVATIONS_COUNTRY = 200  # Threshold for countries
-MIN_OBSERVATIONS_US_STATE = 100  # Threshold for US states
-
-# Define the tier colors
-TIER_COLORS_LIST = ["#E6DBD0", "#E5C5AB", "#E4AF86", "#E39961", "#D97757"]
-
-# Anthropic brand color for borders
-ANTHROPIC_OAT = "#E3DACC"
-AUGMENTATION_COLOR = "#00A078"
-AUTOMATION_COLOR = "#FF9940"
-
-# Standard tier color mapping used throughout
-TIER_COLORS_DICT = {
-    "Minimal": TIER_COLORS_LIST[0],  # Lightest
-    "Emerging (bottom 25%)": TIER_COLORS_LIST[1],
-    "Lower middle (25-50%)": TIER_COLORS_LIST[2],
-    "Upper middle (50-75%)": TIER_COLORS_LIST[3],
-    "Leading (top 25%)": TIER_COLORS_LIST[4],  # Darkest
-}
-
-# Standard tier ordering
-TIER_ORDER = [
-    "Leading (top 25%)",
-    "Upper middle (50-75%)",
-    "Lower middle (25-50%)",
-    "Emerging (bottom 25%)",
-    "Minimal",
-]
-
-# Numeric tier color mapping (for tier values 0-4)
-TIER_COLORS_NUMERIC = {i: color for i, color in enumerate(TIER_COLORS_LIST)}
-
-# Numeric tier name mapping (for tier values 1-4 in actual data)
-TIER_NAMES_NUMERIC = {
-    1: "Emerging (bottom 25%)",
-    2: "Lower middle (25-50%)",
-    3: "Upper middle (50-75%)",
-    4: "Leading (top 25%)",
-}
-
-# Create a custom colormap that can be used for continuous variables
-CUSTOM_CMAP = LinearSegmentedColormap.from_list("custom_tier", TIER_COLORS_LIST, N=256)
-
-# Map layout constants
-MAP_PADDING_X = 0.25  # Horizontal padding for legend space
-MAP_PADDING_Y = 0.05  # Vertical padding
-ALASKA_INSET_BOUNDS = [0.26, 0.18, 0.15, 0.15]  # [left, bottom, width, height]
-HAWAII_INSET_BOUNDS = [0.40, 0.18, 0.11, 0.11]  # [left, bottom, width, height]
-
-
-# Figure style and setup
-def setup_plot_style():
-    """Configure matplotlib."""
-    plt.style.use("default")
-    plt.rcParams.update(
-        {
-            "figure.dpi": 150,
-            "savefig.dpi": 150,
-            "font.size": 10,
-            "axes.labelsize": 11,
-            "axes.titlesize": 12,
-            "xtick.labelsize": 9,
-            "ytick.labelsize": 9,
-            "legend.fontsize": 9,
-            "figure.facecolor": "white",
-            "axes.facecolor": "white",
-            "savefig.facecolor": "white",
-            "axes.edgecolor": "#333333",
-            "axes.linewidth": 0.8,
-            "axes.grid": True,
-            "grid.alpha": 0.3,
-            "grid.linestyle": "-",
-            "grid.linewidth": 0.5,
-            "axes.axisbelow": True,
-        }
-    )
-
-
-def create_figure(figsize=(12, 8), tight_layout=True, nrows=1, ncols=1):
-    """Create a figure with consistent settings.
-
-    Args:
-        figsize: Figure size tuple
-        tight_layout: Whether to use tight layout
-        nrows: Number of subplot rows
-        ncols: Number of subplot columns
-
-    Returns:
-        fig, ax or fig, axes depending on subplot configuration
-    """
-    fig, ax = plt.subplots(nrows, ncols, figsize=figsize)
-    if tight_layout:
-        fig.tight_layout()
-    else:
-        # Explicitly disable the layout engine to prevent warnings
-        fig.set_layout_engine(layout="none")
-    return fig, ax
-
-
-def format_axis(
-    ax,
-    xlabel=None,
-    ylabel=None,
-    title=None,
-    xlabel_size=11,
-    ylabel_size=11,
-    title_size=13,
-    grid=True,
-    grid_alpha=0.3,
-):
-    """Apply consistent axis formatting."""
-    if xlabel:
-        ax.set_xlabel(xlabel, fontsize=xlabel_size)
-    if ylabel:
-        ax.set_ylabel(ylabel, fontsize=ylabel_size)
-    if title:
-        ax.set_title(title, fontsize=title_size, fontweight="bold", pad=15)
-    if grid:
-        ax.grid(True, alpha=grid_alpha)
-    return ax
-
-
-def get_color_normalizer(values, center_at_one=False, vmin=None, vmax=None):
-    """Create appropriate color normalizer for data."""
-    if center_at_one:
-        # Use TwoSlopeNorm for diverging around 1.0
-        if vmin is None:
-            vmin = min(values.min(), 0.1)
-        if vmax is None:
-            vmax = max(values.max(), 2.0)
-        return TwoSlopeNorm(vmin=vmin, vcenter=1.0, vmax=vmax)
-    else:
-        # Use regular normalization
-        if vmin is None:
-            vmin = values.min()
-        if vmax is None:
-            vmax = values.max()
-        return Normalize(vmin=vmin, vmax=vmax)
-
-
-def create_tier_legend(
-    ax,
-    tier_colors,
-    tiers_in_data,
-    excluded_countries=False,
-    no_data=False,
-    loc="lower left",
-    title="Anthropic AI Usage Index tier",
-):
-    """Create a consistent tier legend for maps."""
-    legend_elements = []
-    for tier in TIER_ORDER:
-        if tier in tiers_in_data:
-            legend_elements.append(
-                mpatches.Patch(
-                    facecolor=tier_colors[tier], edgecolor="none", label=tier
-                )
-            )
-
-    if excluded_countries:
-        legend_elements.append(
-            mpatches.Patch(
-                facecolor="#c0c0c0", edgecolor="white", label="Claude not available"
-            )
-        )
-
-    if no_data:
-        legend_elements.append(
-            mpatches.Patch(facecolor="#f0f0f0", edgecolor="white", label="No data")
-        )
-
-    if legend_elements:
-        ax.legend(
-            handles=legend_elements,
-            loc=loc,
-            fontsize=10,
-            bbox_to_anchor=(0, 0) if loc == "lower left" else None,
-            title=title,
-            title_fontsize=11,
-            frameon=True,
-            fancybox=True,
-            shadow=True,
-        )
-
-    return ax
-
-
-# Data wrangling helpers
-
-
-def filter_df(df, **kwargs):
-    """Universal filter helper for dataframes.
-
-    Args:
-        df: DataFrame to filter
-        **kwargs: Column-value pairs to filter on
-                  Lists are handled with .isin()
-
-    Returns:
-        Filtered DataFrame
-    """
-    mask = pd.Series([True] * len(df), index=df.index)
-
-    for key, value in kwargs.items():
-        if value is None:
-            continue  # Skip None values
-        if key in df.columns:
-            if isinstance(value, list):
-                mask = mask & df[key].isin(value)
-            else:
-                mask = mask & (df[key] == value)
-
-    return df[mask]
-
-
-def get_filtered_geographies(df, min_obs_country=None, min_obs_state=None):
-    """
-    Get lists of countries and states that meet MIN_OBSERVATIONS thresholds.
-
-    This function does NOT filter the dataframe - it only identifies which
-    geographies meet the thresholds. The full dataframe is preserved
-    so we can still report statistics for all geographies.
-
-    Args:
-        df: Input dataframe
-        min_obs_country: Minimum observations for countries (default: MIN_OBSERVATIONS_COUNTRY)
-        min_obs_state: Minimum observations for states (default: MIN_OBSERVATIONS_US_STATE)
-
-    Returns:
-        Tuple of (filtered_countries list, filtered_states list)
-    """
-    # Use defaults if not specified
-    if min_obs_country is None:
-        min_obs_country = MIN_OBSERVATIONS_COUNTRY
-    if min_obs_state is None:
-        min_obs_state = MIN_OBSERVATIONS_US_STATE
-
-    # Get country usage counts
-    country_usage = filter_df(df, facet="country", variable="usage_count").set_index(
-        "geo_id"
-    )["value"]
-
-    # Get state usage counts
-    state_usage = filter_df(df, facet="state_us", variable="usage_count").set_index(
-        "geo_id"
-    )["value"]
-
-    # Get countries that meet threshold (excluding not_classified)
-    filtered_countries = country_usage[country_usage >= min_obs_country].index.tolist()
-    filtered_countries = [c for c in filtered_countries if c != "not_classified"]
-
-    # Get states that meet threshold (excluding not_classified)
-    filtered_states = state_usage[state_usage >= min_obs_state].index.tolist()
-    filtered_states = [s for s in filtered_states if s != "not_classified"]
-
-    return filtered_countries, filtered_states
-
-
-def filter_requests_by_threshold(df, geography, geo_id, level=1, threshold=1.0):
-    """
-    Filter requests to only include requests at a specific level that meet threshold requirements.
-
-    Args:
-        df: Long format dataframe with request data
-        geography: Current geography level ('country' or 'state_us')
-        geo_id: Current geography ID (e.g., 'USA', 'CA')
-        level: Request level to filter (default=1 for middle aggregated)
-        threshold: Minimum percentage threshold (default=1.0%)
-
-    Returns:
-        List of valid cluster_names that:
-        1. Are at the specified level (default level 1)
-        2. Have >= threshold % in the current geography
-        3. Have >= threshold % in the parent geography (USA for states, GLOBAL for countries)
-    """
-    # Determine parent geography
-    if geography == "state_us":
-        parent_geo = "USA"
-        parent_geography = "country"
-    elif geography == "country":
-        parent_geo = "GLOBAL"
-        parent_geography = "global"
-    else:  # global
-        # For global, no parent filtering needed
-        df_local = filter_df(
-            df,
-            geography=geography,
-            geo_id=geo_id,
-            facet="request",
-            level=level,
-            variable="request_pct",
-        )
-        return df_local[df_local["value"] >= threshold]["cluster_name"].tolist()
-
-    # Get local request percentages at specified level
-    df_local = filter_df(
-        df,
-        geography=geography,
-        geo_id=geo_id,
-        facet="request",
-        level=level,
-        variable="request_pct",
-    )
-
-    # Get parent request percentages at same level
-    df_parent = filter_df(
-        df,
-        geography=parent_geography,
-        geo_id=parent_geo,
-        facet="request",
-        level=level,
-        variable="request_pct",
-    )
-
-    # Filter by local threshold
-    local_valid = set(df_local[df_local["value"] >= threshold]["cluster_name"])
-
-    # Filter by parent threshold
-    parent_valid = set(df_parent[df_parent["value"] >= threshold]["cluster_name"])
-
-    # Return intersection (must meet both thresholds)
-    return list(local_valid & parent_valid)
-
-
-# Data loading
-
-
-def load_world_shapefile():
-    """Load and prepare world shapefile for mapping."""
-    url = "https://naciscdn.org/naturalearth/10m/cultural/ne_10m_admin_0_countries_iso.zip"
-    world = gpd.read_file(url)
-
-    # Remove Antarctica from the dataset entirely
-    world = world[world["ISO_A3_EH"] != "ATA"]
-
-    # Use Robinson projection for better world map appearance
-    world = world.to_crs("+proj=robin")
-
-    # Mark excluded countries using global EXCLUDED_COUNTRIES
-    world["is_excluded"] = world["ISO_A3_EH"].isin(EXCLUDED_COUNTRIES)
-
-    return world
-
-
-def load_us_states_shapefile():
-    """Load and prepare US states shapefile for mapping."""
-    import ssl
-
-    # Create unverified SSL context to handle Census Bureau cert issues
-    ssl._create_default_https_context = ssl._create_unverified_context
-
-    states_url = (
-        "https://www2.census.gov/geo/tiger/GENZ2018/shp/cb_2018_us_state_20m.zip"
-    )
-    states = gpd.read_file(states_url)
-
-    # Filter out territories but keep all 50 states and DC
-    states = states[~states["STUSPS"].isin(["PR", "VI", "MP", "GU", "AS"])]
-
-    return states
-
-
-def merge_geo_data(shapefile, df_data, geo_column, columns_to_merge, is_tier=False):
-    """Merge data with geographic shapefile.
-
-    Args:
-        shapefile: GeoDataFrame (world or states)
-        df_data: DataFrame with data to merge
-        geo_column: Column in shapefile to join on (e.g., 'ISO_A3_EH', 'STUSPS')
-        columns_to_merge: List of columns to merge from df_data
-        is_tier: Whether this is tier data (includes cluster_name)
-
-    Returns:
-        Merged GeoDataFrame
-    """
-    if is_tier and "cluster_name" not in columns_to_merge:
-        columns_to_merge = columns_to_merge + ["cluster_name"]
-
-    return shapefile.merge(
-        df_data[columns_to_merge], left_on=geo_column, right_on="geo_id", how="left"
-    )
-
-
-def prepare_map_data(
-    geo_df,
-    value_column="value",
-    center_at_one=False,
-    excluded_mask=None,
-):
-    """Prepare data and normalization for map plotting.
-
-    Args:
-        geo_df: GeoDataFrame with geographic data and values to plot
-        value_column: Name of column containing values to plot (default: "value")
-        center_at_one: If True, center color scale at 1.0 for diverging colormap (default: False)
-        excluded_mask: Boolean Series indicating which rows to exclude from normalization
-                       (e.g., countries where service isn't available). If None, no exclusions.
-
-    Returns:
-        tuple: (plot_column_name, norm) where norm is the matplotlib Normalize object
-    """
-    if excluded_mask is None:
-        excluded_mask = pd.Series([False] * len(geo_df), index=geo_df.index)
-
-    valid_data = geo_df[geo_df[value_column].notna() & ~excluded_mask][value_column]
-
-    vmin = valid_data.min() if len(valid_data) > 0 else 0
-    vmax = valid_data.max() if len(valid_data) > 0 else 1
-    norm = get_color_normalizer(
-        valid_data, center_at_one=center_at_one, vmin=vmin, vmax=vmax
-    )
-
-    return value_column, norm
-
-
-# Main visualization functions
-
-
-def plot_world_map(
-    ax, world, data_column="value", tier_colors=None, cmap=None, norm=None
-):
-    """Plot world map with data.
-
-    Args:
-        ax: matplotlib axis
-        world: GeoDataFrame with world data (already merged with values)
-        data_column: column name containing data to plot
-        tier_colors: dict mapping tier names to colors (for categorical)
-        cmap: colormap (for continuous)
-        norm: normalization (for continuous)
-    """
-    if tier_colors:
-        # Plot each tier with its color
-        for tier, color in tier_colors.items():
-            tier_countries = world[
-                (world["cluster_name"] == tier) & (~world["is_excluded"])
-            ]
-            tier_countries.plot(ax=ax, color=color, edgecolor="white", linewidth=0.5)
-    else:
-        # Plot continuous data
-        world_with_data = world[
-            world[data_column].notna() & (world["is_excluded"] == False)
-        ]
-        world_with_data.plot(
-            column=data_column, ax=ax, cmap=cmap, norm=norm, legend=False
-        )
-
-    # Plot excluded countries
-    excluded = world[world["is_excluded"] == True]
-    if not excluded.empty:
-        excluded.plot(ax=ax, color="#c0c0c0", edgecolor="white", linewidth=0.5)
-
-    # Plot no-data countries
-    no_data = world[
-        (world[data_column if not tier_colors else "cluster_name"].isna())
-        & (~world["is_excluded"])
-    ]
-    if not no_data.empty:
-        no_data.plot(ax=ax, color="#f0f0f0", edgecolor="white", linewidth=0.5)
-
-    # Set appropriate bounds for Robinson projection
-    ax.set_xlim(-17000000, 17000000)
-    ax.set_ylim(-8500000, 8500000)
-
-
-def plot_us_states_map(
-    fig, ax, states, data_column="value", tier_colors=None, cmap=None, norm=None
-):
-    """Plot US states map with Alaska and Hawaii insets.
-
-    Args:
-        fig: matplotlib figure
-        ax: main axis for continental US
-        states: GeoDataFrame with state data (already merged with values)
-        data_column: column name containing data to plot
-        tier_colors: dict mapping tier names to colors (for categorical)
-        cmap: colormap (for continuous)
-        norm: normalization (for continuous)
-    """
-    # Project to EPSG:2163 for US Albers Equal Area
-    states = states.to_crs("EPSG:2163")
-
-    # Plot continental US (everything except AK and HI)
-    continental = states[~states["STUSPS"].isin(["AK", "HI"])]
-
-    # First plot all continental states as no-data background
-    continental.plot(ax=ax, color="#f0f0f0", edgecolor="white", linewidth=0.5)
-
-    # Plot continental states with data
-    if tier_colors:
-        # Plot each tier with its color
-        for tier, color in tier_colors.items():
-            tier_states = continental[continental["cluster_name"] == tier]
-            if not tier_states.empty:
-                tier_states.plot(ax=ax, color=color, edgecolor="white", linewidth=0.5)
-    else:
-        # Plot continuous data
-        continental_with_data = continental[continental[data_column].notna()]
-        if not continental_with_data.empty:
-            continental_with_data.plot(
-                column=data_column, ax=ax, cmap=cmap, norm=norm, legend=False
-            )
-
-    # Set axis limits with padding for legend
-    xlim = ax.get_xlim()
-    ylim = ax.get_ylim()
-    x_padding = (xlim[1] - xlim[0]) * MAP_PADDING_X
-    y_padding = (ylim[1] - ylim[0]) * MAP_PADDING_Y
-    ax.set_xlim(xlim[0] - x_padding, xlim[1] + x_padding)
-    ax.set_ylim(ylim[0] - y_padding, ylim[1] + y_padding)
-
-    # Add Alaska inset
-    akax = fig.add_axes(ALASKA_INSET_BOUNDS)
-    akax.axis("off")
-
-    alaska = states[states["STUSPS"] == "AK"]
-    if not alaska.empty:
-        alaska.plot(ax=akax, color="#f0f0f0", edgecolor="white", linewidth=0.5)
-
-        if tier_colors and alaska["cluster_name"].notna().any():
-            tier_name = alaska["cluster_name"].iloc[0]
-            if tier_name in tier_colors:
-                alaska.plot(
-                    ax=akax,
-                    color=tier_colors[tier_name],
-                    edgecolor="white",
-                    linewidth=0.5,
-                )
-        elif not tier_colors and alaska[data_column].notna().any():
-            alaska.plot(column=data_column, ax=akax, cmap=cmap, norm=norm, legend=False)
-
-    # Add Hawaii inset
-    hiax = fig.add_axes(HAWAII_INSET_BOUNDS)
-    hiax.axis("off")
-
-    hawaii = states[states["STUSPS"] == "HI"]
-    if not hawaii.empty:
-        hawaii.plot(ax=hiax, color="#f0f0f0", edgecolor="white", linewidth=0.5)
-
-        if tier_colors and hawaii["cluster_name"].notna().any():
-            tier_name = hawaii["cluster_name"].iloc[0]
-            if tier_name in tier_colors:
-                hawaii.plot(
-                    ax=hiax,
-                    color=tier_colors[tier_name],
-                    edgecolor="white",
-                    linewidth=0.5,
-                )
-        elif not tier_colors and hawaii[data_column].notna().any():
-            hawaii.plot(column=data_column, ax=hiax, cmap=cmap, norm=norm, legend=False)
-
-
-def plot_usage_index_bars(
-    df,
-    geography="country",
-    top_n=None,
-    figsize=(12, 8),
-    title=None,
-    filtered_entities=None,
-    show_usage_counts=True,
-    cmap=CUSTOM_CMAP,
-):
-    """
-    Create horizontal bar chart of Anthropic AI Usage Index.
-
-    Args:
-        df: Long format dataframe
-        geography: 'country' or 'state_us'
-        top_n: Number of top entities to show (None for all)
-        figsize: Figure size
-        title: Chart title
-        filtered_entities: List of geo_id values to include (if None, include all)
-        show_usage_counts: If True, show usage counts in labels (default: True)
-    """
-    # Get data
-    df_metric = filter_df(
-        df, geography=geography, facet=geography, variable="usage_per_capita_index"
-    )
-
-    # Apply entity filtering if provided
-    if filtered_entities is not None:
-        df_metric = df_metric[df_metric["geo_id"].isin(filtered_entities)]
-
-    # Get usage counts for display if requested
-    if show_usage_counts:
-        df_usage = filter_df(
-            df, geography=geography, facet=geography, variable="usage_count"
-        )
-        # Merge to get usage counts
-        df_metric = df_metric.merge(
-            df_usage[["geo_id", "value"]],
-            on="geo_id",
-            suffixes=("", "_usage"),
-            how="left",
-        )
-
-    # Select entities to display
-    if top_n is None or top_n >= len(df_metric):
-        # Show all entities, sorted by lowest value first (will appear at bottom of chart)
-        df_top = df_metric.sort_values("value", ascending=True)
-        # Adjust figure height for many entities
-        if len(df_top) > 20:
-            figsize = (figsize[0], max(10, len(df_top) * 0.3))
-    else:
-        # Select top N entities, then sort ascending so highest values appear at top
-        df_top = df_metric.nlargest(top_n, "value")
-        df_top = df_top.sort_values("value", ascending=True)
-
-    # Create figure
-    fig, ax = create_figure(figsize=figsize)
-
-    # Get colormap and create diverging colors centered at 1
-    values = df_top["value"].values
-    min_val = values.min()
-    max_val = values.max()
-
-    # Determine the range for symmetric color scaling around 1
-    max_distance = max(abs(min_val - 1), abs(max_val - 1))
-
-    # Normalize values for color mapping
-    if max_distance > 0:
-        # Normalize to 0-1 centered at 0.5 for value 1
-        normalized = 0.5 + (values - 1) / (2 * max_distance)
-        # Truncate colormap to avoid too light colors
-        truncate_low = 0.2
-        truncate_high = 0.8
-        normalized = truncate_low + normalized * (truncate_high - truncate_low)
-        normalized = np.clip(normalized, truncate_low, truncate_high)
-    else:
-        normalized = np.ones_like(values) * 0.5
-
-    colors = cmap(normalized)
-
-    # Create horizontal bars
-    y_positions = range(len(df_top))
-    bars = ax.barh(y_positions, values, color=colors, height=0.7)
-
-    # Set y-tick labels
-    ax.set_yticks(y_positions)
-    ax.set_yticklabels(df_top["geo_name"].values)
-
-    # Set y-axis limits to reduce white space
-    ax.set_ylim(-0.5, len(df_top) - 0.5)
-
-    # Add baseline reference line at 1.0
-    ax.axvline(x=1.0, color="black", linestyle="--", alpha=0.5, linewidth=1)
-
-    # Calculate and set x-axis limits with extra space for labels
-    if max_val > 2:
-        ax.set_xlim(0, max_val * 1.25)
-    else:
-        ax.set_xlim(0, max_val * 1.2)
-
-    # Add value labels and usage counts
-    for i, bar in enumerate(bars):
-        width = bar.get_width()
-        # Always use 2 decimal places for consistency
-        label = f"{width:.2f}"
-
-        # Get usage count
-        usage_count = df_top.iloc[i]["value_usage"]
-        if usage_count >= 1000:
-            usage_str = f"{usage_count / 1000:.1f}k"
-        else:
-            usage_str = f"{int(usage_count)}"
-
-        # For top_n > 20, combine label with usage count to avoid overlap
-        if not top_n or top_n > 20:
-            combined_label = f"{label} (N={usage_str})"
-            ax.text(
-                width + 0.03,
-                bar.get_y() + bar.get_height() / 2.0,
-                combined_label,
-                ha="left",
-                va="center",
-                fontsize=8,
-            )
-        else:
-            # Add value label to the right of the bar
-            ax.text(
-                width + 0.03,
-                bar.get_y() + bar.get_height() / 2.0,
-                label,
-                ha="left",
-                va="center",
-                fontsize=9,
-            )
-
-            # Add usage count inside the bar
-            usage_str_full = f"N = {usage_str}"
-            ax.text(
-                0.05,
-                bar.get_y() + bar.get_height() / 2.0,
-                usage_str_full,
-                ha="left",
-                va="center",
-                fontsize=8,
-                color="white",
-            )
-
-    # Set labels and title
-    if top_n:
-        default_title = f"Top {top_n} {'countries' if geography == 'country' else 'US states'} by Anthropic AI Usage Index"
-    else:
-        default_title = f"Anthropic AI Usage Index by {'country' if geography == 'country' else 'US state'}"
-
-    format_axis(
-        ax,
-        xlabel="Anthropic AI Usage Index (usage % / working-age population %)",
-        title=title or default_title,
-        grid=True,
-        grid_alpha=0.3,
-    )
-
-    return fig
-
-
-def plot_variable_bars(
-    df,
-    variable,
-    facet,
-    geography="country",
-    geo_id=None,
-    top_n=None,
-    figsize=(12, 8),
-    title=None,
-    xlabel=None,
-    filtered_entities=None,
-    cmap=CUSTOM_CMAP,
-    normalize=False,
-    exclude_not_classified=False,
-):
-    """
-    Create horizontal bar chart for any variable.
-
-    Args:
-        df: Long format dataframe
-        variable: Variable name to plot (e.g., 'soc_pct', 'gdp_per_capita')
-        facet: Facet to use
-        geography: 'country' or 'state_us'
-        geo_id: Optional specific geo_id to filter (e.g., 'USA' for SOC data)
-        top_n: Number of top entities to show (None for all)
-        figsize: Figure size
-        title: Chart title
-        xlabel: x-axis label
-        filtered_entities: List of cluster_name or geo_id values to include
-        cmap: Colormap to use
-        normalize: If True, rescale values to sum to 100% (useful for percentages)
-        exclude_not_classified: If True, exclude 'not_classified' entries before normalizing
-    """
-    # Get data
-    df_metric = filter_df(
-        df, geography=geography, facet=facet, variable=variable, geo_id=geo_id
-    )
-
-    # Exclude not_classified if requested (before normalization)
-    if exclude_not_classified:
-        # Check both cluster_name and geo_id columns
-        if "cluster_name" in df_metric.columns:
-            df_metric = df_metric[
-                ~df_metric["cluster_name"].isin(["not_classified", "none"])
-            ]
-        if "geo_id" in df_metric.columns:
-            df_metric = df_metric[~df_metric["geo_id"].isin(["not_classified", "none"])]
-
-    # Normalize if requested (after filtering not_classified)
-    if normalize:
-        total_sum = df_metric["value"].sum()
-        if total_sum > 0:
-            df_metric["value"] = (df_metric["value"] / total_sum) * 100
-
-    # Apply entity filtering if provided
-    if filtered_entities is not None:
-        # Check if we're filtering by cluster_name or geo_id
-        if "cluster_name" in df_metric.columns:
-            df_metric = df_metric[df_metric["cluster_name"].isin(filtered_entities)]
-        else:
-            df_metric = df_metric[df_metric["geo_id"].isin(filtered_entities)]
-
-    # Select entities to display
-    if top_n is None or top_n >= len(df_metric):
-        # Show all entities, sorted by lowest value first
-        df_top = df_metric.sort_values("value", ascending=True)
-        # Adjust figure height for many entities
-        if len(df_top) > 20:
-            figsize = (figsize[0], max(10, len(df_top) * 0.3))
-    else:
-        # Select top N entities
-        df_top = df_metric.nlargest(top_n, "value")
-        df_top = df_top.sort_values("value", ascending=True)
-
-    # Create figure
-    fig, ax = create_figure(figsize=figsize)
-
-    # Get colormap and colors
-    values = df_top["value"].values
-    min_val = values.min()
-    max_val = values.max()
-
-    # Linear color mapping
-    if max_val > min_val:
-        normalized = (values - min_val) / (max_val - min_val)
-        # Truncate to avoid extremes
-        normalized = 0.2 + normalized * 0.6
-    else:
-        normalized = np.ones_like(values) * 0.5
-
-    colors = cmap(normalized)
-
-    # Create horizontal bars
-    y_positions = range(len(df_top))
-    bars = ax.barh(y_positions, values, color=colors, height=0.7)
-
-    # Set y-tick labels
-    ax.set_yticks(y_positions)
-    # Use cluster_name or geo_name depending on what's available
-    if "cluster_name" in df_top.columns:
-        labels = df_top["cluster_name"].values
-    elif "geo_name" in df_top.columns:
-        labels = df_top["geo_name"].values
-    else:
-        labels = df_top["geo_id"].values
-    ax.set_yticklabels(labels)
-
-    # Set y-axis limits to reduce white space
-    ax.set_ylim(-0.5, len(df_top) - 0.5)
-
-    # Calculate and set x-axis limits
-    x_range = max_val - min_val
-    if min_val < 0:
-        # Include negative values with some padding
-        ax.set_xlim(min_val - x_range * 0.1, max_val + x_range * 0.2)
-    else:
-        # Positive values only
-        ax.set_xlim(0, max_val * 1.2)
-
-    # Add value labels
-    for _, bar in enumerate(bars):
-        width = bar.get_width()
-        # Format based on value magnitude
-        if abs(width) >= 1000:
-            label = f"{width:.0f}"
-        elif abs(width) >= 10:
-            label = f"{width:.1f}"
-        else:
-            label = f"{width:.2f}"
-
-        # Position label
-        if width < 0:
-            ha = "right"
-            x_offset = -0.01 * (max_val - min_val)
-        else:
-            ha = "left"
-            x_offset = 0.01 * (max_val - min_val)
-
-        ax.text(
-            width + x_offset,
-            bar.get_y() + bar.get_height() / 2.0,
-            label,
-            ha=ha,
-            va="center",
-            fontsize=8 if len(df_top) > 20 else 9,
-        )
-
-    # Set labels and title
-    if not title:
-        if top_n:
-            title = f"Top {top_n} by {variable}"
-        else:
-            title = f"{variable} distribution"
-
-    format_axis(
-        ax,
-        xlabel=xlabel or variable,
-        title=title,
-        grid=True,
-        grid_alpha=0.3,
-    )
-
-    return fig
-
-
-def plot_usage_share_bars(
-    df,
-    geography="country",
-    top_n=20,
-    figsize=(12, 8),
-    title=None,
-    filtered_entities=None,
-    cmap=CUSTOM_CMAP,
-):
-    """
-    Create bar chart showing share of global usage.
-
-    Args:
-        df: Long format dataframe
-        geography: Geographic level
-        top_n: Number of top entities
-        figsize: Figure size
-        title: Chart title
-        filtered_entities: List of geo_id values to include (if None, include all)
-
-    """
-    # Get data
-    df_metric = filter_df(
-        df, geography=geography, facet=geography, variable="usage_pct"
-    )
-
-    # Exclude "not_classified" from the data
-    df_metric = df_metric[df_metric["geo_id"] != "not_classified"]
-
-    # Apply entity filtering if provided
-    if filtered_entities is not None:
-        df_metric = df_metric[df_metric["geo_id"].isin(filtered_entities)]
-
-    # Get top n
-    df_top = df_metric.nlargest(top_n, "value")
-
-    # Create figure
-    fig, ax = create_figure(figsize=figsize)
-
-    # Create bars
-    positions = range(len(df_top))
-    values = df_top["value"].values
-    names = df_top["geo_name"].values
-
-    # Use custom colormap
-    norm = get_color_normalizer(values, center_at_one=False)
-    colors = [cmap(norm(val)) for val in values]
-
-    bars = ax.bar(positions, values, color=colors, alpha=0.8)
-
-    # Customize
-    ax.set_xticks(positions)
-    ax.set_xticklabels(names, rotation=45, ha="right")
-    # Reduce horizontal margins to bring bars closer to plot borders
-    ax.margins(x=0.01)
-
-    default_title = f"Top {top_n} {'countries' if geography == 'country' else 'US states'} by share of global Claude usage"
-    format_axis(
-        ax, ylabel="Share of global usage (%)", title=title or default_title, grid=False
-    )
-
-    # Add value labels
-    for bar, value in zip(bars, values, strict=True):
-        label = f"{value:.1f}%"
-
-        # Add value label above the bar
-        ax.text(
-            bar.get_x() + bar.get_width() / 2,
-            value + 0.1,
-            label,
-            ha="center",
-            fontsize=8,
-        )
-
-    # Grid
-    ax.grid(True, axis="y", alpha=0.3)
-
-    return fig
-
-
-def plot_usage_index_histogram(
-    df, geography="country", bins=30, figsize=(10, 6), title=None, cmap=CUSTOM_CMAP
-):
-    """
-    Create histogram of Anthropic AI Usage Index distribution.
-
-    Args:
-        df: Long format dataframe
-        geography: Geographic level
-        bins: Number of histogram bins
-        figsize: Figure size
-        title: Chart title
-    """
-    # Get data
-    df_metric = filter_df(
-        df, geography=geography, facet=geography, variable="usage_per_capita_index"
-    )
-
-    # Create figure
-    fig, ax = create_figure(figsize=figsize)
-
-    # Create histogram
-    values = df_metric["value"].values
-    _, bins_edges, patches = ax.hist(
-        values, bins=bins, edgecolor="white", linewidth=0.5
-    )
-
-    # Color bars with custom gradient based on value
-    norm = get_color_normalizer(
-        values,
-        center_at_one=False,
-        vmin=min(bins_edges[0], 0),
-        vmax=max(bins_edges[-1], 2),
-    )
-
-    for patch, left_edge, right_edge in zip(
-        patches, bins_edges[:-1], bins_edges[1:], strict=True
-    ):
-        # Use the midpoint of the bin for color
-        mid_val = (left_edge + right_edge) / 2
-        color = cmap(norm(mid_val))
-        patch.set_facecolor(color)
-
-    # Add vertical line at 1.0 (where usage and population shares match)
-    ax.axvline(x=1.0, color="black", linestyle="--", alpha=0.5, linewidth=1)
-
-    # Add statistics
-    mean_val = values.mean()
-    median_val = np.median(values)
-
-    stats_text = f"Mean: {mean_val:.2f}\nMedian: {median_val:.2f}\nN = {len(values)}"
-    ax.text(
-        0.98,
-        0.97,
-        stats_text,
-        transform=ax.transAxes,
-        ha="right",
-        va="top",
-        fontsize=9,
-        bbox=dict(boxstyle="round", facecolor="white", alpha=0.8),
-    )
-
-    # Customize
-    geo_label = "countries" if geography == "country" else "US states"
-    default_title = f"Distribution of Anthropic AI Usage Index ({geo_label})"
-
-    format_axis(
-        ax,
-        xlabel="Anthropic AI Usage Index (usage % / working-age population %)",
-        ylabel=f"Number of {geo_label}",
-        title=title or default_title,
-    )
-
-    return fig
-
-
-def plot_gdp_scatter(
-    df,
-    geography="country",
-    figsize=(10, 8),
-    title=None,
-    cmap=CUSTOM_CMAP,
-    filtered_entities=None,
-):
-    """
-    Create log-log scatter plot of GDP vs Anthropic AI Usage Index.
-
-    Args:
-        df: Long format dataframe
-        geography: Geographic level
-        figsize: Figure size
-        title: Chart title
-        cmap: Colormap to use
-        filtered_entities: List of geo_id values that meet MIN_OBSERVATIONS threshold (optional)
-    """
-    # Get usage data
-    df_usage = filter_df(
-        df, geography=geography, facet=geography, variable="usage_per_capita_index"
-    )
-
-    # Apply filtering if provided
-    if filtered_entities is not None:
-        df_usage = df_usage[df_usage["geo_id"].isin(filtered_entities)]
-
-    df_usage = df_usage[["geo_id", "cluster_name", "value"]].rename(
-        columns={"value": "usage_index"}
-    )
-
-    # Get GDP data
-    df_gdp = filter_df(
-        df, geography=geography, facet=geography, variable="gdp_per_working_age_capita"
-    )
-
-    # Apply same filtering to GDP data
-    if filtered_entities is not None:
-        df_gdp = df_gdp[df_gdp["geo_id"].isin(filtered_entities)]
-
-    df_gdp = df_gdp[["geo_id", "value"]].rename(columns={"value": "gdp_per_capita"})
-
-    # Merge
-    df_plot = df_usage.merge(df_gdp, on="geo_id", how="inner")
-
-    # Filter out zeros and negative values for log scale
-    # Explicitly check both GDP and usage are positive (will be true for filtered geos)
-    mask = (df_plot["gdp_per_capita"] > 0) & (df_plot["usage_index"] > 0)
-    df_plot = df_plot[mask]
-
-    # Create figure
-    fig, ax = create_figure(figsize=figsize)
-
-    # Create scatter plot with geo_id values as labels
-    x = df_plot["gdp_per_capita"].values
-    y = df_plot["usage_index"].values
-
-    # Transform to log space for plotting
-    log_x = np.log(x)
-    log_y = np.log(y)
-
-    # Create norm for colorbar (using natural log)
-    norm = plt.Normalize(vmin=log_y.min(), vmax=log_y.max())
-
-    # First, plot invisible points to ensure matplotlib's autoscaling includes all data points
-    ax.scatter(log_x, log_y, s=0, alpha=0)  # Size 0, invisible points for autoscaling
-
-    # Plot the geo_id values as text at the exact data points in log space
-    for ln_x, ln_y, geo_id in zip(log_x, log_y, df_plot["geo_id"].values, strict=True):
-        # Get color from colormap based on ln(usage_index)
-        color_val = norm(ln_y)
-        text_color = cmap(color_val)
-
-        ax.text(
-            ln_x,
-            ln_y,
-            geo_id,
-            fontsize=7,
-            ha="center",
-            va="center",
-            color=text_color,
-            alpha=0.9,
-            weight="bold",
-        )
-
-    # Add constant for intercept
-    X_with_const = sm.add_constant(log_x)
-
-    # Fit OLS regression in log space
-    model = sm.OLS(log_y, X_with_const)
-    results = model.fit()
-
-    # Extract statistics
-    intercept = results.params[0]
-    slope = results.params[1]
-    r_squared = results.rsquared
-    p_value = results.pvalues[1]  # p-value for slope
-
-    # Create fit line (we're already in log space)
-    x_fit = np.linspace(log_x.min(), log_x.max(), 100)
-    y_fit = intercept + slope * x_fit
-    ax.plot(
-        x_fit,
-        y_fit,
-        "gray",
-        linestyle="--",
-        alpha=0.7,
-        linewidth=2,
-        label=f"Power law: AUI ~ GDP^{slope:.2f}",
-    )
-
-    # Add regression statistics
-    # Format p-value display
-    if p_value < 0.001:
-        p_str = "p < 0.001"
-    else:
-        p_str = f"p = {p_value:.3f}"
-
-    ax.text(
-        0.05,
-        0.95,
-        f"$\\beta = {slope:.3f}\\ ({p_str})$\n$R^2 = {r_squared:.3f}$",
-        transform=ax.transAxes,
-        fontsize=10,
-        bbox=dict(boxstyle="round", facecolor="white", alpha=0.8),
-        verticalalignment="top",
-    )
-
-    # Customize labels for log-transformed values
-    xlabel = "ln(GDP per working-age capita in USD)"
-    ylabel = "ln(Anthropic AI Usage Index)"
-    default_title = f"Income and Anthropic AI Usage Index by {'country' if geography == 'country' else 'US state'}"
-
-    format_axis(
-        ax, xlabel=xlabel, ylabel=ylabel, title=title or default_title, grid=False
-    )
-
-    # Grid for log scale
-    ax.grid(True, alpha=0.3, which="both", linestyle="-", linewidth=0.5)
-
-    # Add legend
-    ax.legend(loc="best")
-
-    # Create colorbar using ScalarMappable
-    scalar_mappable = plt.cm.ScalarMappable(cmap=cmap, norm=norm)
-    scalar_mappable.set_array([])
-    cbar = plt.colorbar(scalar_mappable, ax=ax)
-    cbar.set_label(
-        "ln(Anthropic AI Usage Index)", fontsize=9, rotation=270, labelpad=15
-    )
-
-    return fig
-
-
-def plot_request_comparison_cards(
-    df,
-    geo_ids,
-    title,
-    geography,
-    top_n=5,
-    figsize=(10, 6),
-    exclude_not_classified=True,
-    request_level=1,
-    request_threshold=1.0,
-):
-    """
-    Create a condensed card visualization showing top overrepresented request categories
-    for multiple geographies (countries or states).
-
-    Args:
-        df: Long format dataframe
-        geo_ids: List of geography IDs to compare (e.g., ['USA', 'BRA', 'VNM', 'IND'])
-        title: Title for the figure (required)
-        geography: Geographic level ('country' or 'state_us')
-        top_n: Number of top requests to show per geography (default 5)
-        figsize: Figure size as tuple
-        exclude_not_classified: Whether to exclude "not_classified" entries
-        request_level: Request hierarchy level to use (default 1)
-        request_threshold: Minimum percentage threshold for requests (default 1.0%)
-    """
-    # Get data for specified geography
-    data_subset = filter_df(df, facet="request", geo_id=geo_ids, geography=geography)
-
-    # Filter for request_pct_index variable and specified level
-    data_subset = filter_df(
-        data_subset, variable="request_pct_index", level=request_level
-    )
-
-    # Exclude not_classified if requested
-    if exclude_not_classified:
-        data_subset = data_subset[
-            ~data_subset["cluster_name"].str.contains("not_classified", na=False)
-        ]
-
-    # Get tier and geo_name information
-    geo_info = filter_df(
-        df, geography=geography, variable="usage_tier", geo_id=geo_ids
-    )[["geo_id", "geo_name", "value"]].drop_duplicates()
-    tier_map = dict(zip(geo_info["geo_id"], geo_info["value"], strict=True))
-    name_map = dict(zip(geo_info["geo_id"], geo_info["geo_name"], strict=True))
-
-    # Set up figure with 2x2 grid for 4 geographies
-    n_rows, n_cols = 2, 2
-    fig, axes = create_figure(figsize=figsize, nrows=n_rows, ncols=n_cols)
-    axes = axes.flatten()
-
-    # Use global tier colors
-    tier_colors = TIER_COLORS_NUMERIC
-
-    # Process each geography
-    for idx, geo_id in enumerate(geo_ids):
-        ax = axes[idx]
-
-        # Apply request threshold filtering to get valid requests for this geography
-        valid_requests = filter_requests_by_threshold(
-            df, geography, geo_id, level=request_level, threshold=request_threshold
-        )
-
-        # Get data for this geography, filtered by valid requests
-        geo_data = data_subset[
-            (data_subset["geo_id"] == geo_id)
-            & (data_subset["cluster_name"].isin(valid_requests))
-            & (data_subset["value"] > 1.0)  # Only show overrepresented requests
-        ].copy()
-
-        # Get top n from the filtered requests
-        geo_data = geo_data.nlargest(top_n, "value")
-
-        # Get tier color
-        tier = tier_map[geo_id]
-        base_color = tier_colors[tier]
-
-        # Create a lighter version of the tier color for the card background
-        rgb = mcolors.to_rgb(base_color)
-        # Mix with white (85% white, 15% color for very subtle background)
-        pastel_rgb = tuple(0.85 + 0.15 * c for c in rgb)
-        card_bg_color = mcolors.to_hex(pastel_rgb)
-
-        # Fill entire axis with background color
-        ax.set_facecolor(card_bg_color)
-
-        # Create card with requests
-        card_height = 0.9  # Fixed height for all cards
-        card_bottom = 0.965 - card_height  # Consistent positioning
-
-        card_rect = FancyBboxPatch(
-            (0.10, card_bottom),
-            0.80,
-            card_height,
-            transform=ax.transAxes,
-            boxstyle="round,pad=0.02,rounding_size=0.035",
-            facecolor=card_bg_color,
-            edgecolor="none",
-            linewidth=2,
-            clip_on=False,
-        )
-        ax.add_patch(card_rect)
-
-        # Header bar
-        header_top = 0.965 - 0.10
-        header_rect = FancyBboxPatch(
-            (0.14, header_top),
-            0.72,
-            0.08,
-            transform=ax.transAxes,
-            boxstyle="round,pad=0.01,rounding_size=0.03",
-            facecolor=base_color,
-            edgecolor="none",
-            alpha=0.7,
-            clip_on=False,
-        )
-        ax.add_patch(header_rect)
-
-        # Add geography name
-        geo_name = name_map[geo_id]
-
-        ax.text(
-            0.5,
-            header_top + 0.04,
-            geo_name,
-            transform=ax.transAxes,
-            ha="center",
-            va="center",
-            fontsize=12,
-            fontweight="bold",
-            color="#1C1C1C",
-        )
-
-        # Adjust start position below header upwards
-        y_pos = header_top - 0.05
-
-        for _, row in geo_data.iterrows():
-            request = row["cluster_name"]
-            value = row["value"]
-
-            # Format ratio
-            if value >= 10:
-                ratio_str = f"{value:.0f}x"
-            elif value >= 2:
-                ratio_str = f"{value:.1f}x"
-            else:
-                ratio_str = f"{value:.2f}x"
-
-            # Wrap text
-            wrapped_text = textwrap.fill(request, width=46, break_long_words=False)
-            lines = wrapped_text.split("\n")
-
-            # Display text lines with sufficient line spacing
-            line_spacing = 0.045
-            for j, line in enumerate(lines):
-                ax.text(
-                    0.13,  # Adjust text position for wider card
-                    y_pos - j * line_spacing,
-                    line,
-                    transform=ax.transAxes,
-                    ha="left",
-                    va="top",
-                    fontsize=9,
-                    color="#1C1C1C",
-                    rasterized=False,
-                )
-
-            # Position ratio with adjusted margin for wide card
-            text_height = len(lines) * line_spacing
-            ax.text(
-                0.85,
-                y_pos - (text_height - line_spacing) / 2,
-                ratio_str,
-                transform=ax.transAxes,
-                ha="right",
-                va="center",
-                fontsize=10,
-                fontweight="bold",
-                color="#B85450",
-                rasterized=False,
-            )
-
-            # Add space between different requests
-            y_pos -= text_height + 0.05
-
-        # Remove axes
-        ax.axis("off")
-
-    # Add title
-    fig.suptitle(title, fontsize=14, fontweight="bold", y=0.98)
-
-    plt.tight_layout()
-    plt.subplots_adjust(
-        top=0.92, bottom=0.02, left=0.01, right=0.99, hspace=0.02, wspace=0.02
-    )
-
-    return fig
-
-
-def plot_dc_task_request_cards(
-    df,
-    title,
-    figsize=(10, 5),
-):
-    """
-    Create professional card visualizations showing top overrepresented O*NET tasks and requests for Washington, DC.
-
-    Args:
-        df: Long format dataframe
-        figsize: Figure size as tuple
-        title: Optional title for the figure
-    """
-    # Fixed parameters for DC
-    geo_id = "DC"
-    geography = "state_us"
-    top_n = 5
-
-    # Get tier for color
-    tier_data = filter_df(
-        df, geography=geography, variable="usage_tier", geo_id=[geo_id]
-    )
-    tier = tier_data["value"].iloc[0]
-
-    # Use tier color
-    tier_colors = TIER_COLORS_NUMERIC
-    base_color = tier_colors[tier]
-
-    # Create lighter version for card background
-    rgb = mcolors.to_rgb(base_color)
-    pastel_rgb = tuple(0.85 + 0.15 * c for c in rgb)
-    card_bg_color = mcolors.to_hex(pastel_rgb)
-
-    # Create figure with 2 subplots (cards)
-    fig, axes = create_figure(figsize=figsize, ncols=2)
-
-    # Card 1: Top O*NET Tasks
-    ax1 = axes[0]
-    ax1.set_facecolor(card_bg_color)
-
-    # Get O*NET task data
-    df_tasks = filter_df(
-        df,
-        geography=geography,
-        geo_id=[geo_id],
-        facet="onet_task",
-        variable="onet_task_pct_index",
-    )
-
-    # Exclude not_classified and none
-    df_tasks = df_tasks[~df_tasks["cluster_name"].isin(["not_classified", "none"])]
-
-    # Get top n overrepresented tasks
-    df_tasks = df_tasks[df_tasks["value"] > 1.0].nlargest(top_n, "value")
-
-    # Use fixed card heights
-    card_height_tasks = 0.955
-    card_bottom_tasks = 0.965 - card_height_tasks
-
-    # Draw card for O*NET tasks
-    card_rect1 = FancyBboxPatch(
-        (0.10, card_bottom_tasks),
-        0.80,
-        card_height_tasks,
-        transform=ax1.transAxes,
-        boxstyle="round,pad=0.02,rounding_size=0.035",
-        facecolor=card_bg_color,
-        edgecolor="none",
-        linewidth=2,
-        clip_on=False,
-    )
-    ax1.add_patch(card_rect1)
-
-    # Header for O*NET tasks
-    header_top = 0.965 - 0.10
-    header_rect1 = FancyBboxPatch(
-        (0.12, header_top),
-        0.76,
-        0.08,
-        transform=ax1.transAxes,
-        boxstyle="round,pad=0.01,rounding_size=0.03",
-        facecolor=base_color,
-        edgecolor="none",
-        alpha=0.7,
-        clip_on=False,
-    )
-    ax1.add_patch(header_rect1)
-
-    ax1.text(
-        0.5,
-        header_top + 0.04,
-        "Top 5 overrepresented O*NET tasks in DC",
-        transform=ax1.transAxes,
-        ha="center",
-        va="center",
-        fontsize=11,
-        fontweight="bold",
-        color="#1C1C1C",
-    )
-
-    # Add task items
-    y_pos = header_top - 0.05
-
-    for _, row in df_tasks.iterrows():
-        task = row["cluster_name"]
-        value = row["value"]
-
-        # Convert to sentence case and remove trailing period
-        task = task[0].upper() + task[1:].lower() if task else task
-        task = task.rstrip(".")  # Remove trailing period
-
-        # Format ratio - always with 2 decimal places
-        ratio_str = f"{value:.2f}x"
-
-        # Wrap text
-        wrapped_text = textwrap.fill(task, width=46, break_long_words=False)
-        lines = wrapped_text.split("\n")
-
-        # Display text lines
-        line_spacing = 0.045
-        for j, line in enumerate(lines):
-            ax1.text(
-                0.13,
-                y_pos - j * line_spacing,
-                line,
-                transform=ax1.transAxes,
-                ha="left",
-                va="top",
-                fontsize=9,
-                color="#1C1C1C",
-                rasterized=False,
-            )
-
-        # Add ratio at the right with consistent color
-        ax1.text(
-            0.87,
-            y_pos - (len(lines) - 1) * line_spacing / 2,
-            ratio_str,
-            transform=ax1.transAxes,
-            ha="right",
-            va="center",
-            fontsize=10,
-            color="#B85450",
-            fontweight="bold",
-        )
-
-        # Move to next item position
-        y_pos -= len(lines) * line_spacing + 0.025
-
-    ax1.axis("off")
-
-    # Card 2: Top Requests
-    ax2 = axes[1]
-    ax2.set_facecolor(card_bg_color)
-
-    # Get valid requests using threshold
-    valid_requests = filter_requests_by_threshold(
-        df, geography, geo_id, level=1, threshold=1.0
-    )
-
-    # Get request data
-    df_requests = filter_df(
-        df,
-        geography=geography,
-        geo_id=[geo_id],
-        facet="request",
-        variable="request_pct_index",
-        level=1,
-    )
-
-    # Filter by valid requests and overrepresented
-    df_requests = df_requests[
-        (df_requests["cluster_name"].isin(valid_requests))
-        & (df_requests["value"] > 1.0)
-        & (~df_requests["cluster_name"].str.contains("not_classified", na=False))
-    ]
-
-    # Get top n
-    df_requests = df_requests.nlargest(top_n, "value")
-
-    # Draw card for requests with fixed height
-    card_height_requests = 0.72
-    card_bottom_requests = 0.965 - card_height_requests
-
-    card_rect2 = FancyBboxPatch(
-        (0.10, card_bottom_requests),
-        0.80,
-        card_height_requests,
-        transform=ax2.transAxes,
-        boxstyle="round,pad=0.02,rounding_size=0.035",
-        facecolor=card_bg_color,
-        edgecolor="none",
-        linewidth=2,
-        clip_on=False,
-    )
-    ax2.add_patch(card_rect2)
-
-    # Header for requests
-    header_rect2 = FancyBboxPatch(
-        (0.12, header_top),
-        0.76,
-        0.08,
-        transform=ax2.transAxes,
-        boxstyle="round,pad=0.01,rounding_size=0.03",
-        facecolor=base_color,
-        edgecolor="none",
-        alpha=0.7,
-        clip_on=False,
-    )
-    ax2.add_patch(header_rect2)
-
-    ax2.text(
-        0.5,
-        header_top + 0.04,
-        "Top 5 overrepresented request clusters in DC",
-        transform=ax2.transAxes,
-        ha="center",
-        va="center",
-        fontsize=11,
-        fontweight="bold",
-        color="#1C1C1C",
-    )
-
-    # Add request items
-    y_pos = header_top - 0.05
-
-    for _, row in df_requests.iterrows():
-        request = row["cluster_name"]
-        value = row["value"]
-
-        # Format ratio always with 2 decimal places
-        ratio_str = f"{value:.2f}x"
-
-        # Wrap text
-        wrapped_text = textwrap.fill(request, width=46, break_long_words=False)
-        lines = wrapped_text.split("\n")
-
-        # Display text lines
-        line_spacing = 0.045
-        for j, line in enumerate(lines):
-            ax2.text(
-                0.13,
-                y_pos - j * line_spacing,
-                line,
-                transform=ax2.transAxes,
-                ha="left",
-                va="top",
-                fontsize=9,
-                color="#1C1C1C",
-                rasterized=False,
-            )
-
-        # Add ratio at the right with consistent color
-        ax2.text(
-            0.87,
-            y_pos - (len(lines) - 1) * line_spacing / 2,
-            ratio_str,
-            transform=ax2.transAxes,
-            ha="right",
-            va="center",
-            fontsize=10,
-            color="#B85450",
-            fontweight="bold",
-        )
-
-        # Move to next item position
-        y_pos -= len(lines) * line_spacing + 0.025
-
-    ax2.axis("off")
-
-    # Add subtle title if provided
-    fig.suptitle(title, fontsize=13, fontweight="bold", y=0.98)
-
-    plt.tight_layout()
-    return fig
-
-
-# Summary statistics function
-def plot_tier_summary_table(df, geography="country", figsize=(12, 6)):
-    """
-    Create a visual table showing entities per tier and example members.
-
-    Args:
-        df: Long format dataframe
-        geography: 'country' or 'state_us'
-        figsize: Figure size
-    """
-    # Get tier data
-    df_tier = filter_df(df, geography=geography, variable="usage_tier")
-
-    # Exclude US territories that appear as countries (may be confusing to readers)
-    if geography == "country":
-        us_territories_as_countries = [
-            "PRI",
-            "VIR",
-            "GUM",
-            "ASM",
-            "MNP",
-        ]  # Puerto Rico, Virgin Islands, Guam, American Samoa, Northern Mariana Islands
-        df_tier = df_tier[~df_tier["geo_id"].isin(us_territories_as_countries)]
-
-    # Get usage per capita index for sorting entities within tiers
-    df_usage_index = filter_df(
-        df, geography=geography, variable="usage_per_capita_index"
-    )
-
-    # Apply same territory filter to usage index data
-    if geography == "country":
-        df_usage_index = df_usage_index[
-            ~df_usage_index["geo_id"].isin(us_territories_as_countries)
-        ]
-
-    # Merge tier with usage index
-    df_tier_full = df_tier[["geo_id", "geo_name", "cluster_name"]].merge(
-        df_usage_index[["geo_id", "value"]],
-        on="geo_id",
-        how="left",
-        suffixes=("", "_index"),
-    )
-
-    # Use global tier colors
-    tier_colors = TIER_COLORS_DICT
-
-    # Calculate appropriate figure height based on number of tiers
-    n_tiers = sum(
-        1 for tier in TIER_ORDER if tier in df_tier_full["cluster_name"].values
-    )
-    # Adjust height: minimal padding for compact display
-    fig_height = 0.5 + n_tiers * 0.3  # Much more compact
-
-    # Create figure with calculated size
-    fig, ax = create_figure(figsize=(figsize[0], fig_height))
-    ax.axis("tight")
-    ax.axis("off")
-
-    # Make background transparent
-    fig.patch.set_alpha(0.0)
-    ax.patch.set_alpha(0.0)
-
-    # Prepare table data
-    table_data = []
-    entity_type = "countries" if geography == "country" else "states"
-    col_labels = [
-        "Tier",
-        "AUI range",
-        f"# of {entity_type}",
-        f"Example {entity_type}",
-    ]
-
-    for tier in TIER_ORDER:
-        if tier in df_tier_full["cluster_name"].values:
-            # Get entities in this tier
-            tier_entities = filter_df(df_tier_full, cluster_name=tier)
-            count = len(tier_entities)
-
-            # Calculate usage index range for this tier
-            min_index = tier_entities["value"].min()
-            max_index = tier_entities["value"].max()
-            index_range = f"{min_index:.2f} - {max_index:.2f}"
-
-            # For Minimal tier where all have 0 index, pick shortest names
-            if tier == "Minimal" and tier_entities["value"].max() == 0:
-                tier_entities = tier_entities.copy()
-                tier_entities["name_length"] = tier_entities["geo_name"].str.len()
-                top_entities = tier_entities.nsmallest(5, "name_length")[
-                    "geo_name"
-                ].tolist()
-            else:
-                # Get top 5 entities by usage index in this tier
-                top_entities = tier_entities.nlargest(5, "value")["geo_name"].tolist()
-
-            # Format the example entities as a comma-separated string
-            examples = ", ".join(top_entities[:5])
-
-            table_data.append([tier, index_range, str(count), examples])
-
-    # Create table with better column widths
-    table = ax.table(
-        cellText=table_data,
-        colLabels=col_labels,
-        cellLoc="left",
-        loc="center",
-        colWidths=[0.20, 0.18, 0.12, 0.50],
-        colColours=[ANTHROPIC_OAT] * 4,
-    )
-
-    # Style the table
-    table.auto_set_font_size(False)
-    table.set_fontsize(11)
-    table.scale(1, 2.2)
-
-    # Set all cell edges to Anthropic oat color
-    for _, cell in table.get_celld().items():
-        cell.set_edgecolor(ANTHROPIC_OAT)
-        cell.set_linewidth(1.5)
-
-    # Color code the rows with consistent black text
-    for i, row_data in enumerate(table_data):
-        tier_name = row_data[0]
-        if tier_name in tier_colors:
-            # Color the tier name cell with full opacity
-            table[(i + 1, 0)].set_facecolor(tier_colors[tier_name])
-            table[(i + 1, 0)].set_text_props(color="black", weight="bold")
-
-            # Light background for usage index range column
-            table[(i + 1, 1)].set_facecolor(tier_colors[tier_name])
-            table[(i + 1, 1)].set_alpha(0.3)
-            table[(i + 1, 1)].set_text_props(ha="center", color="black")
-
-            # Light background for count column
-            table[(i + 1, 2)].set_facecolor(tier_colors[tier_name])
-            table[(i + 1, 2)].set_alpha(0.2)
-            table[(i + 1, 2)].set_text_props(ha="center", color="black")
-
-            # Even lighter background for examples column
-            table[(i + 1, 3)].set_facecolor(tier_colors[tier_name])
-            table[(i + 1, 3)].set_alpha(0.1)
-            table[(i + 1, 3)].set_text_props(color="black")
-
-    # Style header row with Anthropic oat and black text
-    for j in range(4):
-        table[(0, j)].set_facecolor(ANTHROPIC_OAT)
-        table[(0, j)].set_text_props(color="black", weight="bold")
-
-    # Center the count column
-    for i in range(len(table_data)):
-        table[(i + 1, 1)].set_text_props(ha="center")
-
-    return fig
-
-
-def plot_tier_map(
-    df,
-    title,
-    geography,
-    figsize=(16, 10),
-    show_labels=True,
-):
-    """
-    Create a map showing per Anthropic AI Usage Tiers.
-
-    Args:
-        df: Long format dataframe with usage_tier variable
-        geography: 'country' or 'state_us'
-        figsize: Figure size
-        title: Map title
-        show_labels: whether to show title and legend (False for clean export)
-    """
-    # Filter for tier data
-    df_tier = filter_df(df, geography=geography, variable="usage_tier").copy()
-
-    # Use global tier colors definition
-    tier_colors = TIER_COLORS_DICT
-
-    # Map tiers to colors
-    df_tier["color"] = df_tier["cluster_name"].map(tier_colors)
-
-    # Set up figure
-    # Create figure with tight_layout disabled
-    fig, ax = create_figure(figsize=figsize, tight_layout=False)
-
-    if geography == "country":
-        # Load world shapefile function
-        world = load_world_shapefile()
-
-        # Merge with world data using geo_id (which contains ISO-3 codes)
-        # Use ISO_A3_EH for merging as it's complete (ISO_A3 has -99 for France)
-        world = merge_geo_data(
-            world,
-            df_tier,
-            "ISO_A3_EH",
-            ["geo_id", "color", "cluster_name"],
-            is_tier=True,
-        )
-
-        # Plot world map
-        plot_world_map(ax, world, data_column="cluster_name", tier_colors=tier_colors)
-
-    else:  # state_us
-        # Load US states shapefile function
-        states = load_us_states_shapefile()
-
-        # Merge with tier data BEFORE projection
-        states = merge_geo_data(
-            states, df_tier, "STUSPS", ["geo_id", "color", "cluster_name"], is_tier=True
-        )
-
-        # Pot states with insets
-        plot_us_states_map(
-            fig, ax, states, data_column="cluster_name", tier_colors=tier_colors
-        )
-
-    # Remove axes
-    ax.set_axis_off()
-
-    # Add title only if show_labels=True
-    if show_labels:
-        format_axis(ax, title=title, title_size=14, grid=False)
-
-    # Check which tiers actually appear in the data
-    tiers_in_data = df_tier["cluster_name"].unique()
-
-    # Add legend only if show_labels=True
-    if show_labels:
-        # Check for excluded countries and no data
-        excluded = False
-        no_data = False
-        if geography == "country":
-            if "world" in locals() and "is_excluded" in world.columns:
-                excluded = world["is_excluded"].any()
-            if "world" in locals():
-                no_data = world["cluster_name"].isna().any()
-        else:  # state_us
-            if "states" in locals():
-                no_data = states["cluster_name"].isna().any()
-
-        create_tier_legend(
-            ax, tier_colors, tiers_in_data, excluded_countries=excluded, no_data=no_data
-        )
-
-    return fig
-
-
-def plot_variable_map(
-    df,
-    variable,
-    geography="country",
-    figsize=(16, 10),
-    title=None,
-    cmap=CUSTOM_CMAP,
-    center_at_one=None,
-):
-    """
-    Create static map for any variable.
-
-    Args:
-        df: Long format dataframe
-        variable: Variable to plot (e.g., 'usage_pct')
-        geography: 'country' or 'state_us'
-        figsize: Figure size (width, height) in inches
-        title: Map title
-        cmap: Matplotlib colormap or name (default uses custom colormap)
-        center_at_one: Whether to center the color scale at 1.0 (default True for usage_per_capita_index)
-    """
-    # Get data for the specified variable
-    df_data = filter_df(df, geography=geography, facet=geography, variable=variable)
-
-    # Create figure
-    fig = plt.figure(figsize=figsize, dpi=150)
-    fig.set_layout_engine(layout="none")  # Disable layout engine for custom axes
-    ax = fig.add_subplot(111)
-
-    if geography == "country":
-        # Load world shapefile function (automatically marks excluded countries)
-        world = load_world_shapefile()
-
-        # Merge using geo_id (which contains ISO-3 codes)
-        world = merge_geo_data(
-            world, df_data, "ISO_A3_EH", ["geo_id", "value"], is_tier=False
-        )
-
-        # Prepare data and normalization
-        plot_column, norm = prepare_map_data(
-            world, "value", center_at_one, world["is_excluded"]
-        )
-
-        # Plot world map
-        plot_world_map(ax, world, data_column=plot_column, cmap=cmap, norm=norm)
-
-    else:  # state_us
-        # Load US states shapefile function
-        states = load_us_states_shapefile()
-
-        # Merge our data with the states shapefile
-        states = merge_geo_data(
-            states, df_data, "STUSPS", ["geo_id", "value"], is_tier=False
-        )
-
-        # Prepare data and normalization
-        plot_column, norm = prepare_map_data(states, "value", center_at_one)
-
-        # Plot states with insets
-        plot_us_states_map(
-            fig, ax, states, data_column=plot_column, cmap=cmap, norm=norm
-        )
-
-    # Remove axes
-    ax.set_axis_off()
-
-    # Add colorbar with proper size and positioning
-    divider = make_axes_locatable(ax)
-    cax = divider.append_axes("right", size="3%", pad=0.1)
-
-    # Create colorbar
-    scalar_mappable = plt.cm.ScalarMappable(cmap=cmap, norm=norm)
-    scalar_mappable.set_array([])
-    cbar = plt.colorbar(scalar_mappable, cax=cax)
-
-    # Set colorbar label based on variable
-    if variable == "usage_pct":
-        cbar.set_label("Usage share (%)", fontsize=10, rotation=270, labelpad=15)
-    elif variable == "usage_per_capita_index":
-        cbar.set_label(
-            "Anthropic AI Usage Index", fontsize=10, rotation=270, labelpad=15
-        )
-    else:
-        cbar.set_label(variable, fontsize=10, rotation=270, labelpad=15)
-
-    # Set title
-    if variable == "usage_pct":
-        default_title = "Share of Claude usage by " + (
-            "country" if geography == "country" else "US state"
-        )
-    else:
-        default_title = f"{variable} by " + (
-            "country" if geography == "country" else "US state"
-        )
-
-    format_axis(ax, title=title or default_title, title_size=14, grid=False)
-
-    # Add legend for excluded countries and no data
-    legend_elements = []
-
-    # Check if we have excluded countries or no data regions
-    if geography == "country":
-        # Check for excluded countries (world['is_excluded'] == True)
-        if "is_excluded" in world.columns:
-            excluded_countries = world[world["is_excluded"] == True]
-            if not excluded_countries.empty:
-                legend_elements.append(
-                    Patch(
-                        facecolor="#c0c0c0",
-                        edgecolor="white",
-                        label="Claude not available",
-                    )
-                )
-
-            # Check for countries with no data
-            no_data_countries = world[
-                (world["value"].isna()) & (world["is_excluded"] != True)
-            ]
-            if not no_data_countries.empty:
-                legend_elements.append(
-                    Patch(facecolor="#f0f0f0", edgecolor="white", label="No data")
-                )
-
-    if legend_elements:
-        ax.legend(
-            handles=legend_elements,
-            loc="lower left",
-            fontsize=9,
-            frameon=True,
-            fancybox=True,
-            shadow=True,
-            bbox_to_anchor=(0, 0),
-        )
-
-    return fig
-
-
-def plot_soc_usage_scatter(
-    df,
-    geography,
-    filtered_entities=None,
-):
-    """
-    Create faceted scatterplot of SOC percentages vs Anthropic AI Usage Index.
-    Always creates a 2x2 grid of square subplots showing the top 4 SOC groups.
-
-    Args:
-        df: Long format dataframe with enriched data
-        geography: 'country' or 'state_us'
-        filtered_entities: List of geo_id values that meet MIN_OBSERVATIONS threshold
-    """
-    # Fixed configuration for 2x2 grid
-    n_cols = 2
-    n_rows = 2
-    n_top_groups = 4
-
-    # Apply MIN_OBSERVATIONS filtering if not provided
-    if filtered_entities is None:
-        filtered_countries, filtered_states = get_filtered_geographies(df)
-        filtered_entities = (
-            filtered_countries if geography == "country" else filtered_states
-        )
-
-    # Get Anthropic AI Usage Index data
-    df_usage_index = filter_df(
-        df,
-        geography=geography,
-        variable="usage_per_capita_index",
-        geo_id=filtered_entities,
-    )[["geo_id", "value"]].rename(columns={"value": "ai_usage_index"})
-
-    # Get usage counts for bubble sizes
-    df_usage = filter_df(
-        df, geography=geography, variable="usage_count", geo_id=filtered_entities
-    )[["geo_id", "value"]].rename(columns={"value": "usage_count"})
-
-    # Get tier data for colors
-    df_tier = filter_df(
-        df, geography=geography, variable="usage_tier", geo_id=filtered_entities
-    )[["geo_id", "cluster_name", "value"]].rename(
-        columns={"cluster_name": "tier_name", "value": "tier_value"}
-    )
-
-    # Get SOC percentages
-    df_soc = filter_df(
-        df,
-        geography=geography,
-        facet="soc_occupation",
-        variable="soc_pct",
-        geo_id=filtered_entities,
-    )[["geo_id", "cluster_name", "value"]].rename(
-        columns={"cluster_name": "soc_group", "value": "soc_pct"}
-    )
-
-    # Merge all data
-    df_plot = df_soc.merge(
-        df_usage_index, on="geo_id", how="inner"
-    )  # inner join because some geographies don't have data for all SOC groups
-    df_plot = df_plot.merge(df_usage, on="geo_id", how="left")
-    df_plot = df_plot.merge(
-        df_tier[["geo_id", "tier_name", "tier_value"]], on="geo_id", how="left"
-    )
-
-    # Use parent geography reference for consistent SOC selection
-    if geography == "country":
-        # Use global reference for countries
-        reference_soc = filter_df(
-            df,
-            geography="global",
-            geo_id="GLOBAL",
-            facet="soc_occupation",
-            variable="soc_pct",
-        )
-    else:  # state_us
-        # Use US reference for states
-        reference_soc = filter_df(
-            df,
-            geography="country",
-            geo_id="USA",
-            facet="soc_occupation",
-            variable="soc_pct",
-        )
-
-    # Get top SOC groups from reference (excluding not_classified)
-    reference_filtered = reference_soc[
-        ~reference_soc["cluster_name"].str.contains("not_classified", na=False)
-    ]
-    plot_soc_groups = reference_filtered.nlargest(n_top_groups, "value")[
-        "cluster_name"
-    ].tolist()
-
-    # Filter to selected SOC groups
-    df_plot = df_plot[df_plot["soc_group"].isin(plot_soc_groups)]
-
-    tier_colors = TIER_COLORS_DICT
-
-    # Fixed square subplot size for 2x2 grid
-    subplot_size = 6  # Each subplot is 6x6 inches
-    figsize = (subplot_size * n_cols, subplot_size * n_rows)
-
-    # Create figure
-    fig, axes = create_figure(figsize=figsize, nrows=n_rows, ncols=n_cols)
-    fig.suptitle(
-        "Occupation group shares vs Anthropic AI Usage Index",
-        fontsize=16,
-        fontweight="bold",
-        y=0.98,
-    )
-
-    # Flatten axes for easier iteration (always 2x2 grid)
-    axes_flat = axes.flatten()
-
-    # Plot each SOC group
-    for idx, soc_group in enumerate(plot_soc_groups):
-        ax = axes_flat[idx]
-
-        # Get data for this SOC group
-        soc_data = filter_df(df_plot, soc_group=soc_group)
-
-        # Create scatter plot for each tier
-        for tier_name in tier_colors.keys():
-            tier_data = filter_df(soc_data, tier_name=tier_name)
-
-            # Scale bubble sizes using sqrt for better visibility
-            sizes = np.sqrt(tier_data["usage_count"]) * 2
-
-            ax.scatter(
-                tier_data["ai_usage_index"],
-                tier_data["soc_pct"],
-                s=sizes,
-                c=tier_colors[tier_name],
-                alpha=0.6,
-                edgecolors="black",
-                linewidth=0.5,
-                label=tier_name,
-            )
-
-        # Add trend line and regression statistics
-        X = sm.add_constant(soc_data["ai_usage_index"].values)
-        y = soc_data["soc_pct"].values
-
-        model = sm.OLS(y, X)
-        results = model.fit()
-
-        intercept = results.params[0]
-        slope = results.params[1]
-        r_squared = results.rsquared
-        p_value = results.pvalues[1]  # p-value for slope
-
-        # Plot trend line
-        x_line = np.linspace(
-            soc_data["ai_usage_index"].min(), soc_data["ai_usage_index"].max(), 100
-        )
-        y_line = intercept + slope * x_line
-        ax.plot(x_line, y_line, "--", color="gray", alpha=0.5, linewidth=1)
-
-        # Format p-value display
-        if p_value < 0.001:
-            p_str = "p < 0.001"
-        else:
-            p_str = f"p = {p_value:.3f}"
-
-        # Add regression statistics
-        ax.text(
-            0.95,
-            0.95,
-            f"$\\beta = {slope:.3f}\\ ({p_str})$\n$R^2 = {r_squared:.3f}$",
-            transform=ax.transAxes,
-            ha="right",
-            va="top",
-            fontsize=9,
-            bbox=dict(boxstyle="round", facecolor="white", alpha=0.8),
-        )
-
-        # Format axes
-        format_axis(
-            ax,
-            xlabel="Anthropic AI Usage Index (usage % / working-age population %)",
-            ylabel="Occupation group share (%)",
-            title=soc_group,
-            xlabel_size=10,
-            ylabel_size=10,
-            grid=False,
-        )
-        ax.grid(True, alpha=0.3)
-
-    # Add legend
-    handles, labels = axes_flat[0].get_legend_handles_labels()
-    if handles:
-        # Create new handles with consistent size for legend only
-        # This doesn't modify the actual plot markers
-        legend_handles = []
-        for handle in handles:
-            # Get the color from the original handle
-            color = (
-                handle.get_facecolor()[0]
-                if hasattr(handle, "get_facecolor")
-                else "gray"
-            )
-            # Create a Line2D object with circle marker for legend
-            new_handle = Line2D(
-                [0],
-                [0],
-                marker="o",
-                color="w",
-                markerfacecolor=color,
-                markersize=8,
-                markeredgecolor="black",
-                markeredgewidth=0.5,
-                alpha=0.6,
-            )
-            legend_handles.append(new_handle)
-
-        # Position tier legend centered under the left column with vertical layout
-        fig.legend(
-            legend_handles,
-            labels,
-            title="Anthropic AI Usage Index tier",
-            loc="upper center",
-            bbox_to_anchor=(0.25, -0.03),
-            frameon=True,
-            fancybox=True,
-            shadow=True,
-            ncol=2,
-            borderpad=0.6,
-        )
-
-    # Add size legend using actual scatter points for perfect matching
-    reference_counts = [100, 1000, 10000]
-
-    # Create invisible scatter points with the exact same size formula as the plot
-    size_legend_elements = []
-    for count in reference_counts:
-        # Use exact same formula as in the plot
-        size = np.sqrt(count) * 2
-        # Create scatter on first axis (will be invisible) just for legend
-        scatter = axes_flat[0].scatter(
-            [],
-            [],  # Empty data
-            s=size,
-            c="gray",
-            alpha=0.6,
-            edgecolors="black",
-            linewidth=0.5,
-            label=f"{count:,}",
-        )
-        size_legend_elements.append(scatter)
-
-    # Add size legend centered under the right column with vertical layout
-    fig.legend(
-        handles=size_legend_elements,
-        title="Claude usage count",
-        loc="upper center",
-        bbox_to_anchor=(0.75, -0.03),
-        frameon=True,
-        fancybox=True,
-        shadow=True,
-        ncol=1,
-        borderpad=0.6,
-    )
-
-    plt.tight_layout(rect=[0, -0.03, 1, 0.98])
-    return fig
-
-
-def collaboration_task_regression(df, geography="country"):
-    """
-    Analyze automation vs augmentation patterns controlling for task mix for
-    geographies that meet the minimum observation threshold.
-
-    Uses global task weights to calculate expected automation for each geography,
-    then compares actual vs expected automation.
-
-    Note: Includes "none" tasks in calculations since they have automation/augmentation
-    patterns in the data. Excludes "not_classified" tasks which lack collaboration data.
-
-    Args:
-        df: Input dataframe
-        geography: "country" or "state_us"
-    """
-    # Filter to geographies that meet min observation threshold
-    filtered_countries, filtered_states = get_filtered_geographies(df)
-    filtered_geos = filtered_countries if geography == "country" else filtered_states
-
-    # Get collaboration automation data
-    df_automation = filter_df(
-        df,
-        facet="collaboration_automation_augmentation",
-        geography=geography,
-        variable="automation_pct",
-        geo_id=filtered_geos,
-    )[["geo_id", "value"]].rename(columns={"value": "automation_pct"})
-
-    # Get Anthropic AI Usage Index data
-    df_usage = filter_df(
-        df,
-        geography=geography,
-        facet=geography,
-        variable="usage_per_capita_index",
-        geo_id=filtered_geos,
-    )[["geo_id", "geo_name", "value"]].copy()
-    df_usage.rename(columns={"value": "usage_per_capita_index"}, inplace=True)
-
-    # Get geography-specific task weights (percentages)
-    df_geo_tasks = filter_df(
-        df,
-        facet="onet_task",
-        geography=geography,
-        variable="onet_task_pct",
-        geo_id=filtered_geos,
-    ).copy()
-
-    # Exclude not_classified and none tasks
-    df_geo_tasks = df_geo_tasks[
-        ~df_geo_tasks["cluster_name"].isin(["not_classified", "none"])
-    ]
-
-    # Get global task-specific collaboration patterns (only available at global level)
-    df_task_collab = filter_df(
-        df,
-        facet="onet_task::collaboration",
-        geography="global",
-        geo_id="GLOBAL",
-        variable="onet_task_collaboration_pct",
-    ).copy()
-
-    # Parse task name and collaboration type from cluster_name
-    df_task_collab["task_name"] = df_task_collab["cluster_name"].str.split("::").str[0]
-    df_task_collab["collab_type"] = (
-        df_task_collab["cluster_name"].str.split("::").str[1]
-    )
-
-    # Map collaboration types to automation/augmentation
-    # Automation: directive, feedback loop
-    # Augmentation: validation, task iteration, learning
-    # Excluded: none, not_classified
-    def is_automation(collab_type):
-        if collab_type in ["directive", "feedback loop"]:
-            return True
-        elif collab_type in [
-            "validation",
-            "task iteration",
-            "learning",
-        ]:
-            return False
-        else:  # none, not_classified
-            return None
-
-    df_task_collab["is_automation"] = df_task_collab["collab_type"].apply(is_automation)
-
-    # Exclude not_classified tasks upfront
-    df_task_collab_valid = df_task_collab[
-        df_task_collab["task_name"] != "not_classified"
-    ]
-
-    # Calculate automation percentage for each task
-    task_automation_rates = {}
-    for task_name in df_task_collab_valid["task_name"].unique():
-        task_data = df_task_collab_valid[
-            (df_task_collab_valid["task_name"] == task_name)
-            & (df_task_collab_valid["is_automation"].notna())
-        ]
-
-        # Skip tasks that only have "not_classified" collaboration types
-        if task_data.empty or task_data["value"].sum() == 0:
-            continue
-
-        automation_sum = task_data[task_data["is_automation"]]["value"].sum()
-        total_sum = task_data["value"].sum()
-        task_automation_rates[task_name] = (automation_sum / total_sum) * 100
-
-    # Calculate expected automation for each country using its own task weights
-    expected_automation = []
-    geo_ids = []
-
-    for geo_id in filtered_geos:
-        # Get this geography's task distribution (excluding not_classified)
-        geo_tasks = df_geo_tasks[
-            (df_geo_tasks["geo_id"] == geo_id)
-            & (df_geo_tasks["cluster_name"] != "not_classified")
-        ]
-
-        # Skip geographies with no task data
-        if geo_tasks.empty:
-            continue
-
-        # Calculate weighted automation using geography's task weights
-        weighted_auto = 0.0
-        total_weight = 0.0
-
-        for _, row in geo_tasks.iterrows():
-            task = row["cluster_name"]
-            weight = row["value"]  # Already in percentage
-
-            # Get automation rate for this task (from global data)
-            if task in task_automation_rates:
-                auto_rate = task_automation_rates[task]
-                weighted_auto += weight * auto_rate
-                total_weight += weight
-
-        # Calculate expected automation
-        expected_auto = weighted_auto / total_weight
-        expected_automation.append(expected_auto)
-        geo_ids.append(geo_id)
-
-    # Create dataframe with expected automation
-    df_expected = pd.DataFrame(
-        {"geo_id": geo_ids, "expected_automation_pct": expected_automation}
-    )
-
-    # Merge all data
-    df_regression = df_automation.merge(df_expected, on="geo_id", how="inner")
-    df_regression = df_regression.merge(df_usage, on="geo_id", how="inner")
-
-    # Count unique tasks for reporting
-    n_tasks = len(task_automation_rates)
-
-    # Calculate residuals from regressions for proper partial correlation
-    # For automation, regress actual on expected to get residuals
-    X_expected = sm.add_constant(df_regression["expected_automation_pct"])
-    model_automation = sm.OLS(df_regression["automation_pct"], X_expected)
-    results_automation = model_automation.fit()
-    df_regression["automation_residuals"] = results_automation.resid
-
-    # For usage, regress on expected automation to get residuals
-    model_usage = sm.OLS(df_regression["usage_per_capita_index"], X_expected)
-    results_usage = model_usage.fit()
-    df_regression["usage_residuals"] = results_usage.resid
-
-    # Partial regression is regression of residuals
-    # We want usage (X) to explain automation (Y)
-    X_partial = sm.add_constant(df_regression["usage_residuals"])
-    model_partial = sm.OLS(df_regression["automation_residuals"], X_partial)
-    results_partial = model_partial.fit()
-    partial_slope = results_partial.params.iloc[1]
-    partial_r2 = results_partial.rsquared
-    partial_p = results_partial.pvalues.iloc[1]
-
-    # Create visualization - only show partial correlation
-    fig, ax = create_figure(figsize=(10, 8))
-
-    # Define colormap for automation residuals
-    colors_automation = [AUGMENTATION_COLOR, AUTOMATION_COLOR]
-    cmap_automation = LinearSegmentedColormap.from_list(
-        "automation", colors_automation, N=100
-    )
-
-    # Plot partial correlation
-    # Create colormap normalization for automation residuals
-    norm = plt.Normalize(
-        vmin=df_regression["automation_residuals"].min(),
-        vmax=df_regression["automation_residuals"].max(),
-    )
-
-    # Plot invisible points to ensure matplotlib's autoscaling includes all data points
-    ax.scatter(
-        df_regression["usage_residuals"],
-        df_regression["automation_residuals"],
-        s=0,  # invisible points for autoscaling
-        alpha=0,
-    )
-
-    # Plot country geo_id values as text instead of scatter points
-    for _, row in df_regression.iterrows():
-        color_val = norm(row["automation_residuals"])
-        text_color = cmap_automation(color_val)
-
-        ax.text(
-            row["usage_residuals"],
-            row["automation_residuals"],
-            row["geo_id"],
-            fontsize=7,
-            ha="center",
-            va="center",
-            color=text_color,
-            alpha=0.9,
-            weight="bold",
-        )
-
-    # Create a ScalarMappable for the colorbar
-    scalar_mappable = plt.cm.ScalarMappable(cmap=cmap_automation, norm=norm)
-    scalar_mappable.set_array([])
-
-    # Add regression line using actual regression results
-    # OLS model: automation_residuals = intercept + slope * usage_residuals
-    x_resid_line = np.linspace(
-        df_regression["usage_residuals"].min(),
-        df_regression["usage_residuals"].max(),
-        100,
-    )
-    intercept = results_partial.params.iloc[0]
-    y_resid_line = intercept + partial_slope * x_resid_line
-    ax.plot(
-        x_resid_line,
-        y_resid_line,
-        "grey",
-        linestyle="--",
-        linewidth=2,
-        alpha=0.7,
-    )
-
-    # Set axis labels and title
-    format_axis(
-        ax,
-        xlabel="Anthropic AI Usage Index residuals\n(per capita usage not explained by task mix)",
-        ylabel="Automation % residuals\n(automation not explained by task mix)",
-        title="Relationship between Anthropic AI Usage Index and automation",
-        grid=False,
-    )
-
-    # Add correlation info inside the plot
-    if partial_p < 0.001:
-        p_str = "p < 0.001"
-    else:
-        p_str = f"p = {partial_p:.3f}"
-
-    ax.text(
-        0.08,
-        0.975,
-        f"Partial regression (controlling for task mix): $\\beta = {partial_slope:.3f}, R^2 = {partial_r2:.3f}\\ ({p_str})$",
-        transform=ax.transAxes,
-        fontsize=10,
-        bbox=dict(boxstyle="round", facecolor="white", alpha=0.8),
-        verticalalignment="top",
-    )
-
-    ax.axhline(y=0, color="gray", linestyle=":", linewidth=1, alpha=0.3)
-    ax.axvline(x=0, color="gray", linestyle=":", linewidth=1, alpha=0.3)
-    ax.grid(True, alpha=0.3, linestyle="--")
-
-    # Add colorbar
-    fig.subplots_adjust(right=0.92)
-    cbar_ax = fig.add_axes([0.94, 0.2, 0.02, 0.6])
-    cbar = plt.colorbar(scalar_mappable, cax=cbar_ax)
-    cbar.set_label("Automation % residuals", fontsize=10, rotation=270, labelpad=15)
-
-    # Adjust plot to make room for titles and ensure all data is visible
-    plt.subplots_adjust(top=0.92, right=0.92, left=0.12, bottom=0.12)
-
-    # Return results
-    return {
-        "figure": fig,
-        "partial_slope": partial_slope,
-        "partial_r2": partial_r2,
-        "partial_pvalue": partial_p,
-        "n_countries": len(df_regression),
-        "n_tasks": n_tasks,
-        "df_residuals": df_regression,
-    }
-
-
-def plot_automation_preference_residuals(df, geography="country", figsize=(14, 12)):
-    """Plot automation vs augmentation preference after controlling for task mix.
-
-    For geographies meeting minimum observation threshold only.
-
-    Args:
-        df: Input dataframe
-        geography: "country" or "state_us"
-        figsize: Figure size
-    """
-    # First run the collaboration analysis to get residuals
-    results = collaboration_task_regression(df, geography=geography)
-
-    # Suppress figure created by collaboration_task_regression
-    plt.close(results["figure"])
-
-    # Get the dataframe with residuals
-    df_residuals = results["df_residuals"]
-
-    # Sort by automation residuals (most augmentation to most automation)
-    df_plot = df_residuals.sort_values("automation_residuals", ascending=True)
-
-    # Adjust figure size based on number of geographies
-    n_geos = len(df_plot)
-    fig_height = max(8, n_geos * 0.25)
-    fig, ax = create_figure(figsize=(figsize[0], fig_height))
-
-    # Create color map
-    colors = [
-        AUGMENTATION_COLOR if x < 0 else AUTOMATION_COLOR
-        for x in df_plot["automation_residuals"]
-    ]
-
-    # Create horizontal bar chart
-    ax.barh(
-        range(len(df_plot)),
-        df_plot["automation_residuals"].values,
-        color=colors,
-        alpha=0.8,
-    )
-
-    # Set y-axis labels with geography names only
-    y_labels = [row["geo_name"] for _, row in df_plot.iterrows()]
-    ax.set_yticks(range(len(df_plot)))
-    ax.set_yticklabels(y_labels, fontsize=7)
-
-    # Reduce white space at top and bottom
-    ax.set_ylim(-0.5, len(df_plot) - 0.5)
-
-    # Add vertical line at zero
-    ax.axvline(x=0, color="black", linestyle="-", linewidth=1, alpha=0.7)
-
-    # Labels and title
-    geo_label = "Countries'" if geography == "country" else "States'"
-    format_axis(
-        ax,
-        xlabel="Automation % residual (after controlling for task mix)",
-        ylabel="",
-        title=f"{geo_label} automation vs augmentation preference\n(after controlling for task composition)",
-        grid=False,
-    )
-
-    # Add grid
-    ax.grid(True, axis="x", alpha=0.3, linestyle="--")
-
-    # Add value labels on the bars
-    for i, (_, row) in enumerate(df_plot.iterrows()):
-        value = row["automation_residuals"]
-        x_offset = 0.2 if abs(value) < 5 else 0.3
-        x_pos = value + (x_offset if value > 0 else -x_offset)
-        ax.text(
-            x_pos,
-            i,
-            f"{value:.1f}",
-            ha="left" if value > 0 else "right",
-            va="center",
-            fontsize=8,
-        )
-
-    # Add annotations
-    y_range = ax.get_ylim()
-    annotation_y = y_range[1] * 0.85
-
-    # Left annotation for augmentation
-    ax.text(
-        ax.get_xlim()[0] * 0.7,
-        annotation_y,
-        "Prefer augmentation",
-        fontsize=9,
-        color=AUGMENTATION_COLOR,
-        fontweight="bold",
-        ha="left",
-        va="center",
-    )
-
-    # Right annotation for automation
-    ax.text(
-        ax.get_xlim()[1] * 0.7,
-        annotation_y,
-        "Prefer automation",
-        fontsize=9,
-        color=AUTOMATION_COLOR,
-        fontweight="bold",
-        ha="right",
-        va="center",
-    )
-
-    plt.tight_layout()
-
-    return fig
-
-
-def plot_soc_distribution(
-    df, geo_list, geography, figsize=(14, 10), title=None, exclude_not_classified=True
-):
-    """
-    Plot SOC occupation distribution for multiple geographies (countries or states) with horizontal bars, colored by tier.
-
-    Args:
-        df: Long format dataframe
-        geo_list: List of geo_id values to compare (e.g., ['USA', 'BRA'] for countries or ['CA', 'TX'] for states)
-        geography: Geographic level ('country' or 'state_us')
-        figsize: Figure size
-        title: Chart title
-        exclude_not_classified: If True, excludes 'not_classified' from the chart
-    """
-    # Use global tier colors and names
-    tier_colors = TIER_COLORS_NUMERIC
-    tier_names = TIER_NAMES_NUMERIC
-
-    # Get usage tier and geo_name for each geography
-    tier_data = filter_df(
-        df, geography=geography, variable="usage_tier", facet=geography, geo_id=geo_list
-    )[["geo_id", "geo_name", "value"]].rename(columns={"value": "tier"})
-
-    # Collect SOC data for all geographies first to determine consistent ordering
-    all_soc_data = []
-    for geo_id in geo_list:
-        geo_soc = filter_df(
-            df,
-            geography=geography,
-            geo_id=geo_id,
-            facet="soc_occupation",
-            variable="soc_pct",
-        ).copy()
-
-        if not geo_soc.empty:
-            # Optionally filter out not_classified
-            if exclude_not_classified:
-                geo_soc = geo_soc[geo_soc["cluster_name"] != "not_classified"].copy()
-
-            geo_soc["geo"] = geo_id
-            all_soc_data.append(geo_soc)
-
-    combined_data = pd.concat(all_soc_data)
-
-    # Use global SOC distribution for countries, USA distribution for states
-    if geography == "country":
-        reference_data = filter_df(
-            df,
-            geography="global",
-            geo_id="GLOBAL",
-            facet="soc_occupation",
-            variable="soc_pct",
-        )
-    else:  # state_us
-        reference_data = filter_df(
-            df,
-            geography="country",
-            geo_id="USA",
-            facet="soc_occupation",
-            variable="soc_pct",
-        )
-
-    # Filter out not_classified from reference data if needed
-    if exclude_not_classified:
-        reference_data = reference_data[
-            reference_data["cluster_name"] != "not_classified"
-        ]
-
-    # Sort by reference values ascending so highest appears at top when plotted
-    soc_order = reference_data.sort_values("value", ascending=True)[
-        "cluster_name"
-    ].tolist()
-
-    # Create figure
-    fig, ax = create_figure(figsize=figsize)
-
-    # Width of bars and positions
-    n_geos = len(geo_list)
-    bar_width = 0.95 / n_geos  # Wider bars, less spacing within groups
-    y_positions = (
-        np.arange(len(soc_order)) * 1.05
-    )  # Reduce spacing between SOC groups to 5%
-
-    # Sort geo_list to ensure highest tier appears at top within each group
-    # Reverse the order so tier 4 is plotted first and appears on top
-    geo_tier_map = dict(zip(tier_data["geo_id"], tier_data["tier"], strict=True))
-    geo_list_sorted = sorted(geo_list, key=lambda x: geo_tier_map[x])
-
-    # Plot bars for each geography
-    for i, geo_id in enumerate(geo_list_sorted):
-        geo_data = filter_df(combined_data, geo=geo_id)
-        geo_name = filter_df(tier_data, geo_id=geo_id)["geo_name"].iloc[0]
-        geo_tier = filter_df(tier_data, geo_id=geo_id)["tier"].iloc[0]
-
-        # Get values in the right order
-        values = []
-        for soc in soc_order:
-            val_data = filter_df(geo_data, cluster_name=soc)["value"]
-            # Use NaN for missing data
-            values.append(val_data.iloc[0] if not val_data.empty else float("nan"))
-
-        # Determine color based on tier
-        color = tier_colors[int(geo_tier)]
-
-        # Create bars with offset for multiple geographies
-        # Reverse the offset calculation so first geo (lowest tier) goes to bottom
-        offset = ((n_geos - 1 - i) - n_geos / 2 + 0.5) * bar_width
-
-        # Get tier name for label
-        tier_label = tier_names[int(geo_tier)]
-        label_text = f"{geo_name} ({tier_label})"
-
-        bars = ax.barh(
-            y_positions + offset,
-            values,
-            bar_width,
-            label=label_text,
-            color=color,
-            alpha=0.8,
-        )
-
-        # Add value labels for bars with data
-        for bar, value in zip(bars, values, strict=True):
-            if not pd.isna(value):
-                ax.text(
-                    value + 0.1,
-                    bar.get_y() + bar.get_height() / 2,
-                    f"{value:.1f}%",
-                    va="center",
-                    fontsize=5,
-                )
-
-    # Set y-axis labels - position them at the center of each SOC group
-    ax.set_yticks(y_positions)
-    ax.set_yticklabels(soc_order, fontsize=9, va="center")
-
-    # Reduce white space at top and bottom
-    ax.set_ylim(y_positions[0] - 0.5, y_positions[-1] + 0.5)
-
-    # Customize plot
-    format_axis(
-        ax,
-        xlabel="Share of Claude task usage (%)",
-        ylabel="Standard Occupation Classification group",
-        grid=False,
-    )
-
-    if title is None:
-        title = "Claude task usage by occupation: Comparison by AI usage tier"
-    format_axis(ax, title=title, title_size=14, grid=False)
-
-    # Add legend
-    ax.legend(loc="lower right", fontsize=10, framealpha=0.95)
-
-    # Grid
-    ax.grid(True, axis="x", alpha=0.3, linestyle="--")
-    ax.set_xlim(0, max(combined_data["value"]) * 1.15)
-
-    plt.tight_layout()
-    return fig

release_2025_09_15/code/aei_report_v3_analysis_1p_api.ipynb

@@ -1,315 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# AEI Report v3 API Analysis\n",
-    "This notebook produces the streamlined analysis for the AEI report API chapter"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "vscode": {
-     "languageId": "python"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "from pathlib import Path\n",
-    "import pandas as pd"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "vscode": {
-     "languageId": "python"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# Import the analysis functions\n",
-    "from aei_analysis_functions_1p_api import (\n",
-    "    setup_plot_style,\n",
-    "    load_preprocessed_data,\n",
-    "    create_top_requests_bar_chart,\n",
-    "    create_platform_occupational_comparison,\n",
-    "    create_platform_lorenz_curves,\n",
-    "    create_collaboration_alluvial,\n",
-    "    create_automation_augmentation_panel,\n",
-    "    create_token_output_bar_chart,\n",
-    "    create_completion_vs_input_tokens_scatter,\n",
-    "    create_occupational_usage_cost_scatter,\n",
-    "    create_partial_regression_plot,\n",
-    "    perform_usage_share_regression_unweighted,\n",
-    "    create_btos_ai_adoption_chart,\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "vscode": {
-     "languageId": "python"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# Set matplotlib to use the correct backend and style\n",
-    "setup_plot_style()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "vscode": {
-     "languageId": "python"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# Set up output directory for saving figures\n",
-    "output_dir = Path(\"../data/output/figures/\")\n",
-    "btos_data_path = Path(\"../data/input/BTOS_National.xlsx\")\n",
-    "api_data_path = Path(\"../data/intermediate/aei_raw_1p_api_2025-08-04_to_2025-08-11.csv\")\n",
-    "cai_data_path = Path(\n",
-    "    \"../data/intermediate/aei_raw_claude_ai_2025-08-04_to_2025-08-11.csv\"\n",
-    ")\n",
-    "\n",
-    "# Create output directory\n",
-    "output_dir.mkdir(parents=True, exist_ok=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "vscode": {
-     "languageId": "python"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# Load BTOS Data\n",
-    "print(\"Loading BTOS data...\")\n",
-    "btos_df = pd.read_excel(btos_data_path, sheet_name=\"Response Estimates\")\n",
-    "btos_df_ref_dates_df = pd.read_excel(\n",
-    "    btos_data_path, sheet_name=\"Collection and Reference Dates\"\n",
-    ")\n",
-    "\n",
-    "# Load the API data\n",
-    "print(\"Loading API data...\")\n",
-    "api_df = load_preprocessed_data(api_data_path)\n",
-    "\n",
-    "# Load the Claude.ai data\n",
-    "print(\"Loading Claude.ai data...\")\n",
-    "cai_df = load_preprocessed_data(cai_data_path)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "vscode": {
-     "languageId": "python"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "create_btos_ai_adoption_chart(btos_df, btos_df_ref_dates_df, output_dir)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "vscode": {
-     "languageId": "python"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# Create the top requests bar chart\n",
-    "print(\"Creating top requests bar chart...\")\n",
-    "top_requests_chart = create_top_requests_bar_chart(api_df, output_dir)\n",
-    "print(f\"Chart saved to: {top_requests_chart}\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "vscode": {
-     "languageId": "python"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# Create the platform occupational comparison chart\n",
-    "print(\"Creating platform occupational comparison chart...\")\n",
-    "occupational_comparison_chart = create_platform_occupational_comparison(\n",
-    "    api_df, cai_df, output_dir\n",
-    ")\n",
-    "print(f\"Chart saved to: {occupational_comparison_chart}\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "vscode": {
-     "languageId": "python"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# Create the platform Lorenz curves\n",
-    "print(\"Creating platform Lorenz curves...\")\n",
-    "lorenz_curves_chart = create_platform_lorenz_curves(api_df, cai_df, output_dir)\n",
-    "print(f\"Chart saved to: {lorenz_curves_chart}\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "vscode": {
-     "languageId": "python"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# Create the collaboration alluvial diagram\n",
-    "print(\"Creating collaboration alluvial diagram...\")\n",
-    "alluvial_chart = create_collaboration_alluvial(api_df, cai_df, output_dir)\n",
-    "print(f\"Chart saved to: {alluvial_chart}\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "vscode": {
-     "languageId": "python"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# Create the automation vs augmentation panel\n",
-    "print(\"Creating automation vs augmentation panel...\")\n",
-    "automation_panel_chart = create_automation_augmentation_panel(\n",
-    "    api_df, cai_df, output_dir\n",
-    ")\n",
-    "print(f\"Chart saved to: {automation_panel_chart}\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "vscode": {
-     "languageId": "python"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# Create the token output bar chart\n",
-    "print(\"Creating token output bar chart...\")\n",
-    "token_output_chart = create_token_output_bar_chart(api_df, output_dir)\n",
-    "print(f\"Chart saved to: {token_output_chart}\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "vscode": {
-     "languageId": "python"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# Create the completion vs input tokens scatter plot\n",
-    "print(\"Creating completion vs input tokens scatter plot...\")\n",
-    "completion_input_scatter = create_completion_vs_input_tokens_scatter(api_df, output_dir)\n",
-    "print(f\"Chart saved to: {completion_input_scatter}\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "vscode": {
-     "languageId": "python"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# Create the occupational usage vs cost scatter plot\n",
-    "print(\"Creating occupational usage vs cost scatter plot...\")\n",
-    "usage_cost_scatter = create_occupational_usage_cost_scatter(api_df, output_dir)\n",
-    "print(f\"Chart saved to: {usage_cost_scatter}\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "vscode": {
-     "languageId": "python"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# Create the partial regression plot\n",
-    "print(\"Creating partial regression plot...\")\n",
-    "partial_plot, regression_results = create_partial_regression_plot(\n",
-    "    api_df, cai_df, output_dir\n",
-    ")\n",
-    "print(f\"Chart saved to: {partial_plot}\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "vscode": {
-     "languageId": "python"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# Perform the unweighted usage share regression analysis\n",
-    "print(\"Performing unweighted usage share regression analysis...\")\n",
-    "regression_model = perform_usage_share_regression_unweighted(api_df, cai_df, output_dir)\n",
-    "regression_model.summary()"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Coconut",
-   "language": "coconut",
-   "name": "coconut"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "python",
-    "version": 3
-   },
-   "file_extension": ".coco",
-   "mimetype": "text/x-python3",
-   "name": "coconut",
-   "pygments_lexer": "coconut",
-   "version": "3.0.2"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}

release_2025_09_15/code/aei_report_v3_analysis_claude_ai.ipynb

@@ -1,868 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# AEI Report v3 Claude.ai Analysis\n",
-    "\n",
-    "This notebook performs statistical analysis and creates visualizations from enriched Clio data.\n",
-    "It works directly with long format data from the preprocessing pipeline.\n",
-    "\n",
-    "**Input**: `aei_enriched_claude_ai_2025-08-04_to_2025-08-11.csv`\n",
-    "\n",
-    "**Output**: Visualizations"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 1. Setup and Data Loading"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "vscode": {
-     "languageId": "python"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "from pathlib import Path\n",
-    "import pandas as pd\n",
-    "import matplotlib.pyplot as plt\n",
-    "\n",
-    "# Import all analysis functions\n",
-    "from aei_analysis_functions_claude_ai import (\n",
-    "    setup_plot_style,\n",
-    "    get_filtered_geographies,\n",
-    "    plot_usage_index_bars,\n",
-    "    plot_tier_map,\n",
-    "    plot_usage_share_bars,\n",
-    "    plot_tier_summary_table,\n",
-    "    plot_gdp_scatter,\n",
-    "    plot_request_comparison_cards,\n",
-    "    plot_soc_usage_scatter,\n",
-    "    plot_dc_task_request_cards,\n",
-    "    collaboration_task_regression,\n",
-    "    plot_usage_index_histogram,\n",
-    "    plot_variable_map,\n",
-    "    plot_soc_distribution,\n",
-    "    plot_automation_preference_residuals,\n",
-    "    plot_variable_bars,\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "vscode": {
-     "languageId": "python"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# Set matplotlib to use the correct backend and style\n",
-    "setup_plot_style()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "vscode": {
-     "languageId": "python"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# Set up output directory for saving figures\n",
-    "output_dir = Path(\"../data/output/figures/\")\n",
-    "output_dir.mkdir(parents=True, exist_ok=True)\n",
-    "output_dir_app = Path(\"../data/output/figures/appendix/\")\n",
-    "output_dir_app.mkdir(parents=True, exist_ok=True)\n",
-    "\n",
-    "# Load enriched data\n",
-    "data_path = \"../data/output/aei_enriched_claude_ai_2025-08-04_to_2025-08-11.csv\"\n",
-    "\n",
-    "# Load the data - use keep_default_na=False to preserve \"NA\" (Namibia) as string\n",
-    "df = pd.read_csv(data_path, keep_default_na=False, na_values=[\"\"])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "vscode": {
-     "languageId": "python"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# Filter countries to those with at least 200 observations\n",
-    "# Filter US states to those with at least 100 observations\n",
-    "filtered_countries, filtered_states = get_filtered_geographies(df)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 2.2 Global"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "vscode": {
-     "languageId": "python"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# Top countries by share of global usage\n",
-    "plot_usage_share_bars(\n",
-    "    df,\n",
-    "    geography=\"country\",\n",
-    "    top_n=30,\n",
-    ")\n",
-    "plt.savefig(\n",
-    "    output_dir / \"usage_pct_bar_country_top30.png\", dpi=300, bbox_inches=\"tight\"\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "vscode": {
-     "languageId": "python"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# Create world map showing usage tiers\n",
-    "plot_tier_map(\n",
-    "    df,\n",
-    "    geography=\"country\",\n",
-    "    title=\"Anthropic AI Usage Index tiers by country\",\n",
-    "    figsize=(16, 10),\n",
-    ")\n",
-    "plt.savefig(\n",
-    "    output_dir / \"ai_usage_index_tier_map_country_all.png\", dpi=300, bbox_inches=\"tight\"\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "vscode": {
-     "languageId": "python"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# Create tier summary table for countries\n",
-    "plot_tier_summary_table(df, geography=\"country\")\n",
-    "plt.savefig(\n",
-    "    output_dir / \"tier_summary_table_country.png\",\n",
-    "    dpi=300,\n",
-    "    bbox_inches=\"tight\",\n",
-    "    transparent=True,\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "vscode": {
-     "languageId": "python"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# Top countries by usage per capita\n",
-    "plot_usage_index_bars(\n",
-    "    df, geography=\"country\", top_n=20, filtered_entities=filtered_countries\n",
-    ")\n",
-    "plt.savefig(\n",
-    "    output_dir / \"ai_usage_index_bar_country_top20.png\", dpi=300, bbox_inches=\"tight\"\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "vscode": {
-     "languageId": "python"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# GDP vs usage regression for countries\n",
-    "plot_gdp_scatter(df, geography=\"country\", filtered_entities=filtered_countries)\n",
-    "plt.savefig(\n",
-    "    output_dir / \"ai_usage_index_gdp_reg_country_min_obs.png\",\n",
-    "    dpi=300,\n",
-    "    bbox_inches=\"tight\",\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "vscode": {
-     "languageId": "python"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# GDP vs usage regression for countries\n",
-    "plot_gdp_scatter(\n",
-    "    df, geography=\"country\", filtered_entities=filtered_countries, figsize=(13.2, 8.25)\n",
-    ")\n",
-    "plt.savefig(\n",
-    "    output_dir / \"ai_usage_index_gdp_reg_country_min_obs_wide.png\",\n",
-    "    dpi=300,\n",
-    "    bbox_inches=\"tight\",\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "vscode": {
-     "languageId": "python"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# Create SOC diffusion scatter plot with top 4 classified SOC groups (2x2 grid)\n",
-    "plot_soc_usage_scatter(df, geography=\"country\")\n",
-    "plt.savefig(\n",
-    "    output_dir / \"soc_usage_scatter_top4_country_min.png\", dpi=300, bbox_inches=\"tight\"\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "vscode": {
-     "languageId": "python"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# Find the highest usage country in each tier (1-4)\n",
-    "\n",
-    "# Get usage tier and usage count data for all countries\n",
-    "tier_data = df[\n",
-    "    (df[\"geography\"] == \"country\")\n",
-    "    & (df[\"variable\"] == \"usage_tier\")\n",
-    "    & (df[\"facet\"] == \"country\")\n",
-    "][[\"geo_id\", \"value\"]].rename(columns={\"value\": \"tier\"})\n",
-    "\n",
-    "usage_data = df[\n",
-    "    (df[\"geography\"] == \"country\")\n",
-    "    & (df[\"variable\"] == \"usage_count\")\n",
-    "    & (df[\"facet\"] == \"country\")\n",
-    "][[\"geo_id\", \"geo_name\", \"value\"]].rename(columns={\"value\": \"usage_count\"})\n",
-    "\n",
-    "# Merge tier and usage data\n",
-    "country_data = usage_data.merge(tier_data, on=\"geo_id\")\n",
-    "\n",
-    "selected_countries = [\n",
-    "    country_data[country_data[\"tier\"] == tier]\n",
-    "    .sort_values(\"usage_count\", ascending=False)\n",
-    "    .iloc[0][\"geo_id\"]\n",
-    "    for tier in [4, 3, 2, 1]\n",
-    "]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "vscode": {
-     "languageId": "python"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# Compare top overrepresented requests for 4 highest usage countries in each tier\n",
-    "plot_request_comparison_cards(\n",
-    "    df,\n",
-    "    geo_ids=selected_countries,\n",
-    "    top_n=5,\n",
-    "    title=\"Top overrepresented requests for the United States, Brazil, Vietnam and India\",\n",
-    "    geography=\"country\",\n",
-    ")\n",
-    "\n",
-    "plt.savefig(\n",
-    "    output_dir / \"request_comparison_cards_by_tier_country_selected4.png\",\n",
-    "    dpi=300,\n",
-    "    bbox_inches=\"tight\",\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 3. United States"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "vscode": {
-     "languageId": "python"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# State tier map\n",
-    "plot_tier_map(\n",
-    "    df, geography=\"state_us\", title=\"Anthropic AI Usage Index tier by US state\"\n",
-    ")\n",
-    "plt.savefig(\n",
-    "    output_dir / \"ai_usage_index_tier_map_state_all.png\", dpi=300, bbox_inches=\"tight\"\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "vscode": {
-     "languageId": "python"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# Top 20 US states\n",
-    "plot_usage_index_bars(\n",
-    "    df,\n",
-    "    geography=\"state_us\",\n",
-    "    top_n=20,\n",
-    ")\n",
-    "plt.savefig(\n",
-    "    output_dir / \"ai_usage_index_bar_state_top20.png\", dpi=300, bbox_inches=\"tight\"\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "vscode": {
-     "languageId": "python"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# Create tier summary table for US states\n",
-    "plot_tier_summary_table(df, geography=\"state_us\")\n",
-    "plt.savefig(\n",
-    "    output_dir / \"tier_summary_table_state.png\",\n",
-    "    dpi=300,\n",
-    "    bbox_inches=\"tight\",\n",
-    "    transparent=True,\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "vscode": {
-     "languageId": "python"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# Find the highest usage US state in each tier (1-4)\n",
-    "\n",
-    "# Get usage tier and usage count data for US states\n",
-    "tier_data_states = df[\n",
-    "    (df[\"geography\"] == \"state_us\")\n",
-    "    & (df[\"variable\"] == \"usage_tier\")\n",
-    "    & (df[\"facet\"] == \"state_us\")\n",
-    "][[\"geo_id\", \"value\"]].rename(columns={\"value\": \"tier\"})\n",
-    "\n",
-    "usage_data_states = df[\n",
-    "    (df[\"geography\"] == \"state_us\")\n",
-    "    & (df[\"variable\"] == \"usage_count\")\n",
-    "    & (df[\"facet\"] == \"state_us\")\n",
-    "][[\"geo_id\", \"geo_name\", \"value\"]].rename(columns={\"value\": \"usage_count\"})\n",
-    "\n",
-    "# Merge tier and usage data\n",
-    "state_data = usage_data_states.merge(tier_data_states, on=\"geo_id\")\n",
-    "\n",
-    "# Find the highest usage state in each tier\n",
-    "selected_states = [\n",
-    "    state_data[state_data[\"tier\"] == tier]\n",
-    "    .sort_values(\"usage_count\", ascending=False)\n",
-    "    .iloc[0][\"geo_id\"]\n",
-    "    for tier in [4, 3, 2, 1]\n",
-    "]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "vscode": {
-     "languageId": "python"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# Compare top overrepresented requests for US states representing each tier\n",
-    "# CA (Tier 4), TX (Tier 3), FL (Tier 2), SC (Tier 1)\n",
-    "states_to_compare = [\"CA\", \"TX\", \"FL\", \"SC\"]\n",
-    "\n",
-    "plot_request_comparison_cards(\n",
-    "    df,\n",
-    "    geo_ids=states_to_compare,\n",
-    "    top_n=5,\n",
-    "    title=\"Top overrepresented high-level requests for California, Texas, Florida and South Carolina\",\n",
-    "    geography=\"state_us\",\n",
-    ")\n",
-    "\n",
-    "plt.savefig(\n",
-    "    output_dir / \"request_comparison_cards_by_tier_state_selected4.png\",\n",
-    "    dpi=300,\n",
-    "    bbox_inches=\"tight\",\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "vscode": {
-     "languageId": "python"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# Create card-style visualization for Washington DC\n",
-    "# Shows top O*NET tasks and top request categories\n",
-    "plot_dc_task_request_cards(\n",
-    "    df, title=\"Washington, DC: Highest Anthropic AI Usage Index in the US\"\n",
-    ")\n",
-    "\n",
-    "plt.savefig(\n",
-    "    output_dir / \"task_request_comparison_state_dc.png\", dpi=300, bbox_inches=\"tight\"\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "vscode": {
-     "languageId": "python"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# Collaboration pattern analysis with task mix control\n",
-    "# This analysis determines whether the relationship between AUI\n",
-    "# and automation preference persists after controlling for task composition\n",
-    "collaboration_task_regression(df, geography=\"country\")\n",
-    "plt.savefig(\n",
-    "    output_dir / \"collaboration_task_control_partial_corr_country.png\",\n",
-    "    dpi=300,\n",
-    "    bbox_inches=\"tight\",\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Appendix"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Global"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "vscode": {
-     "languageId": "python"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# Distribution histogram\n",
-    "plot_usage_index_histogram(\n",
-    "    df, geography=\"country\", title=\"Distribution of Anthropic AI Usage Index\"\n",
-    ")\n",
-    "plt.savefig(\n",
-    "    output_dir_app / \"ai_usage_index_histogram_country_all.png\",\n",
-    "    dpi=300,\n",
-    "    bbox_inches=\"tight\",\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "vscode": {
-     "languageId": "python"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# Create map showing share of usage\n",
-    "plot_variable_map(\n",
-    "    df,\n",
-    "    variable=\"usage_pct\",\n",
-    "    geography=\"country\",\n",
-    "    title=\"Share of global Claude usage by country\",\n",
-    "    figsize=(14, 8),\n",
-    ")\n",
-    "plt.savefig(\n",
-    "    output_dir_app / \"usage_pct_map_country_all.png\", dpi=300, bbox_inches=\"tight\"\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "vscode": {
-     "languageId": "python"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# Create world map showing usage per capita\n",
-    "plot_variable_map(\n",
-    "    df,\n",
-    "    variable=\"usage_per_capita_index\",\n",
-    "    geography=\"country\",\n",
-    "    title=\"Anthropic AI Usage Index by country\",\n",
-    "    center_at_one=True,\n",
-    "    figsize=(14, 8),\n",
-    ")\n",
-    "plt.savefig(\n",
-    "    output_dir_app / \"ai_usage_index_map_country_all.png\", dpi=300, bbox_inches=\"tight\"\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "vscode": {
-     "languageId": "python"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# AUI for all countries\n",
-    "plot_usage_index_bars(\n",
-    "    df,\n",
-    "    geography=\"country\",\n",
-    "    filtered_entities=filtered_countries,\n",
-    ")\n",
-    "plt.savefig(\n",
-    "    output_dir_app / \"ai_usage_index_country_all.png\", dpi=300, bbox_inches=\"tight\"\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "vscode": {
-     "languageId": "python"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# SOC distribution comparison for countries by usage tier\n",
-    "plot_soc_distribution(\n",
-    "    df,\n",
-    "    selected_countries,\n",
-    "    \"country\",\n",
-    "    title=\"Occupation groups by Claude task usage in the United States, Brazil, Vietnam and India\",\n",
-    ")\n",
-    "plt.savefig(\n",
-    "    output_dir_app / \"soc_distribution_by_tier_country_selected4.png\",\n",
-    "    dpi=300,\n",
-    "    bbox_inches=\"tight\",\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "vscode": {
-     "languageId": "python"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# Plot automation preference residuals after controlling for task mix\n",
-    "# This shows which countries prefer more automation vs augmentation\n",
-    "# than would be expected given their task composition\n",
-    "plot_automation_preference_residuals(df)\n",
-    "plt.savefig(\n",
-    "    output_dir_app / \"automation_preference_residuals.png\", dpi=300, bbox_inches=\"tight\"\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## United States"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "vscode": {
-     "languageId": "python"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# Top countries by share of global usage\n",
-    "plot_usage_share_bars(\n",
-    "    df,\n",
-    "    geography=\"state_us\",\n",
-    "    top_n=30,\n",
-    "    title=\"Top 30 US states by share of US Claude usage\",\n",
-    ")\n",
-    "plt.savefig(\n",
-    "    output_dir_app / \"usage_pct_bar_state_top30.png\", dpi=300, bbox_inches=\"tight\"\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "vscode": {
-     "languageId": "python"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# Distribution histogram\n",
-    "plot_usage_index_histogram(\n",
-    "    df, geography=\"state_us\", title=\"Distribution of Anthropic AI Usage Index\"\n",
-    ")\n",
-    "plt.savefig(\n",
-    "    output_dir_app / \"ai_usage_index_histogram_state_all.png\",\n",
-    "    dpi=300,\n",
-    "    bbox_inches=\"tight\",\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "vscode": {
-     "languageId": "python"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# Create map showing share of usage\n",
-    "plot_variable_map(\n",
-    "    df,\n",
-    "    variable=\"usage_pct\",\n",
-    "    geography=\"state_us\",\n",
-    "    title=\"Share of global Claude usage by US state\",\n",
-    "    figsize=(14, 8),\n",
-    ")\n",
-    "plt.savefig(\n",
-    "    output_dir_app / \"usage_pct_map_state_all.png\", dpi=300, bbox_inches=\"tight\"\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "vscode": {
-     "languageId": "python"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# Create map showing per capita usage\n",
-    "plot_variable_map(\n",
-    "    df,\n",
-    "    variable=\"usage_per_capita_index\",\n",
-    "    geography=\"state_us\",\n",
-    "    title=\"Anthropic AI Usage Index by US state\",\n",
-    "    center_at_one=True,\n",
-    "    figsize=(14, 8),\n",
-    ")\n",
-    "plt.savefig(\n",
-    "    output_dir_app / \"ai_usage_index_map_state_all.png\", dpi=300, bbox_inches=\"tight\"\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "vscode": {
-     "languageId": "python"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "plot_usage_index_bars(\n",
-    "    df,\n",
-    "    geography=\"state_us\",\n",
-    ")\n",
-    "plt.savefig(\n",
-    "    output_dir_app / \"ai_usage_index_bar_state_all.png\", dpi=300, bbox_inches=\"tight\"\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "vscode": {
-     "languageId": "python"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# GDP vs usage regression for US states\n",
-    "plot_gdp_scatter(df, geography=\"state_us\", filtered_entities=filtered_states)\n",
-    "plt.savefig(\n",
-    "    output_dir_app / \"ai_usage_index_gdp_reg_state_min_obs.png\",\n",
-    "    dpi=300,\n",
-    "    bbox_inches=\"tight\",\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "vscode": {
-     "languageId": "python"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# SOC distribution comparison for US states by usage tier\n",
-    "plot_soc_distribution(\n",
-    "    df,\n",
-    "    selected_states,\n",
-    "    \"state_us\",\n",
-    "    title=\"Occupation groups by Claude task usage in California, Texas, Florida and South Carolina\",\n",
-    ")\n",
-    "plt.savefig(\n",
-    "    output_dir_app / \"soc_distribution_by_tier_state_selected4.png\",\n",
-    "    dpi=300,\n",
-    "    bbox_inches=\"tight\",\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "vscode": {
-     "languageId": "python"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# Top SOC chart\n",
-    "plot_variable_bars(\n",
-    "    df,\n",
-    "    variable=\"soc_pct\",\n",
-    "    geography=\"country\",\n",
-    "    facet=\"soc_occupation\",\n",
-    "    geo_id=\"USA\",\n",
-    "    title=\"Occupation groups in the US by Claude use for associated tasks\",\n",
-    "    xlabel=\"Share of total usage (%)\",\n",
-    "    exclude_not_classified=True,\n",
-    ")\n",
-    "\n",
-    "# Save the figure\n",
-    "plt.savefig(output_dir_app / \"soc_bar_country_us.png\", dpi=300, bbox_inches=\"tight\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "vscode": {
-     "languageId": "python"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# Create SOC diffusion scatter plot with top 4 classified SOC groups\n",
-    "plot_soc_usage_scatter(\n",
-    "    df,\n",
-    "    geography=\"state_us\",\n",
-    ")\n",
-    "plt.savefig(\n",
-    "    output_dir_app / \"soc_usage_scatter_top4_state_min.png\",\n",
-    "    dpi=300,\n",
-    "    bbox_inches=\"tight\",\n",
-    ")"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Coconut",
-   "language": "coconut",
-   "name": "coconut"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "python",
-    "version": 3
-   },
-   "file_extension": ".coco",
-   "mimetype": "text/x-python3",
-   "name": "coconut",
-   "pygments_lexer": "coconut",
-   "version": "3.0.2"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}

release_2025_09_15/code/aei_report_v3_change_over_time_claude_ai.py

@@ -1,564 +0,0 @@
-#!/usr/bin/env python3
-"""
-Clean Economic Analysis Figure Generator
-======================================
-Generates three key figures for V1→V2→V3 economic analysis:
-1. Usage Share Trends Across Economic Index Reports
-2. Notable Task Changes (Growing/Declining Tasks)
-3. Automation vs Augmentation Evolution
-
-ASSUMPTIONS:
-- V1/V2/V3 use same task taxonomy
-- GLOBAL geo_id is representative
-- Missing values = 0% usage
-- Percentages don't need renormalization
-"""
-
-import os
-import warnings
-from pathlib import Path
-
-import matplotlib.pyplot as plt
-import numpy as np
-import pandas as pd
-import seaborn as sns
-
-# Use default matplotlib styling
-plt.style.use("default")
-
-# Configuration
-FILES = {
-    "v1_tasks": "../data/input/task_pct_v1.csv",
-    "v2_tasks": "../data/input/task_pct_v2.csv",
-    "v3_data": "../data/intermediate/aei_raw_claude_ai_2025-08-04_to_2025-08-11.csv",
-    "v1_auto": "../data/input/automation_vs_augmentation_v1.csv",
-    "v2_auto": "../data/input/automation_vs_augmentation_v2.csv",
-    "onet": "../data/intermediate/onet_task_statements.csv",
-    "soc": "../data/intermediate/soc_structure.csv",
-}
-
-AUTOMATION_TYPES = ["directive", "feedback_loop"]
-AUGMENTATION_TYPES = ["validation", "task_iteration", "learning"]
-MIN_THRESHOLD = 1.0
-COLORS = {
-    "increase": "#2E8B57",
-    "decrease": "#CD5C5C",
-    "automation": "#FF6B6B",
-    "augmentation": "#4ECDC4",
-}
-
-# ============================================================================
-# DATA LOADING
-# ============================================================================
-
-
-def load_task_data(filepath, version_name):
-    """Load and validate task percentage data for any version."""
-    if not Path(filepath).exists():
-        raise FileNotFoundError(f"Missing {version_name} data: {filepath}")
-
-    df = pd.read_csv(filepath)
-
-    if version_name == "V3":
-        # Filter V3 data for global onet tasks
-        df = df[
-            (df["geo_id"] == "GLOBAL")
-            & (df["facet"] == "onet_task")
-            & (df["variable"] == "onet_task_pct")
-        ].copy()
-        df = df.rename(columns={"cluster_name": "task_name", "value": "pct"})
-
-        # Remove "not_classified" from V3 for fair comparison with V1/V2
-        # Keep "none" as it represents legitimate unclassifiable tasks across all versions
-        not_classified_pct = df[df["task_name"] == "not_classified"]["pct"].sum()
-        df = df[df["task_name"] != "not_classified"].copy()
-
-        # Renormalize V3 to 100% after removing not_classified
-        if not_classified_pct > 0:
-            remaining_total = df["pct"].sum()
-            normalization_factor = 100 / remaining_total
-            df["pct"] = df["pct"] * normalization_factor
-            print(
-                f"  → Removed {not_classified_pct:.1f}% not_classified, renormalized by {normalization_factor:.3f}x"
-            )
-
-    # Validate structure
-    if "task_name" not in df.columns or "pct" not in df.columns:
-        raise ValueError(f"{version_name} data missing required columns")
-
-    # Normalize task names and validate totals
-    df["task_name"] = df["task_name"].str.lower().str.strip()
-    total = df["pct"].sum()
-
-    if not (80 <= total <= 120):
-        warnings.warn(
-            f"{version_name} percentages sum to {total:.1f}% (expected ~100%)",
-            stacklevel=2,
-        )
-
-    print(f"✓ {version_name}: {len(df)} tasks, {total:.1f}% coverage")
-    return df[["task_name", "pct"]]
-
-
-def load_automation_data():
-    """Load automation/collaboration data for all versions."""
-    result = {}
-
-    # V1 and V2 - always renormalize to 100%
-    for version in ["v1", "v2"]:
-        df = pd.read_csv(FILES[f"{version}_auto"])
-
-        # Always renormalize to 100%
-        total = df["pct"].sum()
-        normalization_factor = 100 / total
-        df["pct"] = df["pct"] * normalization_factor
-        print(
-            f"  → {version.upper()} automation: renormalized from {total:.1f}% to 100.0%"
-        )
-
-        result[version] = df
-
-    # V3 from processed data
-    df = pd.read_csv(FILES["v3_data"])
-    v3_collab = df[
-        (df["geo_id"] == "GLOBAL")
-        & (df["facet"] == "collaboration")
-        & (df["level"] == 0)
-        & (df["variable"] == "collaboration_pct")
-    ].copy()
-    v3_collab = v3_collab.rename(
-        columns={"cluster_name": "interaction_type", "value": "pct"}
-    )
-
-    # Remove "not_classified" from V3 collaboration data for fair comparison
-    not_classified_pct = v3_collab[v3_collab["interaction_type"] == "not_classified"][
-        "pct"
-    ].sum()
-    v3_collab = v3_collab[v3_collab["interaction_type"] != "not_classified"].copy()
-
-    # Renormalize V3 collaboration to 100% after removing not_classified
-    if not_classified_pct > 0:
-        remaining_total = v3_collab["pct"].sum()
-        normalization_factor = 100 / remaining_total
-        v3_collab["pct"] = v3_collab["pct"] * normalization_factor
-        print(
-            f"  → V3 collaboration: removed {not_classified_pct:.1f}% not_classified, renormalized by {normalization_factor:.3f}x"
-        )
-
-    result["v3"] = v3_collab[["interaction_type", "pct"]]
-
-    print(f"✓ Automation data loaded for all versions")
-    return result
-
-
-def load_occupational_mapping():
-    """Load O*NET to SOC mapping data."""
-    onet_df = pd.read_csv(FILES["onet"])
-    soc_df = pd.read_csv(FILES["soc"]).dropna(subset=["Major Group"])
-
-    onet_df["soc_major_group"] = onet_df["O*NET-SOC Code"].str[:2]
-    soc_df["soc_major_group"] = soc_df["Major Group"].str[:2]
-
-    merged = onet_df.merge(
-        soc_df[["soc_major_group", "SOC or O*NET-SOC 2019 Title"]], on="soc_major_group"
-    )
-    merged["task_normalized"] = merged["Task"].str.lower().str.strip()
-
-    print(f"✓ Occupational mapping: {merged['soc_major_group'].nunique()} SOC groups")
-    return merged
-
-
-# ============================================================================
-# ANALYSIS
-# ============================================================================
-
-
-def analyze_occupational_trends(task_data, onet_soc_data):
-    """Analyze occupational category trends across versions."""
-
-    def aggregate_by_occupation(df):
-        merged = df.merge(
-            onet_soc_data[
-                ["task_normalized", "SOC or O*NET-SOC 2019 Title"]
-            ].drop_duplicates(),
-            left_on="task_name",
-            right_on="task_normalized",
-            how="left",
-        )
-
-        unmapped = merged[merged["SOC or O*NET-SOC 2019 Title"].isna()]
-        # Only warn if there are real unmapped tasks (not just "none" and "not_classified")
-        real_unmapped = unmapped[
-            ~unmapped["task_name"].isin(["none", "not_classified"])
-        ]
-        if len(real_unmapped) > 0:
-            real_unmapped_pct = real_unmapped["pct"].sum()
-            warnings.warn(
-                f"{real_unmapped_pct:.1f}% of tasks unmapped to occupational categories",
-                stacklevel=2,
-            )
-
-        return merged.groupby("SOC or O*NET-SOC 2019 Title")["pct"].sum()
-
-    # Aggregate all versions
-    comparison_df = pd.DataFrame(
-        {
-            "v1": aggregate_by_occupation(task_data["v1"]),
-            "v2": aggregate_by_occupation(task_data["v2"]),
-            "v3": aggregate_by_occupation(task_data["v3"]),
-        }
-    ).fillna(0)
-
-    # Calculate changes and filter economically significant categories
-    comparison_df["v3_v1_diff"] = comparison_df["v3"] - comparison_df["v1"]
-    significant = comparison_df[
-        (comparison_df[["v1", "v2", "v3"]] >= MIN_THRESHOLD).any(axis=1)
-    ]
-
-    print(
-        f"✓ Occupational analysis: {len(significant)} economically significant categories"
-    )
-    return significant.sort_values("v1", ascending=False)
-
-
-def analyze_task_changes(task_data, onet_soc_data, top_n=12):
-    """Identify most notable task changes V1→V3."""
-    v1, v3 = task_data["v1"], task_data["v3"]
-
-    # Compare changes
-    comparison = (
-        v1[["task_name", "pct"]]
-        .rename(columns={"pct": "v1_pct"})
-        .merge(
-            v3[["task_name", "pct"]].rename(columns={"pct": "v3_pct"}),
-            on="task_name",
-            how="outer",
-        )
-        .fillna(0)
-    )
-
-    comparison["change"] = comparison["v3_pct"] - comparison["v1_pct"]
-    comparison["rel_change"] = np.where(
-        comparison["v1_pct"] > 0,
-        (comparison["v3_pct"] - comparison["v1_pct"]) / comparison["v1_pct"] * 100,
-        np.inf,
-    )
-
-    # Add SOC context
-    with_context = comparison.merge(
-        onet_soc_data[
-            ["task_normalized", "SOC or O*NET-SOC 2019 Title"]
-        ].drop_duplicates(),
-        left_on="task_name",
-        right_on="task_normalized",
-        how="left",
-    )
-
-    # Get all tasks with economically significant changes (>= 0.2pp)
-    significant_changes = with_context[abs(with_context["change"]) >= 0.2].copy()
-
-    # Create category column with formatted relative percentage change
-    def format_rel_change(row):
-        if row["v1_pct"] > 0:
-            rel_change = (row["v3_pct"] - row["v1_pct"]) / row["v1_pct"] * 100
-            return f"{rel_change:+.0f}%"
-        else:
-            return "new"
-
-    significant_changes["category"] = significant_changes.apply(
-        format_rel_change, axis=1
-    )
-
-    # Rename column and sort by change descending
-    significant_changes = significant_changes.rename(
-        columns={"SOC or O*NET-SOC 2019 Title": "soc_group"}
-    )
-    significant_changes = significant_changes.sort_values("change", ascending=False)
-
-    # Round to 3 decimals
-    significant_changes[["v1_pct", "v3_pct", "change"]] = significant_changes[
-        ["v1_pct", "v3_pct", "change"]
-    ].round(3)
-
-    print(f"✓ Task changes: {len(significant_changes)} notable changes identified")
-    return significant_changes
-
-
-def analyze_automation_trends(automation_data):
-    """Analyze automation vs augmentation trends across versions."""
-    # Standardize interaction names
-    for df in automation_data.values():
-        df["interaction_type"] = df["interaction_type"].replace(
-            {"task iteration": "task_iteration", "feedback loop": "feedback_loop"}
-        )
-
-    results = {}
-    for version, data in automation_data.items():
-        auto_total = data[data["interaction_type"].isin(AUTOMATION_TYPES)]["pct"].sum()
-        aug_total = data[data["interaction_type"].isin(AUGMENTATION_TYPES)]["pct"].sum()
-
-        interaction_dict = dict(zip(data["interaction_type"], data["pct"], strict=True))
-        results[version] = {
-            "automation_total": auto_total,
-            "augmentation_total": aug_total,
-            "directive": interaction_dict["directive"],
-            "feedback_loop": interaction_dict["feedback_loop"],
-            "validation": interaction_dict["validation"],
-            "task_iteration": interaction_dict["task_iteration"],
-            "learning": interaction_dict["learning"],
-        }
-
-    print("✓ Automation trends analysis complete")
-    return results
-
-
-# ============================================================================
-# VISUALIZATION
-# ============================================================================
-
-
-def setup_plot_style():
-    """Configure consistent plot styling."""
-    plt.rcParams.update({"font.size": 12, "axes.titlesize": 16, "axes.labelsize": 14})
-    sns.set_context("notebook", font_scale=1.1)
-
-
-def create_usage_trends_figure(comparison_df):
-    """Create Usage Share Trends subplot figure."""
-    setup_plot_style()
-
-    # Get top categories
-    top_cats = comparison_df[
-        (comparison_df[["v1", "v2", "v3"]] >= MIN_THRESHOLD).any(axis=1)
-    ].head(8)
-    top_cats.index = top_cats.index.str.replace(" Occupations", "")
-
-    fig, axes = plt.subplots(2, 4, figsize=(20, 15))
-    axes = axes.flatten()
-
-    line_color = "#FF8E53"
-    fill_color = "#DEB887"
-
-    # Simplified date labels (actual periods: Dec 2024-Jan 2025, Feb-Mar 2025, Aug 2025)
-    versions, version_labels = [1, 2, 3], ["Jan 2025", "Mar 2025", "Aug 2025"]
-
-    for i, (category, data) in enumerate(top_cats.iterrows()):
-        if i >= len(axes):
-            break
-        ax = axes[i]
-        values = [data["v1"], data["v2"], data["v3"]]
-
-        ax.plot(
-            versions,
-            values,
-            "o-",
-            color=line_color,
-            linewidth=3,
-            markersize=8,
-            markerfacecolor=line_color,
-            markeredgecolor="white",
-            markeredgewidth=2,
-        )
-        ax.fill_between(versions, values, alpha=0.3, color=fill_color)
-
-        # Add value labels
-        for x, y in zip(versions, values, strict=True):
-            ax.text(
-                x,
-                y + max(values) * 0.02,
-                f"{y:.1f}%",
-                ha="center",
-                va="bottom",
-                fontsize=12,
-                fontweight="bold",
-            )
-
-        ax.set_title(category, fontsize=14, fontweight="bold", pad=10)
-        ax.set_xticks(versions)
-        ax.set_xticklabels(version_labels)
-        ax.set_ylabel("Percentage", fontsize=12)
-        ax.set_ylim(0, max(values) * 1.15)
-        ax.grid(True, alpha=0.3)
-        ax.spines["top"].set_visible(False)
-        ax.spines["right"].set_visible(False)
-
-    fig.suptitle(
-        "Usage share trends across economic index reports (V1 to V3)",
-        fontsize=18,
-        fontweight="bold",
-        y=0.98,
-    )
-    plt.tight_layout()
-    plt.subplots_adjust(top=0.88)
-    return fig
-
-
-def create_automation_figure(trends):
-    """Create Automation vs Augmentation Evolution figure."""
-    setup_plot_style()
-
-    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(16, 6))
-
-    # Simplified date labels (actual periods: Dec 2024-Jan 2025, Feb-Mar 2025, Aug 2025)
-    version_labels = ["Jan 2025", "Mar 2025", "Aug 2025"]
-    x_pos = [1, 2, 3]
-
-    # Left: Overall trends (no fill)
-    auto_vals = [trends[v]["automation_total"] for v in ["v1", "v2", "v3"]]
-    aug_vals = [trends[v]["augmentation_total"] for v in ["v1", "v2", "v3"]]
-
-    ax1.plot(
-        x_pos,
-        auto_vals,
-        "o-",
-        color=COLORS["automation"],
-        linewidth=3,
-        markersize=8,
-        label="Automation",
-        markeredgecolor="white",
-        markeredgewidth=2,
-    )
-    ax1.plot(
-        x_pos,
-        aug_vals,
-        "o-",
-        color=COLORS["augmentation"],
-        linewidth=3,
-        markersize=8,
-        label="Augmentation",
-        markeredgecolor="white",
-        markeredgewidth=2,
-    )
-
-    # Value labels with automation above and augmentation below dots
-    y_max = max(max(auto_vals), max(aug_vals))
-    for i, (auto, aug) in enumerate(zip(auto_vals, aug_vals, strict=True)):
-        # Red (automation) always above the dot
-        ax1.text(
-            x_pos[i],
-            auto + 1.2,
-            f"{auto:.1f}%",
-            ha="center",
-            va="bottom",
-            fontweight="bold",
-            color=COLORS["automation"],
-        )
-        # Blue (augmentation) always below the dot
-        ax1.text(
-            x_pos[i],
-            aug - 1.5,
-            f"{aug:.1f}%",
-            ha="center",
-            va="top",
-            fontweight="bold",
-            color=COLORS["augmentation"],
-        )
-
-    ax1.set_xticks(x_pos)
-    ax1.set_xticklabels(version_labels)
-    ax1.set_ylabel("Percentage")
-    ax1.set_title("Automation vs augmentation trends")
-    ax1.legend()
-    ax1.grid(True, alpha=0.3)
-    ax1.spines[["top", "right"]].set_visible(False)
-    ax1.set_ylim(0, y_max * 1.15)
-
-    # Right: Individual interaction types with color-coded groups
-    interactions = [
-        "directive",
-        "feedback_loop",
-        "validation",
-        "task_iteration",
-        "learning",
-    ]
-    # Automation = red shades, Augmentation = cool shades
-    colors_individual = ["#DC143C", "#FF6B6B", "#4682B4", "#5F9EA0", "#4169E1"]
-
-    for interaction, color in zip(interactions, colors_individual, strict=True):
-        values = [trends[v][interaction] for v in ["v1", "v2", "v3"]]
-        ax2.plot(
-            x_pos,
-            values,
-            "o-",
-            color=color,
-            linewidth=2.5,
-            markersize=6,
-            label=interaction.replace("_", " ").title(),
-            alpha=0.8,
-        )
-
-    ax2.set_xticks(x_pos)
-    ax2.set_xticklabels(version_labels)
-    ax2.set_ylabel("Percentage")
-    ax2.set_title("Individual interaction types")
-    ax2.legend(bbox_to_anchor=(1.05, 1), loc="upper left")
-    ax2.grid(True, alpha=0.3)
-    ax2.spines[["top", "right"]].set_visible(False)
-
-    plt.suptitle(
-        "Automation vs augmentation evolution (V1 to V3)",
-        fontsize=16,
-        fontweight="bold",
-    )
-    plt.tight_layout()
-    return fig
-
-
-# ============================================================================
-# MAIN
-# ============================================================================
-
-
-def main():
-    """Generate all three economic analysis figures."""
-    print("=" * 80)
-    print("ECONOMIC ANALYSIS FIGURE GENERATION")
-    print("=" * 80)
-
-    # Use consistent output directory for all economic research scripts
-    output_dir = "../data/output/figures"
-    os.makedirs(output_dir, exist_ok=True)
-
-    # Load all data
-    print("\nLoading data...")
-    task_data = {
-        "v1": load_task_data(FILES["v1_tasks"], "V1"),
-        "v2": load_task_data(FILES["v2_tasks"], "V2"),
-        "v3": load_task_data(FILES["v3_data"], "V3"),
-    }
-    automation_data = load_automation_data()
-    onet_soc_data = load_occupational_mapping()
-
-    # Analysis
-    print("\nAnalyzing trends...")
-    occupational_trends = analyze_occupational_trends(task_data, onet_soc_data)
-    task_changes = analyze_task_changes(task_data, onet_soc_data)
-    automation_trends = analyze_automation_trends(automation_data)
-
-    # Generate figures
-    print("\nGenerating figures...")
-
-    fig1 = create_usage_trends_figure(occupational_trends)
-    fig1.savefig(
-        f"{output_dir}/main_occupational_categories.png",
-        dpi=300,
-        bbox_inches="tight",
-        facecolor="white",
-    )
-    print("✓ Saved: main_occupational_categories.png")
-
-    fig3 = create_automation_figure(automation_trends)
-    fig3.savefig(
-        f"{output_dir}/automation_trends_v1_v2_v3.png",
-        dpi=300,
-        bbox_inches="tight",
-        facecolor="white",
-    )
-    print("✓ Saved: automation_trends_v1_v2_v3.png")
-
-    print(f"\n✅ All figures generated successfully!")
-    return occupational_trends, task_changes, automation_trends
-
-
-if __name__ == "__main__":
-    results = main()

release_2025_09_15/code/aei_report_v3_preprocessing_claude_ai.ipynb

@@ -1,1840 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# AEI Report v3 Claude.ai Preprocessing\n",
-    "\n",
-    "This notebook takes processed Clio data and enriches it with external sources:\n",
-    "1. Merges with population data for per capita calculations\n",
-    "2. Merges with GDP data for economic analysis\n",
-    "3. Merges with SOC/O*NET data for occupational analysis\n",
-    "4. Applies MIN_OBSERVATIONS filtering\n",
-    "5. Calculates derived metrics (per capita, indices, tiers)\n",
-    "6. Categorizes collaboration patterns\n",
-    "\n",
-    "**Input**: `aei_raw_claude_ai_2025-08-04_to_2025-08-11.csv`\n",
-    "\n",
-    "**Output**: `aei_enriched_claude_ai_2025-08-04_to_2025-08-11.csv`"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Configuration and Setup"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from pathlib import Path\n",
-    "\n",
-    "import numpy as np\n",
-    "import pandas as pd"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Year for external data\n",
-    "YEAR = 2024\n",
-    "\n",
-    "# Data paths - using local directories\n",
-    "DATA_INPUT_DIR = \"../data/input\"  # Raw external data\n",
-    "DATA_INTERMEDIATE_DIR = (\n",
-    "    \"../data/intermediate\"  # Processed external data and Clio output\n",
-    ")\n",
-    "DATA_OUTPUT_DIR = \"../data/output\"  # Final enriched data\n",
-    "\n",
-    "# Minimum observation thresholds\n",
-    "MIN_OBSERVATIONS_COUNTRY = 200  # Threshold for countries\n",
-    "MIN_OBSERVATIONS_US_STATE = 100  # Threshold for US states"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Countries where Claude doesn't operate (23 countries)\n",
-    "EXCLUDED_COUNTRIES = [\n",
-    "    \"AF\",  # Afghanistan\n",
-    "    \"BY\",  # Belarus\n",
-    "    \"CD\",  # Democratic Republic of the Congo\n",
-    "    \"CF\",  # Central African Republic\n",
-    "    \"CN\",  # China\n",
-    "    \"CU\",  # Cuba\n",
-    "    \"ER\",  # Eritrea\n",
-    "    \"ET\",  # Ethiopia\n",
-    "    \"HK\",  # Hong Kong\n",
-    "    \"IR\",  # Iran\n",
-    "    \"KP\",  # North Korea\n",
-    "    \"LY\",  # Libya\n",
-    "    \"ML\",  # Mali\n",
-    "    \"MM\",  # Myanmar\n",
-    "    \"MO\",  # Macau\n",
-    "    \"NI\",  # Nicaragua\n",
-    "    \"RU\",  # Russia\n",
-    "    \"SD\",  # Sudan\n",
-    "    \"SO\",  # Somalia\n",
-    "    \"SS\",  # South Sudan\n",
-    "    \"SY\",  # Syria\n",
-    "    \"VE\",  # Venezuela\n",
-    "    \"YE\",  # Yemen\n",
-    "]"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Data Loading Functions"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def load_population_data():\n",
-    "    \"\"\"\n",
-    "    Load population data for countries and US states.\n",
-    "\n",
-    "    Args:\n",
-    "        verbose: Whether to print progress\n",
-    "\n",
-    "    Returns:\n",
-    "        Dict with country and state_us population dataframes\n",
-    "    \"\"\"\n",
-    "    pop_country_path = (\n",
-    "        Path(DATA_INTERMEDIATE_DIR) / f\"working_age_pop_{YEAR}_country.csv\"\n",
-    "    )\n",
-    "    pop_state_path = (\n",
-    "        Path(DATA_INTERMEDIATE_DIR) / f\"working_age_pop_{YEAR}_us_state.csv\"\n",
-    "    )\n",
-    "\n",
-    "    if not pop_country_path.exists() or not pop_state_path.exists():\n",
-    "        raise FileNotFoundError(\n",
-    "            f\"Population data is required but not found.\\n\"\n",
-    "            f\"  Expected files:\\n\"\n",
-    "            f\"    - {pop_country_path}\\n\"\n",
-    "            f\"    - {pop_state_path}\\n\"\n",
-    "            f\"  Run preprocess_population.py first to generate these files.\"\n",
-    "        )\n",
-    "\n",
-    "    # Use keep_default_na=False to preserve any \"NA\" values as strings\n",
-    "    df_pop_country = pd.read_csv(\n",
-    "        pop_country_path, keep_default_na=False, na_values=[\"\"]\n",
-    "    )\n",
-    "    df_pop_state = pd.read_csv(pop_state_path, keep_default_na=False, na_values=[\"\"])\n",
-    "\n",
-    "    return {\"country\": df_pop_country, \"state_us\": df_pop_state}\n",
-    "\n",
-    "\n",
-    "def load_gdp_data():\n",
-    "    \"\"\"\n",
-    "    Load GDP data for countries and US states.\n",
-    "\n",
-    "    Returns:\n",
-    "        Dict with country and state_us GDP dataframes\n",
-    "    \"\"\"\n",
-    "    gdp_country_path = Path(DATA_INTERMEDIATE_DIR) / f\"gdp_{YEAR}_country.csv\"\n",
-    "    gdp_state_path = Path(DATA_INTERMEDIATE_DIR) / f\"gdp_{YEAR}_us_state.csv\"\n",
-    "\n",
-    "    if not gdp_country_path.exists() or not gdp_state_path.exists():\n",
-    "        raise FileNotFoundError(\n",
-    "            f\"GDP data is required but not found.\\n\"\n",
-    "            f\"  Expected files:\\n\"\n",
-    "            f\"    - {gdp_country_path}\\n\"\n",
-    "            f\"    - {gdp_state_path}\\n\"\n",
-    "            f\"  Run preprocess_gdp.py first to generate these files.\"\n",
-    "        )\n",
-    "\n",
-    "    # Use keep_default_na=False to preserve any \"NA\" values as strings\n",
-    "    df_gdp_country = pd.read_csv(\n",
-    "        gdp_country_path, keep_default_na=False, na_values=[\"\"]\n",
-    "    )\n",
-    "    df_gdp_state = pd.read_csv(gdp_state_path, keep_default_na=False, na_values=[\"\"])\n",
-    "\n",
-    "    return {\"country\": df_gdp_country, \"state_us\": df_gdp_state}\n",
-    "\n",
-    "\n",
-    "def load_task_data():\n",
-    "    \"\"\"\n",
-    "    Load O*NET task statements with SOC codes.\n",
-    "\n",
-    "    Returns:\n",
-    "        DataFrame with O*NET tasks and SOC major groups\n",
-    "    \"\"\"\n",
-    "    onet_path = Path(DATA_INTERMEDIATE_DIR) / \"onet_task_statements.csv\"\n",
-    "\n",
-    "    if not onet_path.exists():\n",
-    "        raise FileNotFoundError(\n",
-    "            f\"O*NET data is required but not found.\\n\"\n",
-    "            f\"  Expected file:\\n\"\n",
-    "            f\"    - {onet_path}\\n\"\n",
-    "            f\"  Run preprocess_onet.py first to generate this file.\"\n",
-    "        )\n",
-    "\n",
-    "    # Use keep_default_na=False to preserve any \"NA\" values as strings\n",
-    "    df_onet = pd.read_csv(onet_path, keep_default_na=False, na_values=[\"\"])\n",
-    "\n",
-    "    # Normalize task names for matching with Clio data\n",
-    "    df_onet[\"task_normalized\"] = df_onet[\"Task\"].str.lower().str.strip()\n",
-    "\n",
-    "    return df_onet\n",
-    "\n",
-    "\n",
-    "def load_soc_data():\n",
-    "    \"\"\"\n",
-    "    Load SOC structure data for occupation names.\n",
-    "\n",
-    "    Returns:\n",
-    "        DataFrame with SOC major groups and their titles\n",
-    "    \"\"\"\n",
-    "    soc_path = Path(DATA_INTERMEDIATE_DIR) / \"soc_structure.csv\"\n",
-    "\n",
-    "    if not soc_path.exists():\n",
-    "        raise FileNotFoundError(\n",
-    "            f\"SOC structure data is required but not found.\\n\"\n",
-    "            f\"  Expected file:\\n\"\n",
-    "            f\"    - {soc_path}\\n\"\n",
-    "            f\"  Run preprocess_onet.py first to generate this file.\"\n",
-    "        )\n",
-    "\n",
-    "    # Use keep_default_na=False to preserve any \"NA\" values as strings\n",
-    "    df_soc = pd.read_csv(soc_path, keep_default_na=False, na_values=[\"\"])\n",
-    "\n",
-    "    # Get unique major groups with their titles for SOC name mapping\n",
-    "    df_major_groups = df_soc[df_soc[\"soc_major_group\"].notna()][\n",
-    "        [\"soc_major_group\", \"SOC or O*NET-SOC 2019 Title\"]\n",
-    "    ].drop_duplicates(subset=[\"soc_major_group\"])\n",
-    "\n",
-    "    return df_major_groups\n",
-    "\n",
-    "\n",
-    "def load_external_data():\n",
-    "    \"\"\"\n",
-    "    Load all external data sources from local files.\n",
-    "\n",
-    "    Returns:\n",
-    "        Dict with population, gdp, task_statements, and soc_structure dataframes\n",
-    "    \"\"\"\n",
-    "\n",
-    "    external_data = {}\n",
-    "\n",
-    "    # Load each data source with its specific function\n",
-    "    external_data[\"population\"] = load_population_data()\n",
-    "    external_data[\"gdp\"] = load_gdp_data()\n",
-    "    external_data[\"task_statements\"] = load_task_data()\n",
-    "    external_data[\"soc_structure\"] = load_soc_data()\n",
-    "\n",
-    "    return external_data"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Filtering Functions"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def get_filtered_geographies(df):\n",
-    "    \"\"\"\n",
-    "    Get lists of countries and states that meet MIN_OBSERVATIONS thresholds.\n",
-    "\n",
-    "    This function does NOT filter the dataframe - it only identifies which\n",
-    "    geographies meet the thresholds. The full dataframe is preserved\n",
-    "    so we can still report statistics for all geographies.\n",
-    "\n",
-    "    Args:\n",
-    "        df: Input dataframe\n",
-    "\n",
-    "    Returns:\n",
-    "        Tuple of (filtered_countries list, filtered_states list)\n",
-    "    \"\"\"\n",
-    "    # Get country usage counts\n",
-    "    country_usage = df[\n",
-    "        (df[\"facet\"] == \"country\") & (df[\"variable\"] == \"usage_count\")\n",
-    "    ].set_index(\"geo_id\")[\"value\"]\n",
-    "\n",
-    "    # Get state usage counts\n",
-    "    state_usage = df[\n",
-    "        (df[\"facet\"] == \"state_us\") & (df[\"variable\"] == \"usage_count\")\n",
-    "    ].set_index(\"geo_id\")[\"value\"]\n",
-    "\n",
-    "    # Get countries that meet MIN_OBSERVATIONS threshold\n",
-    "    filtered_countries = country_usage[\n",
-    "        country_usage >= MIN_OBSERVATIONS_COUNTRY\n",
-    "    ].index.tolist()\n",
-    "\n",
-    "    # Get states that meet MIN_OBSERVATIONS threshold\n",
-    "    filtered_states = state_usage[\n",
-    "        state_usage >= MIN_OBSERVATIONS_US_STATE\n",
-    "    ].index.tolist()\n",
-    "\n",
-    "    return filtered_countries, filtered_states"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Data Merge Functions"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def merge_population_data(df, population_data):\n",
-    "    \"\"\"\n",
-    "    Merge population data in long format.\n",
-    "\n",
-    "    This function:\n",
-    "    1. Adds countries/states that have population but no usage (with 0 usage values)\n",
-    "    2. Adds population as new rows with variable=\"working_age_pop\"\n",
-    "\n",
-    "    Args:\n",
-    "        df: Input dataframe in long format\n",
-    "        population_data: Dict with country and state_us population dataframes\n",
-    "\n",
-    "    Returns:\n",
-    "        Dataframe with all geographies and population added as rows\n",
-    "    \"\"\"\n",
-    "    df_result = df.copy()\n",
-    "    new_rows = []\n",
-    "\n",
-    "    # Get unique date/platform combinations to replicate for new data\n",
-    "    date_platform_combos = df_result[\n",
-    "        [\"date_start\", \"date_end\", \"platform_and_product\"]\n",
-    "    ].drop_duplicates()\n",
-    "\n",
-    "    # Process countries\n",
-    "    if \"country\" in population_data and not population_data[\"country\"].empty:\n",
-    "        pop_country = population_data[\"country\"]\n",
-    "\n",
-    "        # Get existing countries in our data\n",
-    "        existing_countries = df_result[\n",
-    "            (df_result[\"geography\"] == \"country\")\n",
-    "            & (df_result[\"variable\"] == \"usage_count\")\n",
-    "        ][\"geo_id\"].unique()\n",
-    "\n",
-    "        # Add missing countries with 0 usage (excluding excluded countries)\n",
-    "        missing_countries = (\n",
-    "            set(pop_country[\"country_code\"])\n",
-    "            - set(existing_countries)\n",
-    "            - set(EXCLUDED_COUNTRIES)\n",
-    "        )\n",
-    "\n",
-    "        for _, combo in date_platform_combos.iterrows():\n",
-    "            # Add missing countries with 0 usage (both count and percentage)\n",
-    "            for country_code in missing_countries:\n",
-    "                # Add usage_count = 0\n",
-    "                new_rows.append(\n",
-    "                    {\n",
-    "                        \"geo_id\": country_code,\n",
-    "                        \"geography\": \"country\",\n",
-    "                        \"date_start\": combo[\"date_start\"],\n",
-    "                        \"date_end\": combo[\"date_end\"],\n",
-    "                        \"platform_and_product\": combo[\"platform_and_product\"],\n",
-    "                        \"facet\": \"country\",\n",
-    "                        \"level\": 0,\n",
-    "                        \"variable\": \"usage_count\",\n",
-    "                        \"cluster_name\": \"\",\n",
-    "                        \"value\": 0.0,\n",
-    "                    }\n",
-    "                )\n",
-    "                # Add usage_pct = 0\n",
-    "                new_rows.append(\n",
-    "                    {\n",
-    "                        \"geo_id\": country_code,\n",
-    "                        \"geography\": \"country\",\n",
-    "                        \"date_start\": combo[\"date_start\"],\n",
-    "                        \"date_end\": combo[\"date_end\"],\n",
-    "                        \"platform_and_product\": combo[\"platform_and_product\"],\n",
-    "                        \"facet\": \"country\",\n",
-    "                        \"level\": 0,\n",
-    "                        \"variable\": \"usage_pct\",\n",
-    "                        \"cluster_name\": \"\",\n",
-    "                        \"value\": 0.0,\n",
-    "                    }\n",
-    "                )\n",
-    "\n",
-    "            # Add population data for all countries (that are not excluded)\n",
-    "            for _, pop_row in pop_country.iterrows():\n",
-    "                new_rows.append(\n",
-    "                    {\n",
-    "                        \"geo_id\": pop_row[\"country_code\"],\n",
-    "                        \"geography\": \"country\",\n",
-    "                        \"date_start\": combo[\"date_start\"],\n",
-    "                        \"date_end\": combo[\"date_end\"],\n",
-    "                        \"platform_and_product\": combo[\"platform_and_product\"],\n",
-    "                        \"facet\": \"country\",\n",
-    "                        \"level\": 0,\n",
-    "                        \"variable\": \"working_age_pop\",\n",
-    "                        \"cluster_name\": \"\",\n",
-    "                        \"value\": float(pop_row[\"working_age_pop\"]),\n",
-    "                    }\n",
-    "                )\n",
-    "\n",
-    "    # Process US states\n",
-    "    if \"state_us\" in population_data and not population_data[\"state_us\"].empty:\n",
-    "        pop_state = population_data[\"state_us\"]\n",
-    "\n",
-    "        # Get existing states in our data\n",
-    "        existing_states = df_result[\n",
-    "            (df_result[\"geography\"] == \"state_us\")\n",
-    "            & (df_result[\"variable\"] == \"usage_count\")\n",
-    "        ][\"geo_id\"].unique()\n",
-    "\n",
-    "        # Add missing states with 0 usage\n",
-    "        missing_states = set(pop_state[\"state_code\"]) - set(existing_states)\n",
-    "\n",
-    "        for _, combo in date_platform_combos.iterrows():\n",
-    "            # Add missing states with 0 usage (both count and percentage)\n",
-    "            for state_code in missing_states:\n",
-    "                # Add usage_count = 0\n",
-    "                new_rows.append(\n",
-    "                    {\n",
-    "                        \"geo_id\": state_code,\n",
-    "                        \"geography\": \"state_us\",\n",
-    "                        \"date_start\": combo[\"date_start\"],\n",
-    "                        \"date_end\": combo[\"date_end\"],\n",
-    "                        \"platform_and_product\": combo[\"platform_and_product\"],\n",
-    "                        \"facet\": \"state_us\",\n",
-    "                        \"level\": 0,\n",
-    "                        \"variable\": \"usage_count\",\n",
-    "                        \"cluster_name\": \"\",\n",
-    "                        \"value\": 0.0,\n",
-    "                    }\n",
-    "                )\n",
-    "                # Add usage_pct = 0\n",
-    "                new_rows.append(\n",
-    "                    {\n",
-    "                        \"geo_id\": state_code,\n",
-    "                        \"geography\": \"state_us\",\n",
-    "                        \"date_start\": combo[\"date_start\"],\n",
-    "                        \"date_end\": combo[\"date_end\"],\n",
-    "                        \"platform_and_product\": combo[\"platform_and_product\"],\n",
-    "                        \"facet\": \"state_us\",\n",
-    "                        \"level\": 0,\n",
-    "                        \"variable\": \"usage_pct\",\n",
-    "                        \"cluster_name\": \"\",\n",
-    "                        \"value\": 0.0,\n",
-    "                    }\n",
-    "                )\n",
-    "\n",
-    "            # Add population data for all states\n",
-    "            for _, pop_row in pop_state.iterrows():\n",
-    "                new_rows.append(\n",
-    "                    {\n",
-    "                        \"geo_id\": pop_row[\"state_code\"],\n",
-    "                        \"geography\": \"state_us\",\n",
-    "                        \"date_start\": combo[\"date_start\"],\n",
-    "                        \"date_end\": combo[\"date_end\"],\n",
-    "                        \"platform_and_product\": combo[\"platform_and_product\"],\n",
-    "                        \"facet\": \"state_us\",\n",
-    "                        \"level\": 0,\n",
-    "                        \"variable\": \"working_age_pop\",\n",
-    "                        \"cluster_name\": \"\",\n",
-    "                        \"value\": float(pop_row[\"working_age_pop\"]),\n",
-    "                    }\n",
-    "                )\n",
-    "\n",
-    "    # Add all new rows to the dataframe\n",
-    "    if new_rows:\n",
-    "        df_new = pd.DataFrame(new_rows)\n",
-    "        df_result = pd.concat([df_result, df_new], ignore_index=True)\n",
-    "\n",
-    "    return df_result\n",
-    "\n",
-    "\n",
-    "def merge_gdp_data(df, gdp_data, population_data):\n",
-    "    \"\"\"\n",
-    "    Merge GDP data and calculate GDP per working age capita.\n",
-    "\n",
-    "    Since we have total GDP in actual dollars, we divide by population to get per capita.\n",
-    "\n",
-    "    Args:\n",
-    "        df: Input dataframe in long format\n",
-    "        gdp_data: Dict with country and state_us GDP dataframes (total GDP in dollars)\n",
-    "        population_data: Dict with country and state_us population dataframes\n",
-    "\n",
-    "    Returns:\n",
-    "        Dataframe with GDP per capita data added as rows\n",
-    "    \"\"\"\n",
-    "    df_result = df.copy()\n",
-    "    new_rows = []\n",
-    "\n",
-    "    # Get unique date/platform combinations\n",
-    "    date_platform_combos = df_result[\n",
-    "        [\"date_start\", \"date_end\", \"platform_and_product\"]\n",
-    "    ].drop_duplicates()\n",
-    "\n",
-    "    # Process country GDP\n",
-    "    if \"country\" in gdp_data and \"country\" in population_data:\n",
-    "        gdp_country = gdp_data[\"country\"]\n",
-    "        pop_country = population_data[\"country\"]\n",
-    "\n",
-    "        # Merge GDP with population to calculate per capita\n",
-    "        gdp_pop = gdp_country.merge(pop_country, on=\"iso_alpha_3\", how=\"inner\")\n",
-    "\n",
-    "        # Calculate GDP per working age capita\n",
-    "        gdp_pop[\"gdp_per_working_age_capita\"] = (\n",
-    "            gdp_pop[\"gdp_total\"] / gdp_pop[\"working_age_pop\"]\n",
-    "        )\n",
-    "\n",
-    "        for _, combo in date_platform_combos.iterrows():\n",
-    "            for _, gdp_row in gdp_pop.iterrows():\n",
-    "                new_rows.append(\n",
-    "                    {\n",
-    "                        \"geo_id\": gdp_row[\"country_code\"],  # Use 2-letter code\n",
-    "                        \"geography\": \"country\",\n",
-    "                        \"date_start\": combo[\"date_start\"],\n",
-    "                        \"date_end\": combo[\"date_end\"],\n",
-    "                        \"platform_and_product\": combo[\"platform_and_product\"],\n",
-    "                        \"facet\": \"country\",\n",
-    "                        \"level\": 0,\n",
-    "                        \"variable\": \"gdp_per_working_age_capita\",\n",
-    "                        \"cluster_name\": \"\",\n",
-    "                        \"value\": float(gdp_row[\"gdp_per_working_age_capita\"]),\n",
-    "                    }\n",
-    "                )\n",
-    "\n",
-    "    # Process state GDP\n",
-    "    if \"state_us\" in gdp_data and \"state_us\" in population_data:\n",
-    "        gdp_state = gdp_data[\"state_us\"]\n",
-    "        pop_state = population_data[\"state_us\"]\n",
-    "\n",
-    "        # Merge GDP with population\n",
-    "        # Column names from preprocess_gdp.py: state_code, gdp_total (in actual dollars)\n",
-    "        gdp_pop = gdp_state.merge(pop_state, on=\"state_code\", how=\"inner\")\n",
-    "\n",
-    "        # Calculate GDP per working age capita\n",
-    "        gdp_pop[\"gdp_per_working_age_capita\"] = (\n",
-    "            gdp_pop[\"gdp_total\"] / gdp_pop[\"working_age_pop\"]\n",
-    "        )\n",
-    "\n",
-    "        for _, combo in date_platform_combos.iterrows():\n",
-    "            for _, gdp_row in gdp_pop.iterrows():\n",
-    "                new_rows.append(\n",
-    "                    {\n",
-    "                        \"geo_id\": gdp_row[\"state_code\"],\n",
-    "                        \"geography\": \"state_us\",\n",
-    "                        \"date_start\": combo[\"date_start\"],\n",
-    "                        \"date_end\": combo[\"date_end\"],\n",
-    "                        \"platform_and_product\": combo[\"platform_and_product\"],\n",
-    "                        \"facet\": \"state_us\",\n",
-    "                        \"level\": 0,\n",
-    "                        \"variable\": \"gdp_per_working_age_capita\",\n",
-    "                        \"cluster_name\": \"\",\n",
-    "                        \"value\": float(gdp_row[\"gdp_per_working_age_capita\"]),\n",
-    "                    }\n",
-    "                )\n",
-    "\n",
-    "    # Add all new rows to the dataframe\n",
-    "    if new_rows:\n",
-    "        df_new = pd.DataFrame(new_rows)\n",
-    "        df_result = pd.concat([df_result, df_new], ignore_index=True)\n",
-    "\n",
-    "    return df_result\n",
-    "\n",
-    "\n",
-    "def calculate_soc_distribution(\n",
-    "    df, df_onet, df_soc_structure, filtered_countries=None, filtered_states=None\n",
-    "):\n",
-    "    \"\"\"\n",
-    "    Calculate SOC occupation distribution from O*NET task usage.\n",
-    "\n",
-    "    This uses the following approach:\n",
-    "    1. Map tasks directly to SOC major groups (with minimal double counting)\n",
-    "    2. Combine \"none\" and \"not_classified\" tasks into a single \"not_classified\" SOC group\n",
-    "    3. Sum percentages by SOC group\n",
-    "    4. Normalize to 100% for each geography\n",
-    "    5. Calculate for countries, US states, and global that meet MIN_OBSERVATIONS threshold\n",
-    "\n",
-    "    NOTE: For US states, only ~449 O*NET tasks have state-level data (those with sufficient\n",
-    "    observations), but these tasks still map to SOC groups the same way as for countries.\n",
-    "\n",
-    "    Args:\n",
-    "        df: DataFrame with O*NET task percentages\n",
-    "        df_onet: O*NET task data with SOC codes\n",
-    "        df_soc_structure: SOC structure with major group names\n",
-    "        filtered_countries: List of countries that meet MIN_OBSERVATIONS (optional)\n",
-    "        filtered_states: List of states that meet MIN_OBSERVATIONS (optional)\n",
-    "\n",
-    "    Returns:\n",
-    "        DataFrame with SOC distribution rows added\n",
-    "    \"\"\"\n",
-    "    df_result = df.copy()\n",
-    "    soc_rows = []\n",
-    "\n",
-    "    # Get all O*NET task percentage data (including not_classified and \"none\")\n",
-    "    df_task_pct_all = df_result[\n",
-    "        (df_result[\"facet\"] == \"onet_task\") & (df_result[\"variable\"] == \"onet_task_pct\")\n",
-    "    ].copy()\n",
-    "\n",
-    "    if df_task_pct_all.empty:\n",
-    "        return df_result\n",
-    "\n",
-    "    # Build masks for each geography type\n",
-    "    # Always include global\n",
-    "    global_mask = df_task_pct_all[\"geography\"] == \"global\"\n",
-    "\n",
-    "    # Apply filtering for countries\n",
-    "    if filtered_countries is not None:\n",
-    "        country_mask = (df_task_pct_all[\"geography\"] == \"country\") & (\n",
-    "            df_task_pct_all[\"geo_id\"].isin(filtered_countries)\n",
-    "        )\n",
-    "    else:\n",
-    "        # If no filter, keep all countries\n",
-    "        country_mask = df_task_pct_all[\"geography\"] == \"country\"\n",
-    "\n",
-    "    # Apply filtering for states\n",
-    "    if filtered_states is not None:\n",
-    "        state_mask = (df_task_pct_all[\"geography\"] == \"state_us\") & (\n",
-    "            df_task_pct_all[\"geo_id\"].isin(filtered_states)\n",
-    "        )\n",
-    "    else:\n",
-    "        # If no filter, keep all states\n",
-    "        state_mask = df_task_pct_all[\"geography\"] == \"state_us\"\n",
-    "\n",
-    "    # Combine masks to keep relevant geographies\n",
-    "    combined_mask = global_mask | country_mask | state_mask\n",
-    "    df_task_pct_all = df_task_pct_all[combined_mask].copy()\n",
-    "\n",
-    "    if df_task_pct_all.empty:\n",
-    "        return df_result\n",
-    "\n",
-    "    # Separate not_classified and none tasks from real O*NET tasks\n",
-    "    df_not_classified = df_task_pct_all[\n",
-    "        (df_task_pct_all[\"cluster_name\"].str.contains(\"not_classified\", na=False))\n",
-    "        | (df_task_pct_all[\"cluster_name\"] == \"none\")\n",
-    "    ].copy()\n",
-    "\n",
-    "    # Get real O*NET tasks (excluding not_classified and none)\n",
-    "    df_task_pct = df_task_pct_all[\n",
-    "        (~df_task_pct_all[\"cluster_name\"].str.contains(\"not_classified\", na=False))\n",
-    "        & (df_task_pct_all[\"cluster_name\"] != \"none\")\n",
-    "    ].copy()\n",
-    "\n",
-    "    # Normalize task names for matching\n",
-    "    df_task_pct[\"task_normalized\"] = df_task_pct[\"cluster_name\"].str.lower().str.strip()\n",
-    "\n",
-    "    # Get unique task-SOC pairs from O*NET data\n",
-    "    # This keeps tasks that map to multiple SOC groups (different rows)\n",
-    "    df_task_soc = df_onet[[\"task_normalized\", \"soc_major_group\"]].drop_duplicates()\n",
-    "\n",
-    "    # Merge tasks with their SOC codes\n",
-    "    df_with_soc = df_task_pct.merge(df_task_soc, on=\"task_normalized\", how=\"left\")\n",
-    "\n",
-    "    # Check for unmapped tasks and raise error if found (same as for countries)\n",
-    "    unmapped_tasks = df_with_soc[df_with_soc[\"soc_major_group\"].isna()]\n",
-    "    if not unmapped_tasks.empty:\n",
-    "        unmapped_list = unmapped_tasks[\"cluster_name\"].unique()[:10]  # Show first 10\n",
-    "        n_unmapped = len(unmapped_tasks[\"cluster_name\"].unique())\n",
-    "\n",
-    "        # Check which geographies have unmapped tasks\n",
-    "        unmapped_geos = unmapped_tasks[\"geography\"].unique()\n",
-    "\n",
-    "        raise ValueError(\n",
-    "            f\"Found {n_unmapped} O*NET tasks that could not be mapped to SOC codes.\\n\"\n",
-    "            f\"Geographies with unmapped tasks: {unmapped_geos.tolist()}\\n\"\n",
-    "            f\"First 10 unmapped tasks:\\n\"\n",
-    "            + \"\\n\".join(f\"  - {task}\" for task in unmapped_list)\n",
-    "            + f\"\\n\\nThis likely means the O*NET data is out of sync with the Clio task data.\\n\"\n",
-    "            f\"Please verify that preprocess_onet.py has been run with the correct O*NET version.\"\n",
-    "        )\n",
-    "\n",
-    "    # Create SOC name mapping if SOC structure is available\n",
-    "    soc_names = {}\n",
-    "    if not df_soc_structure.empty:\n",
-    "        for _, row in df_soc_structure.iterrows():\n",
-    "            soc_code = row[\"soc_major_group\"]\n",
-    "            title = row[\"SOC or O*NET-SOC 2019 Title\"]\n",
-    "            # Clean up title (remove \"Occupations\" suffix)\n",
-    "            clean_title = title.replace(\" Occupations\", \"\").replace(\" Occupation\", \"\")\n",
-    "            soc_names[soc_code] = clean_title\n",
-    "\n",
-    "    # Group by geography and process each group\n",
-    "    geo_groups = df_with_soc.groupby(\n",
-    "        [\"geo_id\", \"geography\", \"date_start\", \"date_end\", \"platform_and_product\"]\n",
-    "    )\n",
-    "\n",
-    "    # Also group not_classified data by geography\n",
-    "    not_classified_groups = df_not_classified.groupby(\n",
-    "        [\"geo_id\", \"geography\", \"date_start\", \"date_end\", \"platform_and_product\"]\n",
-    "    )\n",
-    "\n",
-    "    # Track statistics\n",
-    "    states_with_soc = set()\n",
-    "    countries_with_soc = set()\n",
-    "\n",
-    "    # Process all geographies\n",
-    "    all_geos = set()\n",
-    "    for (geo_id, geography, date_start, date_end, platform), _ in geo_groups:\n",
-    "        all_geos.add((geo_id, geography, date_start, date_end, platform))\n",
-    "    for (geo_id, geography, date_start, date_end, platform), _ in not_classified_groups:\n",
-    "        all_geos.add((geo_id, geography, date_start, date_end, platform))\n",
-    "\n",
-    "    for geo_id, geography, date_start, date_end, platform in all_geos:\n",
-    "        # Get mapped SOC data for this geography\n",
-    "        try:\n",
-    "            geo_data = geo_groups.get_group(\n",
-    "                (geo_id, geography, date_start, date_end, platform)\n",
-    "            )\n",
-    "            # Sum percentages by SOC major group\n",
-    "            # If a task maps to multiple SOC groups, its percentage is added to each\n",
-    "            soc_totals = geo_data.groupby(\"soc_major_group\")[\"value\"].sum()\n",
-    "        except KeyError:\n",
-    "            # No mapped tasks for this geography\n",
-    "            soc_totals = pd.Series(dtype=float)\n",
-    "\n",
-    "        # Get not_classified/none data for this geography\n",
-    "        try:\n",
-    "            not_classified_data = not_classified_groups.get_group(\n",
-    "                (geo_id, geography, date_start, date_end, platform)\n",
-    "            )\n",
-    "            # Sum all not_classified and none percentages\n",
-    "            not_classified_total = not_classified_data[\"value\"].sum()\n",
-    "        except KeyError:\n",
-    "            # No not_classified/none for this geography\n",
-    "            not_classified_total = 0\n",
-    "\n",
-    "        # Combine and normalize to 100%\n",
-    "        total_pct = soc_totals.sum() + not_classified_total\n",
-    "\n",
-    "        if total_pct > 0:\n",
-    "            # Normalize mapped SOC groups\n",
-    "            if len(soc_totals) > 0:\n",
-    "                soc_normalized = (soc_totals / total_pct) * 100\n",
-    "            else:\n",
-    "                soc_normalized = pd.Series(dtype=float)\n",
-    "\n",
-    "            # Calculate normalized not_classified percentage\n",
-    "            not_classified_normalized = (not_classified_total / total_pct) * 100\n",
-    "\n",
-    "            # Track geographies that have SOC data\n",
-    "            if geography == \"state_us\":\n",
-    "                states_with_soc.add(geo_id)\n",
-    "            elif geography == \"country\":\n",
-    "                countries_with_soc.add(geo_id)\n",
-    "\n",
-    "            # Create rows for each SOC group\n",
-    "            for soc_group, pct_value in soc_normalized.items():\n",
-    "                # Get SOC name if available, otherwise use code\n",
-    "                soc_name = soc_names.get(soc_group, f\"SOC {soc_group}\")\n",
-    "\n",
-    "                soc_row = {\n",
-    "                    \"geo_id\": geo_id,\n",
-    "                    \"geography\": geography,\n",
-    "                    \"date_start\": date_start,\n",
-    "                    \"date_end\": date_end,\n",
-    "                    \"platform_and_product\": platform,\n",
-    "                    \"facet\": \"soc_occupation\",\n",
-    "                    \"level\": 0,\n",
-    "                    \"variable\": \"soc_pct\",\n",
-    "                    \"cluster_name\": soc_name,\n",
-    "                    \"value\": pct_value,\n",
-    "                }\n",
-    "                soc_rows.append(soc_row)\n",
-    "\n",
-    "            # Add not_classified SOC row if there's any not_classified/none percentage\n",
-    "            if not_classified_normalized > 0:\n",
-    "                soc_row = {\n",
-    "                    \"geo_id\": geo_id,\n",
-    "                    \"geography\": geography,\n",
-    "                    \"date_start\": date_start,\n",
-    "                    \"date_end\": date_end,\n",
-    "                    \"platform_and_product\": platform,\n",
-    "                    \"facet\": \"soc_occupation\",\n",
-    "                    \"level\": 0,\n",
-    "                    \"variable\": \"soc_pct\",\n",
-    "                    \"cluster_name\": \"not_classified\",\n",
-    "                    \"value\": not_classified_normalized,\n",
-    "                }\n",
-    "                soc_rows.append(soc_row)\n",
-    "\n",
-    "    # Print summary\n",
-    "    if countries_with_soc:\n",
-    "        print(\n",
-    "            f\"Calculated SOC distributions for {len(countries_with_soc)} countries + global\"\n",
-    "        )\n",
-    "    if states_with_soc:\n",
-    "        print(f\"Calculated SOC distributions for {len(states_with_soc)} US states\")\n",
-    "\n",
-    "    # Add all SOC rows to result\n",
-    "    if soc_rows:\n",
-    "        df_soc = pd.DataFrame(soc_rows)\n",
-    "        df_result = pd.concat([df_result, df_soc], ignore_index=True)\n",
-    "\n",
-    "    return df_result"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Metric Calculation Functions"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def calculate_per_capita_metrics(df):\n",
-    "    \"\"\"\n",
-    "    Calculate per capita metrics by joining usage and population data.\n",
-    "\n",
-    "    Since data is in long format, this function:\n",
-    "    1. Extracts usage count rows\n",
-    "    2. Extracts population rows\n",
-    "    3. Joins them and calculates per capita\n",
-    "    4. Adds results as new rows\n",
-    "\n",
-    "    Args:\n",
-    "        df: Dataframe in long format with usage and population as rows\n",
-    "\n",
-    "    Returns:\n",
-    "        Dataframe with per capita metrics added as new rows\n",
-    "    \"\"\"\n",
-    "    df_result = df.copy()\n",
-    "\n",
-    "    # Define which metrics should have per capita calculations\n",
-    "    count_metrics = [\"usage_count\"]\n",
-    "\n",
-    "    # Get population data\n",
-    "    df_pop = df_result[df_result[\"variable\"] == \"working_age_pop\"][\n",
-    "        [\n",
-    "            \"geo_id\",\n",
-    "            \"geography\",\n",
-    "            \"date_start\",\n",
-    "            \"date_end\",\n",
-    "            \"platform_and_product\",\n",
-    "            \"value\",\n",
-    "        ]\n",
-    "    ].rename(columns={\"value\": \"population\"})\n",
-    "\n",
-    "    # Calculate per capita for each count metric\n",
-    "    per_capita_rows = []\n",
-    "\n",
-    "    for metric in count_metrics:\n",
-    "        # Get the count data for this metric\n",
-    "        df_metric = df_result[df_result[\"variable\"] == metric].copy()\n",
-    "\n",
-    "        # Join with population data\n",
-    "        df_joined = df_metric.merge(\n",
-    "            df_pop,\n",
-    "            on=[\n",
-    "                \"geo_id\",\n",
-    "                \"geography\",\n",
-    "                \"date_start\",\n",
-    "                \"date_end\",\n",
-    "                \"platform_and_product\",\n",
-    "            ],\n",
-    "            how=\"left\",\n",
-    "        )\n",
-    "\n",
-    "        # Calculate per capita where population exists and is > 0\n",
-    "        df_joined = df_joined[\n",
-    "            df_joined[\"population\"].notna() & (df_joined[\"population\"] > 0)\n",
-    "        ]\n",
-    "\n",
-    "        if not df_joined.empty:\n",
-    "            # Create per capita rows\n",
-    "            for _, row in df_joined.iterrows():\n",
-    "                per_capita_row = {\n",
-    "                    \"geo_id\": row[\"geo_id\"],\n",
-    "                    \"geography\": row[\"geography\"],\n",
-    "                    \"date_start\": row[\"date_start\"],\n",
-    "                    \"date_end\": row[\"date_end\"],\n",
-    "                    \"platform_and_product\": row[\"platform_and_product\"],\n",
-    "                    \"facet\": row[\"facet\"],\n",
-    "                    \"level\": row[\"level\"],\n",
-    "                    \"variable\": metric.replace(\"_count\", \"_per_capita\"),\n",
-    "                    \"cluster_name\": row[\"cluster_name\"],\n",
-    "                    \"value\": row[\"value\"] / row[\"population\"],\n",
-    "                }\n",
-    "                per_capita_rows.append(per_capita_row)\n",
-    "\n",
-    "    # Add all per capita rows to the result\n",
-    "    if per_capita_rows:\n",
-    "        df_per_capita = pd.DataFrame(per_capita_rows)\n",
-    "        df_result = pd.concat([df_result, df_per_capita], ignore_index=True)\n",
-    "\n",
-    "    return df_result\n",
-    "\n",
-    "\n",
-    "def calculate_usage_per_capita_index(df, filtered_countries=None, filtered_states=None):\n",
-    "    \"\"\"\n",
-    "    Calculate usage concentration index: (% of usage) / (% of population).\n",
-    "\n",
-    "    This shows whether a geography has more or less usage than expected based on its population.\n",
-    "    - Index = 1.0: Usage proportional to population\n",
-    "    - Index > 1.0: Over-representation (more usage than expected)\n",
-    "    - Index < 1.0: Under-representation (less usage than expected)\n",
-    "    - Index = 0.0: No usage at all\n",
-    "\n",
-    "    The function calculates the index for all countries/states that have usage data.\n",
-    "    Excluded countries don't have usage data, so they're automatically excluded.\n",
-    "    Countries with zero usage get index=0 naturally from the calculation.\n",
-    "\n",
-    "    Args:\n",
-    "        df: Dataframe with usage and population data\n",
-    "        filtered_countries: List of countries that meet MIN_OBSERVATIONS threshold (used for baseline calculation)\n",
-    "        filtered_states: List of states that meet MIN_OBSERVATIONS threshold (used for baseline calculation)\n",
-    "\n",
-    "    Returns:\n",
-    "        Dataframe with usage concentration index added as new rows\n",
-    "    \"\"\"\n",
-    "    df_result = df.copy()\n",
-    "\n",
-    "    index_rows = []\n",
-    "\n",
-    "    # Process countries\n",
-    "    # Get all countries with usage data (excluded countries won't be here)\n",
-    "    df_usage_country = df_result[\n",
-    "        (df_result[\"geography\"] == \"country\") & (df_result[\"variable\"] == \"usage_count\")\n",
-    "    ].copy()\n",
-    "\n",
-    "    # Get population data for the same countries\n",
-    "    df_pop_country = df_result[\n",
-    "        (df_result[\"geography\"] == \"country\")\n",
-    "        & (df_result[\"variable\"] == \"working_age_pop\")\n",
-    "    ].copy()\n",
-    "\n",
-    "    if not df_usage_country.empty and not df_pop_country.empty:\n",
-    "        # For baseline calculation, use filtered countries if provided, otherwise use all\n",
-    "        if filtered_countries is not None:\n",
-    "            # Calculate totals using only filtered countries for the baseline\n",
-    "            usage_for_baseline = df_usage_country[\n",
-    "                df_usage_country[\"geo_id\"].isin(filtered_countries)\n",
-    "            ]\n",
-    "            pop_for_baseline = df_pop_country[\n",
-    "                df_pop_country[\"geo_id\"].isin(filtered_countries)\n",
-    "            ]\n",
-    "            total_usage = usage_for_baseline[\"value\"].sum()\n",
-    "            total_pop = pop_for_baseline[\"value\"].sum()\n",
-    "        else:\n",
-    "            # Use all countries for baseline\n",
-    "            total_usage = df_usage_country[\"value\"].sum()\n",
-    "            total_pop = df_pop_country[\"value\"].sum()\n",
-    "\n",
-    "        if total_usage > 0 and total_pop > 0:\n",
-    "            # Calculate index for all countries (not just filtered)\n",
-    "            for _, usage_row in df_usage_country.iterrows():\n",
-    "                # Find corresponding population\n",
-    "                pop_value = df_pop_country[\n",
-    "                    df_pop_country[\"geo_id\"] == usage_row[\"geo_id\"]\n",
-    "                ][\"value\"].values\n",
-    "\n",
-    "                if len(pop_value) > 0 and pop_value[0] > 0:\n",
-    "                    # Calculate shares\n",
-    "                    usage_share = (\n",
-    "                        usage_row[\"value\"] / total_usage\n",
-    "                        if usage_row[\"value\"] > 0\n",
-    "                        else 0\n",
-    "                    )\n",
-    "                    pop_share = pop_value[0] / total_pop\n",
-    "\n",
-    "                    # Calculate index (will be 0 if usage is 0)\n",
-    "                    index_value = usage_share / pop_share if pop_share > 0 else 0\n",
-    "\n",
-    "                    index_row = {\n",
-    "                        \"geo_id\": usage_row[\"geo_id\"],\n",
-    "                        \"geography\": usage_row[\"geography\"],\n",
-    "                        \"date_start\": usage_row[\"date_start\"],\n",
-    "                        \"date_end\": usage_row[\"date_end\"],\n",
-    "                        \"platform_and_product\": usage_row[\"platform_and_product\"],\n",
-    "                        \"facet\": usage_row[\"facet\"],\n",
-    "                        \"level\": usage_row[\"level\"],\n",
-    "                        \"variable\": \"usage_per_capita_index\",\n",
-    "                        \"cluster_name\": usage_row[\"cluster_name\"],\n",
-    "                        \"value\": index_value,\n",
-    "                    }\n",
-    "                    index_rows.append(index_row)\n",
-    "\n",
-    "    # Process states\n",
-    "    # Get all states with usage data\n",
-    "    df_usage_state = df_result[\n",
-    "        (df_result[\"geography\"] == \"state_us\")\n",
-    "        & (df_result[\"variable\"] == \"usage_count\")\n",
-    "    ].copy()\n",
-    "\n",
-    "    # Get population data for the same states\n",
-    "    df_pop_state = df_result[\n",
-    "        (df_result[\"geography\"] == \"state_us\")\n",
-    "        & (df_result[\"variable\"] == \"working_age_pop\")\n",
-    "    ].copy()\n",
-    "\n",
-    "    if not df_usage_state.empty and not df_pop_state.empty:\n",
-    "        # For baseline calculation, use filtered states if provided, otherwise use all\n",
-    "        if filtered_states is not None:\n",
-    "            # Calculate totals using only filtered states for the baseline\n",
-    "            usage_for_baseline = df_usage_state[\n",
-    "                df_usage_state[\"geo_id\"].isin(filtered_states)\n",
-    "            ]\n",
-    "            pop_for_baseline = df_pop_state[\n",
-    "                df_pop_state[\"geo_id\"].isin(filtered_states)\n",
-    "            ]\n",
-    "            total_usage = usage_for_baseline[\"value\"].sum()\n",
-    "            total_pop = pop_for_baseline[\"value\"].sum()\n",
-    "        else:\n",
-    "            # Use all states for baseline\n",
-    "            total_usage = df_usage_state[\"value\"].sum()\n",
-    "            total_pop = df_pop_state[\"value\"].sum()\n",
-    "\n",
-    "        if total_usage > 0 and total_pop > 0:\n",
-    "            # Calculate index for all states (not just filtered)\n",
-    "            for _, usage_row in df_usage_state.iterrows():\n",
-    "                # Find corresponding population\n",
-    "                pop_value = df_pop_state[df_pop_state[\"geo_id\"] == usage_row[\"geo_id\"]][\n",
-    "                    \"value\"\n",
-    "                ].values\n",
-    "\n",
-    "                if len(pop_value) > 0 and pop_value[0] > 0:\n",
-    "                    # Calculate shares\n",
-    "                    usage_share = (\n",
-    "                        usage_row[\"value\"] / total_usage\n",
-    "                        if usage_row[\"value\"] > 0\n",
-    "                        else 0\n",
-    "                    )\n",
-    "                    pop_share = pop_value[0] / total_pop\n",
-    "\n",
-    "                    # Calculate index (will be 0 if usage is 0)\n",
-    "                    index_value = usage_share / pop_share if pop_share > 0 else 0\n",
-    "\n",
-    "                    index_row = {\n",
-    "                        \"geo_id\": usage_row[\"geo_id\"],\n",
-    "                        \"geography\": usage_row[\"geography\"],\n",
-    "                        \"date_start\": usage_row[\"date_start\"],\n",
-    "                        \"date_end\": usage_row[\"date_end\"],\n",
-    "                        \"platform_and_product\": usage_row[\"platform_and_product\"],\n",
-    "                        \"facet\": usage_row[\"facet\"],\n",
-    "                        \"level\": usage_row[\"level\"],\n",
-    "                        \"variable\": \"usage_per_capita_index\",\n",
-    "                        \"cluster_name\": usage_row[\"cluster_name\"],\n",
-    "                        \"value\": index_value,\n",
-    "                    }\n",
-    "                    index_rows.append(index_row)\n",
-    "\n",
-    "    # Add all index rows to result\n",
-    "    if index_rows:\n",
-    "        df_index = pd.DataFrame(index_rows)\n",
-    "        df_result = pd.concat([df_result, df_index], ignore_index=True)\n",
-    "\n",
-    "    return df_result\n",
-    "\n",
-    "\n",
-    "def calculate_category_percentage_index(\n",
-    "    df, filtered_countries=None, filtered_states=None\n",
-    "):\n",
-    "    \"\"\"\n",
-    "    Calculate category percentage index for facet specialization.\n",
-    "\n",
-    "    For countries: Compare to global percentage for that cluster\n",
-    "    For US states: Compare to US country percentage for that cluster\n",
-    "\n",
-    "    Only calculates for countries/states that meet MIN_OBSERVATIONS.\n",
-    "    Excludes \"not_classified\" and \"none\" categories as these are catch-alls.\n",
-    "\n",
-    "    Args:\n",
-    "        df: Dataframe with percentage metrics as rows\n",
-    "        filtered_countries: List of countries that meet MIN_OBSERVATIONS threshold\n",
-    "        filtered_states: List of states that meet MIN_OBSERVATIONS threshold\n",
-    "\n",
-    "    Returns:\n",
-    "        Dataframe with category percentage index added as new rows (only for filtered geographies)\n",
-    "    \"\"\"\n",
-    "    df_result = df.copy()\n",
-    "\n",
-    "    # Process percentage metrics for content facets\n",
-    "    pct_vars = [\"onet_task_pct\", \"collaboration_pct\", \"request_pct\"]\n",
-    "\n",
-    "    index_rows = []\n",
-    "\n",
-    "    for pct_var in pct_vars:\n",
-    "        # Get the base facet name\n",
-    "        facet_name = pct_var.replace(\"_pct\", \"\")\n",
-    "\n",
-    "        # Get percentage data for this variable\n",
-    "        df_pct = df_result[\n",
-    "            (df_result[\"variable\"] == pct_var) & (df_result[\"facet\"] == facet_name)\n",
-    "        ].copy()\n",
-    "\n",
-    "        # Exclude not_classified and none categories from index calculation\n",
-    "        # These are catch-all/no-pattern categories that don't provide meaningful comparisons\n",
-    "        df_pct = df_pct[~df_pct[\"cluster_name\"].isin([\"not_classified\", \"none\"])]\n",
-    "\n",
-    "        if not df_pct.empty and \"cluster_name\" in df_pct.columns:\n",
-    "            # Check if this facet has levels (like request)\n",
-    "            has_levels = df_pct[\"level\"].notna().any() and (df_pct[\"level\"] != 0).any()\n",
-    "\n",
-    "            if has_levels:\n",
-    "                # Process each level separately\n",
-    "                levels = df_pct[\"level\"].dropna().unique()\n",
-    "\n",
-    "                for level in levels:\n",
-    "                    df_level = df_pct[df_pct[\"level\"] == level].copy()\n",
-    "\n",
-    "                    # Get global baselines for this level\n",
-    "                    global_baselines = (\n",
-    "                        df_level[\n",
-    "                            (df_level[\"geography\"] == \"global\")\n",
-    "                            & (df_level[\"geo_id\"] == \"GLOBAL\")\n",
-    "                        ]\n",
-    "                        .set_index(\"cluster_name\")[\"value\"]\n",
-    "                        .to_dict()\n",
-    "                    )\n",
-    "\n",
-    "                    # Get US baselines for this level\n",
-    "                    us_baselines = (\n",
-    "                        df_level[\n",
-    "                            (df_level[\"geography\"] == \"country\")\n",
-    "                            & (df_level[\"geo_id\"] == \"US\")\n",
-    "                        ]\n",
-    "                        .set_index(\"cluster_name\")[\"value\"]\n",
-    "                        .to_dict()\n",
-    "                    )\n",
-    "\n",
-    "                    # Process countries for this level\n",
-    "                    if filtered_countries is not None and global_baselines:\n",
-    "                        df_countries = df_level[\n",
-    "                            (df_level[\"geography\"] == \"country\")\n",
-    "                            & (df_level[\"geo_id\"].isin(filtered_countries))\n",
-    "                        ].copy()\n",
-    "\n",
-    "                        for _, row in df_countries.iterrows():\n",
-    "                            baseline = global_baselines.get(row[\"cluster_name\"])\n",
-    "\n",
-    "                            if baseline and baseline > 0:\n",
-    "                                index_row = {\n",
-    "                                    \"geo_id\": row[\"geo_id\"],\n",
-    "                                    \"geography\": row[\"geography\"],\n",
-    "                                    \"date_start\": row[\"date_start\"],\n",
-    "                                    \"date_end\": row[\"date_end\"],\n",
-    "                                    \"platform_and_product\": row[\"platform_and_product\"],\n",
-    "                                    \"facet\": row[\"facet\"],\n",
-    "                                    \"level\": row[\"level\"],\n",
-    "                                    \"variable\": f\"{facet_name}_pct_index\",\n",
-    "                                    \"cluster_name\": row[\"cluster_name\"],\n",
-    "                                    \"value\": row[\"value\"] / baseline,\n",
-    "                                }\n",
-    "                                index_rows.append(index_row)\n",
-    "\n",
-    "                    # Process states for this level\n",
-    "                    if filtered_states is not None and us_baselines:\n",
-    "                        df_states = df_level[\n",
-    "                            (df_level[\"geography\"] == \"state_us\")\n",
-    "                            & (df_level[\"geo_id\"].isin(filtered_states))\n",
-    "                        ].copy()\n",
-    "\n",
-    "                        for _, row in df_states.iterrows():\n",
-    "                            baseline = us_baselines.get(row[\"cluster_name\"])\n",
-    "\n",
-    "                            if baseline and baseline > 0:\n",
-    "                                index_row = {\n",
-    "                                    \"geo_id\": row[\"geo_id\"],\n",
-    "                                    \"geography\": row[\"geography\"],\n",
-    "                                    \"date_start\": row[\"date_start\"],\n",
-    "                                    \"date_end\": row[\"date_end\"],\n",
-    "                                    \"platform_and_product\": row[\"platform_and_product\"],\n",
-    "                                    \"facet\": row[\"facet\"],\n",
-    "                                    \"level\": row[\"level\"],\n",
-    "                                    \"variable\": f\"{facet_name}_pct_index\",\n",
-    "                                    \"cluster_name\": row[\"cluster_name\"],\n",
-    "                                    \"value\": row[\"value\"] / baseline,\n",
-    "                                }\n",
-    "                                index_rows.append(index_row)\n",
-    "            else:\n",
-    "                # No levels (onet_task, collaboration)\n",
-    "                # Get global baselines\n",
-    "                global_baselines = (\n",
-    "                    df_pct[\n",
-    "                        (df_pct[\"geography\"] == \"global\")\n",
-    "                        & (df_pct[\"geo_id\"] == \"GLOBAL\")\n",
-    "                    ]\n",
-    "                    .set_index(\"cluster_name\")[\"value\"]\n",
-    "                    .to_dict()\n",
-    "                )\n",
-    "\n",
-    "                # Get US baselines\n",
-    "                us_baselines = (\n",
-    "                    df_pct[\n",
-    "                        (df_pct[\"geography\"] == \"country\") & (df_pct[\"geo_id\"] == \"US\")\n",
-    "                    ]\n",
-    "                    .set_index(\"cluster_name\")[\"value\"]\n",
-    "                    .to_dict()\n",
-    "                )\n",
-    "\n",
-    "                # Process countries\n",
-    "                if filtered_countries is not None and global_baselines:\n",
-    "                    df_countries = df_pct[\n",
-    "                        (df_pct[\"geography\"] == \"country\")\n",
-    "                        & (df_pct[\"geo_id\"].isin(filtered_countries))\n",
-    "                    ].copy()\n",
-    "\n",
-    "                    for _, row in df_countries.iterrows():\n",
-    "                        baseline = global_baselines.get(row[\"cluster_name\"])\n",
-    "\n",
-    "                        if baseline and baseline > 0:\n",
-    "                            index_row = {\n",
-    "                                \"geo_id\": row[\"geo_id\"],\n",
-    "                                \"geography\": row[\"geography\"],\n",
-    "                                \"date_start\": row[\"date_start\"],\n",
-    "                                \"date_end\": row[\"date_end\"],\n",
-    "                                \"platform_and_product\": row[\"platform_and_product\"],\n",
-    "                                \"facet\": row[\"facet\"],\n",
-    "                                \"level\": row[\"level\"],\n",
-    "                                \"variable\": f\"{facet_name}_pct_index\",\n",
-    "                                \"cluster_name\": row[\"cluster_name\"],\n",
-    "                                \"value\": row[\"value\"] / baseline,\n",
-    "                            }\n",
-    "                            index_rows.append(index_row)\n",
-    "\n",
-    "                # Process states\n",
-    "                if filtered_states is not None and us_baselines:\n",
-    "                    df_states = df_pct[\n",
-    "                        (df_pct[\"geography\"] == \"state_us\")\n",
-    "                        & (df_pct[\"geo_id\"].isin(filtered_states))\n",
-    "                    ].copy()\n",
-    "\n",
-    "                    for _, row in df_states.iterrows():\n",
-    "                        baseline = us_baselines.get(row[\"cluster_name\"])\n",
-    "\n",
-    "                        if baseline and baseline > 0:\n",
-    "                            index_row = {\n",
-    "                                \"geo_id\": row[\"geo_id\"],\n",
-    "                                \"geography\": row[\"geography\"],\n",
-    "                                \"date_start\": row[\"date_start\"],\n",
-    "                                \"date_end\": row[\"date_end\"],\n",
-    "                                \"platform_and_product\": row[\"platform_and_product\"],\n",
-    "                                \"facet\": row[\"facet\"],\n",
-    "                                \"level\": row[\"level\"],\n",
-    "                                \"variable\": f\"{facet_name}_pct_index\",\n",
-    "                                \"cluster_name\": row[\"cluster_name\"],\n",
-    "                                \"value\": row[\"value\"] / baseline,\n",
-    "                            }\n",
-    "                            index_rows.append(index_row)\n",
-    "\n",
-    "    # Add all index rows to result\n",
-    "    if index_rows:\n",
-    "        df_index = pd.DataFrame(index_rows)\n",
-    "        df_result = pd.concat([df_result, df_index], ignore_index=True)\n",
-    "\n",
-    "    return df_result"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def calculate_usage_tiers(df, n_tiers=4, filtered_countries=None, filtered_states=None):\n",
-    "    \"\"\"\n",
-    "    Calculate usage tiers based on indexed per capita usage.\n",
-    "    - Tier 0: Zero adoption (index = 0)\n",
-    "    - Tiers 1-4: Quartiles based on thresholds from filtered countries/states\n",
-    "\n",
-    "    Quartile thresholds are calculated using only countries/states with ≥MIN_OBSERVATIONS,\n",
-    "    but applied to all countries/states to ensure complete visualization.\n",
-    "\n",
-    "    Note: Tier assignments for countries/states with <MIN_OBSERVATIONS should be\n",
-    "    interpreted with caution due to sample size limitations.\n",
-    "\n",
-    "    Args:\n",
-    "        df: Input dataframe\n",
-    "        n_tiers: Number of quartiles to create for non-zero usage (default 4)\n",
-    "        filtered_countries: List of countries that meet MIN_OBSERVATIONS threshold\n",
-    "        filtered_states: List of states that meet MIN_OBSERVATIONS threshold\n",
-    "\n",
-    "    Returns:\n",
-    "        Dataframe with usage tier rows added\n",
-    "    \"\"\"\n",
-    "    df_result = df.copy()\n",
-    "\n",
-    "    # Calculate tiers for indexed per capita metrics\n",
-    "    if \"variable\" in df_result.columns and \"value\" in df_result.columns:\n",
-    "        index_vars = [\"usage_per_capita_index\"]\n",
-    "\n",
-    "        quartile_labels = [\n",
-    "            \"Emerging (bottom 25%)\",\n",
-    "            \"Lower middle (25-50%)\",\n",
-    "            \"Upper middle (50-75%)\",\n",
-    "            \"Leading (top 25%)\",\n",
-    "        ]\n",
-    "\n",
-    "        tier_rows = []\n",
-    "\n",
-    "        for var in index_vars:\n",
-    "            # Process countries\n",
-    "            # Get all countries with the index variable\n",
-    "            all_country_data = df_result[\n",
-    "                (df_result[\"variable\"] == var) & (df_result[\"geography\"] == \"country\")\n",
-    "            ].copy()\n",
-    "\n",
-    "            if not all_country_data.empty:\n",
-    "                # Separate zero and non-zero usage\n",
-    "                zero_usage = all_country_data[all_country_data[\"value\"] == 0].copy()\n",
-    "                nonzero_usage = all_country_data[all_country_data[\"value\"] > 0].copy()\n",
-    "\n",
-    "                # Calculate quartile thresholds using ONLY filtered countries\n",
-    "                if filtered_countries is not None and not nonzero_usage.empty:\n",
-    "                    # Get only filtered countries for quartile calculation\n",
-    "                    filtered_for_quartiles = nonzero_usage[\n",
-    "                        nonzero_usage[\"geo_id\"].isin(filtered_countries)\n",
-    "                    ].copy()\n",
-    "\n",
-    "                    if not filtered_for_quartiles.empty:\n",
-    "                        # Calculate quartile thresholds from filtered countries\n",
-    "                        quartiles = (\n",
-    "                            filtered_for_quartiles[\"value\"]\n",
-    "                            .quantile([0.25, 0.5, 0.75])\n",
-    "                            .values\n",
-    "                        )\n",
-    "\n",
-    "                        # Apply thresholds to all non-zero countries\n",
-    "                        for _, row in nonzero_usage.iterrows():\n",
-    "                            value = row[\"value\"]\n",
-    "\n",
-    "                            # Assign tier based on thresholds\n",
-    "                            if value <= quartiles[0]:\n",
-    "                                tier_label = quartile_labels[0]  # Bottom 25%\n",
-    "                                tier_value = 1\n",
-    "                            elif value <= quartiles[1]:\n",
-    "                                tier_label = quartile_labels[1]  # 25-50%\n",
-    "                                tier_value = 2\n",
-    "                            elif value <= quartiles[2]:\n",
-    "                                tier_label = quartile_labels[2]  # 50-75%\n",
-    "                                tier_value = 3\n",
-    "                            else:\n",
-    "                                tier_label = quartile_labels[3]  # Top 25%\n",
-    "                                tier_value = 4\n",
-    "\n",
-    "                            tier_row = {\n",
-    "                                \"geo_id\": row[\"geo_id\"],\n",
-    "                                \"geography\": row[\"geography\"],\n",
-    "                                \"date_start\": row[\"date_start\"],\n",
-    "                                \"date_end\": row[\"date_end\"],\n",
-    "                                \"platform_and_product\": row[\"platform_and_product\"],\n",
-    "                                \"facet\": row[\"facet\"],\n",
-    "                                \"level\": row[\"level\"],\n",
-    "                                \"variable\": \"usage_tier\",\n",
-    "                                \"cluster_name\": tier_label,\n",
-    "                                \"value\": tier_value,\n",
-    "                            }\n",
-    "                            tier_rows.append(tier_row)\n",
-    "\n",
-    "                # Add tier 0 for all zero usage countries\n",
-    "                for _, row in zero_usage.iterrows():\n",
-    "                    tier_row = {\n",
-    "                        \"geo_id\": row[\"geo_id\"],\n",
-    "                        \"geography\": row[\"geography\"],\n",
-    "                        \"date_start\": row[\"date_start\"],\n",
-    "                        \"date_end\": row[\"date_end\"],\n",
-    "                        \"platform_and_product\": row[\"platform_and_product\"],\n",
-    "                        \"facet\": row[\"facet\"],\n",
-    "                        \"level\": row[\"level\"],\n",
-    "                        \"variable\": \"usage_tier\",\n",
-    "                        \"cluster_name\": \"Minimal\",\n",
-    "                        \"value\": 0,\n",
-    "                    }\n",
-    "                    tier_rows.append(tier_row)\n",
-    "\n",
-    "            # Process states\n",
-    "            # Get all states with the index variable\n",
-    "            all_state_data = df_result[\n",
-    "                (df_result[\"variable\"] == var) & (df_result[\"geography\"] == \"state_us\")\n",
-    "            ].copy()\n",
-    "\n",
-    "            if not all_state_data.empty:\n",
-    "                # Separate zero and non-zero usage\n",
-    "                zero_usage = all_state_data[all_state_data[\"value\"] == 0].copy()\n",
-    "                nonzero_usage = all_state_data[all_state_data[\"value\"] > 0].copy()\n",
-    "\n",
-    "                # Calculate quartile thresholds using ONLY filtered states\n",
-    "                if filtered_states is not None and not nonzero_usage.empty:\n",
-    "                    # Get only filtered states for quartile calculation\n",
-    "                    filtered_for_quartiles = nonzero_usage[\n",
-    "                        nonzero_usage[\"geo_id\"].isin(filtered_states)\n",
-    "                    ].copy()\n",
-    "\n",
-    "                    if not filtered_for_quartiles.empty:\n",
-    "                        # Calculate quartile thresholds from filtered states\n",
-    "                        quartiles = (\n",
-    "                            filtered_for_quartiles[\"value\"]\n",
-    "                            .quantile([0.25, 0.5, 0.75])\n",
-    "                            .values\n",
-    "                        )\n",
-    "\n",
-    "                        # Apply thresholds to all non-zero states\n",
-    "                        for _, row in nonzero_usage.iterrows():\n",
-    "                            value = row[\"value\"]\n",
-    "\n",
-    "                            # Assign tier based on thresholds\n",
-    "                            if value <= quartiles[0]:\n",
-    "                                tier_label = quartile_labels[0]  # Bottom 25%\n",
-    "                                tier_value = 1\n",
-    "                            elif value <= quartiles[1]:\n",
-    "                                tier_label = quartile_labels[1]  # 25-50%\n",
-    "                                tier_value = 2\n",
-    "                            elif value <= quartiles[2]:\n",
-    "                                tier_label = quartile_labels[2]  # 50-75%\n",
-    "                                tier_value = 3\n",
-    "                            else:\n",
-    "                                tier_label = quartile_labels[3]  # Top 25%\n",
-    "                                tier_value = 4\n",
-    "\n",
-    "                            tier_row = {\n",
-    "                                \"geo_id\": row[\"geo_id\"],\n",
-    "                                \"geography\": row[\"geography\"],\n",
-    "                                \"date_start\": row[\"date_start\"],\n",
-    "                                \"date_end\": row[\"date_end\"],\n",
-    "                                \"platform_and_product\": row[\"platform_and_product\"],\n",
-    "                                \"facet\": row[\"facet\"],\n",
-    "                                \"level\": row[\"level\"],\n",
-    "                                \"variable\": \"usage_tier\",\n",
-    "                                \"cluster_name\": tier_label,\n",
-    "                                \"value\": tier_value,\n",
-    "                            }\n",
-    "                            tier_rows.append(tier_row)\n",
-    "\n",
-    "                # Add tier 0 for all zero usage states\n",
-    "                for _, row in zero_usage.iterrows():\n",
-    "                    tier_row = {\n",
-    "                        \"geo_id\": row[\"geo_id\"],\n",
-    "                        \"geography\": row[\"geography\"],\n",
-    "                        \"date_start\": row[\"date_start\"],\n",
-    "                        \"date_end\": row[\"date_end\"],\n",
-    "                        \"platform_and_product\": row[\"platform_and_product\"],\n",
-    "                        \"facet\": row[\"facet\"],\n",
-    "                        \"level\": row[\"level\"],\n",
-    "                        \"variable\": \"usage_tier\",\n",
-    "                        \"cluster_name\": \"Minimal\",\n",
-    "                        \"value\": 0,\n",
-    "                    }\n",
-    "                    tier_rows.append(tier_row)\n",
-    "\n",
-    "        if tier_rows:\n",
-    "            df_result = pd.concat(\n",
-    "                [df_result, pd.DataFrame(tier_rows)], ignore_index=True\n",
-    "            )\n",
-    "\n",
-    "    return df_result"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def calculate_automation_augmentation_metrics(\n",
-    "    df, filtered_countries=None, filtered_states=None\n",
-    "):\n",
-    "    \"\"\"\n",
-    "    Calculate automation vs augmentation percentages for collaboration patterns.\n",
-    "\n",
-    "    This function:\n",
-    "    1. Categorizes collaboration patterns as automation or augmentation\n",
-    "    2. Calculates percentages excluding 'none' and 'not_classified'\n",
-    "    3. Only calculates for filtered geographies at country/state level\n",
-    "\n",
-    "    Categorization:\n",
-    "    - Automation: directive, feedback loop (AI-centric patterns)\n",
-    "    - Augmentation: validation, task iteration, learning (human-centric patterns)\n",
-    "    - Excluded: none (no collaboration), not_classified (unknown)\n",
-    "\n",
-    "    Args:\n",
-    "        df: Dataframe with collaboration data\n",
-    "        filtered_countries: List of countries that meet MIN_OBSERVATIONS\n",
-    "        filtered_states: List of states that meet MIN_OBSERVATIONS\n",
-    "\n",
-    "    Returns:\n",
-    "        Dataframe with automation/augmentation percentage rows added\n",
-    "    \"\"\"\n",
-    "    if \"facet\" not in df.columns or \"cluster_name\" not in df.columns:\n",
-    "        return df\n",
-    "\n",
-    "    df_result = df.copy()\n",
-    "\n",
-    "    # Get collaboration data\n",
-    "    collab_data = df_result[\n",
-    "        (df_result[\"facet\"] == \"collaboration\")\n",
-    "        & (df_result[\"variable\"] == \"collaboration_count\")\n",
-    "    ].copy()\n",
-    "\n",
-    "    if collab_data.empty:\n",
-    "        return df_result\n",
-    "\n",
-    "    # Define pattern categorization\n",
-    "    def categorize_pattern(pattern_name):\n",
-    "        if pd.isna(pattern_name):\n",
-    "            return None\n",
-    "\n",
-    "        pattern_clean = pattern_name.lower().replace(\"_\", \" \").replace(\"-\", \" \")\n",
-    "\n",
-    "        # Augmentation patterns (human-centric)\n",
-    "        if \"validation\" in pattern_clean:\n",
-    "            return \"augmentation\"\n",
-    "        elif \"task iteration\" in pattern_clean or \"task_iteration\" in pattern_clean:\n",
-    "            return \"augmentation\"\n",
-    "        elif \"learning\" in pattern_clean:\n",
-    "            return \"augmentation\"\n",
-    "        # Automation patterns (AI-centric)\n",
-    "        elif \"directive\" in pattern_clean:\n",
-    "            return \"automation\"\n",
-    "        elif \"feedback loop\" in pattern_clean or \"feedback_loop\" in pattern_clean:\n",
-    "            return \"automation\"\n",
-    "        # Excluded patterns - return None to exclude from calculations\n",
-    "        elif \"none\" in pattern_clean or \"not_classified\" in pattern_clean:\n",
-    "            return None\n",
-    "        else:\n",
-    "            return None  # Unknown patterns also excluded\n",
-    "\n",
-    "    # Add category column\n",
-    "    collab_data[\"category\"] = collab_data[\"cluster_name\"].apply(categorize_pattern)\n",
-    "\n",
-    "    # Filter to only patterns that have a category (excludes none, not_classified, etc.)\n",
-    "    collab_categorized = collab_data[collab_data[\"category\"].notna()].copy()\n",
-    "\n",
-    "    if collab_categorized.empty:\n",
-    "        return df_result\n",
-    "\n",
-    "    # Process by geography\n",
-    "    new_rows = []\n",
-    "\n",
-    "    # Group by geography and geo_id\n",
-    "    for (geography, geo_id), geo_data in collab_categorized.groupby(\n",
-    "        [\"geography\", \"geo_id\"]\n",
-    "    ):\n",
-    "        # Apply filtering based on geography level\n",
-    "        if geography == \"country\" and filtered_countries is not None:\n",
-    "            if geo_id not in filtered_countries:\n",
-    "                continue  # Skip countries that don't meet threshold\n",
-    "        elif geography == \"state_us\" and filtered_states is not None:\n",
-    "            if geo_id not in filtered_states:\n",
-    "                continue  # Skip states that don't meet threshold\n",
-    "        # global is always included (no filtering)\n",
-    "\n",
-    "        # Calculate totals by category\n",
-    "        automation_total = geo_data[geo_data[\"category\"] == \"automation\"][\"value\"].sum()\n",
-    "        augmentation_total = geo_data[geo_data[\"category\"] == \"augmentation\"][\n",
-    "            \"value\"\n",
-    "        ].sum()\n",
-    "\n",
-    "        # Total of categorized patterns (excluding none and not_classified)\n",
-    "        total_categorized = automation_total + augmentation_total\n",
-    "\n",
-    "        if total_categorized > 0:\n",
-    "            # Get a sample row for metadata\n",
-    "            sample_row = geo_data.iloc[0]\n",
-    "\n",
-    "            # Create automation percentage row\n",
-    "            automation_row = {\n",
-    "                \"geo_id\": geo_id,\n",
-    "                \"geography\": geography,\n",
-    "                \"date_start\": sample_row[\"date_start\"],\n",
-    "                \"date_end\": sample_row[\"date_end\"],\n",
-    "                \"platform_and_product\": sample_row[\"platform_and_product\"],\n",
-    "                \"facet\": \"collaboration_automation_augmentation\",\n",
-    "                \"level\": 0,\n",
-    "                \"variable\": \"automation_pct\",\n",
-    "                \"cluster_name\": \"automation\",\n",
-    "                \"value\": (automation_total / total_categorized) * 100,\n",
-    "            }\n",
-    "            new_rows.append(automation_row)\n",
-    "\n",
-    "            # Create augmentation percentage row\n",
-    "            augmentation_row = {\n",
-    "                \"geo_id\": geo_id,\n",
-    "                \"geography\": geography,\n",
-    "                \"date_start\": sample_row[\"date_start\"],\n",
-    "                \"date_end\": sample_row[\"date_end\"],\n",
-    "                \"platform_and_product\": sample_row[\"platform_and_product\"],\n",
-    "                \"facet\": \"collaboration_automation_augmentation\",\n",
-    "                \"level\": 0,\n",
-    "                \"variable\": \"augmentation_pct\",\n",
-    "                \"cluster_name\": \"augmentation\",\n",
-    "                \"value\": (augmentation_total / total_categorized) * 100,\n",
-    "            }\n",
-    "            new_rows.append(augmentation_row)\n",
-    "\n",
-    "    # Add all new rows to result\n",
-    "    if new_rows:\n",
-    "        df_new = pd.DataFrame(new_rows)\n",
-    "        df_result = pd.concat([df_result, df_new], ignore_index=True)\n",
-    "\n",
-    "    return df_result"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def add_iso3_and_names(df):\n",
-    "    \"\"\"\n",
-    "    Replace ISO-2 codes with ISO-3 codes and add geographic names.\n",
-    "\n",
-    "    This function:\n",
-    "    1. Replaces geo_id from ISO-2 to ISO-3 for countries\n",
-    "    2. Adds geo_name column with human-readable names for all geographies\n",
-    "    3. Preserves special geo_ids (like 'not_classified') that aren't in ISO mapping\n",
-    "\n",
-    "    Args:\n",
-    "        df: Enriched dataframe with geo_id (ISO-2 for countries, state codes for US states)\n",
-    "\n",
-    "    Returns:\n",
-    "        Dataframe with ISO-3 codes in geo_id and geo_name column added\n",
-    "    \"\"\"\n",
-    "    df_result = df.copy()\n",
-    "\n",
-    "    # Initialize geo_name column\n",
-    "    df_result[\"geo_name\"] = \"\"\n",
-    "\n",
-    "    # Load ISO mapping data for countries\n",
-    "    iso_path = Path(DATA_INTERMEDIATE_DIR) / \"iso_country_codes.csv\"\n",
-    "    if iso_path.exists():\n",
-    "        df_iso = pd.read_csv(iso_path, keep_default_na=False, na_values=[\"\"])\n",
-    "\n",
-    "        # Create ISO-2 to ISO-3 mapping\n",
-    "        iso2_to_iso3 = dict(zip(df_iso[\"iso_alpha_2\"], df_iso[\"iso_alpha_3\"]))\n",
-    "\n",
-    "        # Create ISO-2 to country name mapping\n",
-    "        iso2_to_name = dict(zip(df_iso[\"iso_alpha_2\"], df_iso[\"country_name\"]))\n",
-    "\n",
-    "        # For all rows where geography is 'country', add country names and convert codes\n",
-    "        # This includes content facets that are broken down by country\n",
-    "        country_mask = df_result[\"geography\"] == \"country\"\n",
-    "\n",
-    "        # First, identify which geo_ids don't have ISO mappings\n",
-    "        country_geo_ids = df_result.loc[country_mask, \"geo_id\"].unique()\n",
-    "        unmapped_geo_ids = [\n",
-    "            g for g in country_geo_ids if g not in iso2_to_iso3 and pd.notna(g)\n",
-    "        ]\n",
-    "\n",
-    "        if unmapped_geo_ids:\n",
-    "            print(\n",
-    "                f\"\\nWarning: The following geo_ids are not in ISO-2 mapping and will be kept as-is:\"\n",
-    "            )\n",
-    "            for geo_id in unmapped_geo_ids:\n",
-    "                # Count rows and usage for this geo_id\n",
-    "                geo_mask = (df_result[\"geography\"] == \"country\") & (\n",
-    "                    df_result[\"geo_id\"] == geo_id\n",
-    "                )\n",
-    "                row_count = geo_mask.sum()\n",
-    "                usage_mask = geo_mask & (df_result[\"variable\"] == \"usage_count\")\n",
-    "                usage_sum = (\n",
-    "                    df_result.loc[usage_mask, \"value\"].sum() if usage_mask.any() else 0\n",
-    "                )\n",
-    "                print(f\"  - '{geo_id}': {row_count} rows, {usage_sum:,.0f} usage count\")\n",
-    "\n",
-    "        # Check for geo_ids without country names\n",
-    "        unmapped_names = [g for g in unmapped_geo_ids if g not in iso2_to_name]\n",
-    "        if unmapped_names:\n",
-    "            print(\n",
-    "                f\"\\nWarning: The following geo_ids don't have country names and will use geo_id as name:\"\n",
-    "            )\n",
-    "            for geo_id in unmapped_names:\n",
-    "                print(f\"  - '{geo_id}'\")\n",
-    "\n",
-    "        # Apply country names BEFORE converting ISO-2 to ISO-3\n",
-    "        # The iso2_to_name dictionary uses ISO-2 codes as keys\n",
-    "        df_result.loc[country_mask, \"geo_name\"] = (\n",
-    "            df_result.loc[country_mask, \"geo_id\"]\n",
-    "            .map(iso2_to_name)\n",
-    "            .fillna(df_result.loc[country_mask, \"geo_id\"])\n",
-    "        )\n",
-    "\n",
-    "        # Convert ISO-2 to ISO-3 codes\n",
-    "        df_result.loc[country_mask, \"geo_id\"] = (\n",
-    "            df_result.loc[country_mask, \"geo_id\"]\n",
-    "            .map(iso2_to_iso3)\n",
-    "            .fillna(df_result.loc[country_mask, \"geo_id\"])\n",
-    "        )\n",
-    "    else:\n",
-    "        print(f\"Warning: ISO mapping file not found at {iso_path}\")\n",
-    "\n",
-    "    # Load state names from census data\n",
-    "    state_codes_path = Path(DATA_INPUT_DIR) / \"census_state_codes.txt\"\n",
-    "    if state_codes_path.exists():\n",
-    "        df_state_codes = pd.read_csv(state_codes_path, sep=\"|\")\n",
-    "        # Create state code to name mapping (STUSAB is the 2-letter code, STATE_NAME is the full name)\n",
-    "        state_code_to_name = dict(\n",
-    "            zip(df_state_codes[\"STUSAB\"], df_state_codes[\"STATE_NAME\"])\n",
-    "        )\n",
-    "\n",
-    "        # For all rows where geography is 'state_us', add state names\n",
-    "        state_mask = df_result[\"geography\"] == \"state_us\"\n",
-    "        df_result.loc[state_mask, \"geo_name\"] = df_result.loc[state_mask, \"geo_id\"].map(\n",
-    "            state_code_to_name\n",
-    "        )\n",
-    "    else:\n",
-    "        print(f\"Warning: State census file not found at {state_codes_path}\")\n",
-    "\n",
-    "    # For global entries\n",
-    "    global_mask = df_result[\"geography\"] == \"global\"\n",
-    "    df_result.loc[global_mask, \"geo_name\"] = \"global\"\n",
-    "\n",
-    "    # Fill any missing geo_names with geo_id as fallback\n",
-    "    df_result.loc[df_result[\"geo_name\"] == \"\", \"geo_name\"] = df_result.loc[\n",
-    "        df_result[\"geo_name\"] == \"\", \"geo_id\"\n",
-    "    ]\n",
-    "    df_result[\"geo_name\"] = df_result[\"geo_name\"].fillna(df_result[\"geo_id\"])\n",
-    "\n",
-    "    return df_result"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Main Processing Function"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def enrich_clio_data(input_path, output_path, external_data=None):\n",
-    "    \"\"\"\n",
-    "    Enrich processed Clio data with external sources.\n",
-    "\n",
-    "    Args:\n",
-    "        input_path: Path to processed Clio data\n",
-    "        output_path: Path for enriched CSV output\n",
-    "        external_data: Pre-loaded external data (optional)\n",
-    "\n",
-    "    Returns:\n",
-    "        Path to enriched data file\n",
-    "    \"\"\"\n",
-    "    # Load processed Clio data - use keep_default_na=False to preserve \"NA\" (Namibia)\n",
-    "    df = pd.read_csv(input_path, keep_default_na=False, na_values=[\"\"])\n",
-    "\n",
-    "    # Load external data if not provided\n",
-    "    if external_data is None:\n",
-    "        external_data = load_external_data()\n",
-    "\n",
-    "    # Get filtered geographies (but keep all data in the dataframe)\n",
-    "    filtered_countries, filtered_states = get_filtered_geographies(df)\n",
-    "\n",
-    "    # Merge with population data\n",
-    "    df = merge_population_data(df, external_data[\"population\"])\n",
-    "\n",
-    "    # Merge with GDP data (pass population data for per capita calculation)\n",
-    "    df = merge_gdp_data(df, external_data[\"gdp\"], external_data[\"population\"])\n",
-    "\n",
-    "    # Calculate SOC occupation distribution from O*NET tasks\n",
-    "    # Only for geographies that meet MIN_OBSERVATIONS threshold\n",
-    "    df = calculate_soc_distribution(\n",
-    "        df,\n",
-    "        external_data[\"task_statements\"],\n",
-    "        external_data[\"soc_structure\"],\n",
-    "        filtered_countries=filtered_countries,\n",
-    "        filtered_states=filtered_states,\n",
-    "    )\n",
-    "\n",
-    "    # Calculate per capita metrics\n",
-    "    df = calculate_per_capita_metrics(df)\n",
-    "\n",
-    "    # Calculate usage index - pass filtered countries/states to only use them for baseline\n",
-    "    df = calculate_usage_per_capita_index(\n",
-    "        df, filtered_countries=filtered_countries, filtered_states=filtered_states\n",
-    "    )\n",
-    "\n",
-    "    # Calculate category percentage index - pass filtered countries/states\n",
-    "    df = calculate_category_percentage_index(\n",
-    "        df, filtered_countries=filtered_countries, filtered_states=filtered_states\n",
-    "    )\n",
-    "\n",
-    "    # Calculate usage tiers - pass filtered countries/states to only use them\n",
-    "    df = calculate_usage_tiers(\n",
-    "        df, filtered_countries=filtered_countries, filtered_states=filtered_states\n",
-    "    )\n",
-    "\n",
-    "    # Add collaboration categorization\n",
-    "    df = calculate_automation_augmentation_metrics(df)\n",
-    "\n",
-    "    # Add ISO-3 codes and geographic names\n",
-    "    df = add_iso3_and_names(df)\n",
-    "\n",
-    "    # Sort for consistent output ordering\n",
-    "    df = df.sort_values(\n",
-    "        [\"geography\", \"geo_id\", \"facet\", \"level\", \"cluster_name\", \"variable\"]\n",
-    "    )\n",
-    "\n",
-    "    # Save enriched data as CSV\n",
-    "    df.to_csv(output_path, index=False)\n",
-    "\n",
-    "    return str(output_path)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Merge External Data"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "input_path = \"../data/intermediate/aei_raw_claude_ai_2025-08-04_to_2025-08-11.csv\"\n",
-    "output_path = \"../data/output/aei_enriched_claude_ai_2025-08-04_to_2025-08-11.csv\"\n",
-    "\n",
-    "enrich_clio_data(input_path, output_path)\n",
-    "print(f\"\\n✅ Enrichment complete! Output: {output_path}\")"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "py311",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.11.13"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}

release_2025_09_15/code/preprocess_gdp.py

@@ -1,364 +0,0 @@
-"""
-Preprocess GDP data for economic analysis.
-
-This script downloads and processes GDP data from:
-1. IMF API for country-level GDP data
-2. BEA (Bureau of Economic Analysis) for US state-level GDP data
-
-Output files:
-- gdp_YYYY_country.csv (e.g., gdp_2024_country.csv): Country-level total GDP
-- gdp_YYYY_us_state.csv (e.g., gdp_2024_us_state.csv): US state-level total GDP
-"""
-
-import io
-import json
-import warnings
-from pathlib import Path
-
-import httpx
-import pandas as pd
-
-# Global configuration
-YEAR = 2024
-DATA_INPUT_DIR = Path("../data/input")
-DATA_INTERMEDIATE_DIR = Path("../data/intermediate")
-
-
-# Countries where Claude AI service is not available
-# These will be excluded from all GDP data
-EXCLUDED_COUNTRIES = [
-    "AFG",
-    "BLR",
-    "COD",
-    "CAF",
-    "CHN",
-    "CUB",
-    "ERI",
-    "ETH",
-    "HKG",
-    "IRN",
-    "PRK",
-    "LBY",
-    "MLI",
-    "MMR",
-    "MAC",
-    "NIC",
-    "RUS",
-    "SDN",
-    "SOM",
-    "SSD",
-    "SYR",
-    "VEN",
-    "YEM",
-]
-
-
-def check_existing_files():
-    """Check if processed GDP files already exist."""
-    gdp_country_path = DATA_INTERMEDIATE_DIR / f"gdp_{YEAR}_country.csv"
-    gdp_state_path = DATA_INTERMEDIATE_DIR / f"gdp_{YEAR}_us_state.csv"
-
-    if gdp_country_path.exists() and gdp_state_path.exists():
-        print("✅ GDP files already exist:")
-        print(f"  - {gdp_country_path}")
-        print(f"  - {gdp_state_path}")
-        print("Skipping GDP preprocessing. Delete these files if you want to re-run.")
-        return True
-    return False
-
-
-def load_country_gdp_data():
-    """
-    Load country-level GDP data from cache or IMF API.
-
-    Returns:
-        dict: Raw GDP data from IMF API, or None if fetch fails
-    """
-    # Check if raw data already exists
-    raw_gdp_path = DATA_INPUT_DIR / f"imf_gdp_raw_{YEAR}.json"
-    if raw_gdp_path.exists():
-        print("Loading cached IMF GDP data...")
-        with open(raw_gdp_path) as f:
-            return json.load(f)
-
-    # Download if not cached
-    imf_total_gdp_url = "https://www.imf.org/external/datamapper/api/v1/NGDPD"  # IMF returns GDP in billions USD
-
-    print("Fetching GDP data from IMF API...")
-    try:
-        with httpx.Client() as client:
-            response = client.get(imf_total_gdp_url, timeout=30)
-            response.raise_for_status()
-            gdp_data = response.json()
-            print("✓ Successfully fetched total GDP data from IMF API")
-
-            # Save raw data for future use
-            with open(raw_gdp_path, "w") as f:
-                json.dump(gdp_data, f, indent=2)
-            print(f"✓ Saved raw GDP data to {raw_gdp_path}")
-
-            return gdp_data
-    except Exception as e:
-        raise ConnectionError(f"Failed to fetch data from IMF API: {e}") from e
-
-
-def process_country_gdp_data(gdp_data):
-    """
-    Process IMF GDP data into standardized format.
-
-    Args:
-        gdp_data: Raw IMF API response
-
-    Returns:
-        pd.DataFrame: Processed country GDP data (excluding countries where service is not available)
-    """
-    # Extract GDP data for target year
-    # Structure: {"values": {"NGDPD": {"countryiso3code": {"year": value}}}}
-    gdp_values = gdp_data.get("values", {}).get("NGDPD", {})
-
-    # Build records for target year data only
-    gdp_records = []
-    target_year = str(YEAR)
-    missing_countries = []
-
-    for countryiso3code, years_data in gdp_values.items():
-        if isinstance(years_data, dict):
-            if target_year in years_data and years_data[target_year]:
-                gdp_value = years_data[target_year]
-                # Convert from billions to actual dollars
-                gdp_records.append(
-                    {
-                        "iso_alpha_3": countryiso3code,
-                        "gdp_total": float(gdp_value)
-                        * 1e9,  # Convert billions to dollars
-                        "year": YEAR,
-                    }
-                )
-            else:
-                missing_countries.append(countryiso3code)
-
-    if missing_countries:
-        warnings.warn(
-            f"{len(missing_countries)} countries missing {YEAR} GDP data. "
-            f"Examples: {missing_countries[:5]}",
-            UserWarning,
-            stacklevel=2,
-        )
-
-    df_gdp = pd.DataFrame(gdp_records)
-
-    if df_gdp.empty:
-        raise ValueError(f"No GDP data available for year {YEAR}")
-
-    # Apply country code mappings for mismatches between IMF and ISO3
-    country_code_mappings = {
-        "UVK": "XKX",  # Kosovo
-        # Add more mappings as needed
-    }
-
-    for imf_code, iso3_code in country_code_mappings.items():
-        df_gdp.loc[df_gdp["iso_alpha_3"] == imf_code, "iso_alpha_3"] = iso3_code
-
-    # Filter to only keep countries with valid ISO-3 codes
-    # This removes regional aggregates like ADVEC, AFQ, etc.
-    iso_codes_path = DATA_INTERMEDIATE_DIR / "iso_country_codes.csv"
-    df_iso = pd.read_csv(iso_codes_path, keep_default_na=False, na_values=[""])
-    valid_iso3_codes = set(df_iso["iso_alpha_3"].unique())
-
-    initial_aggregate_count = len(df_gdp)
-    df_gdp = df_gdp[df_gdp["iso_alpha_3"].isin(valid_iso3_codes)]
-    filtered_aggregates = initial_aggregate_count - len(df_gdp)
-
-    if filtered_aggregates > 0:
-        print(
-            f"  Filtered out {filtered_aggregates} non-country codes (regional aggregates)"
-        )
-
-    # Filter out excluded countries (now using 3-letter codes directly)
-    initial_count = len(df_gdp)
-    df_gdp = df_gdp[~df_gdp["iso_alpha_3"].isin(EXCLUDED_COUNTRIES)]
-    excluded_count = initial_count - len(df_gdp)
-
-    if excluded_count > 0:
-        print(f"  Excluded {excluded_count} countries where service is not available")
-
-    # Save processed GDP data
-    processed_gdp_path = DATA_INTERMEDIATE_DIR / f"gdp_{YEAR}_country.csv"
-    df_gdp.to_csv(processed_gdp_path, index=False)
-
-    print(f"✓ Saved processed GDP data to {processed_gdp_path}")
-    print(f"  Countries with {YEAR} GDP data: {len(df_gdp)}")
-    print(f"  Countries excluded (service not available): {len(EXCLUDED_COUNTRIES)}")
-    print(f"  Total global GDP: ${df_gdp['gdp_total'].sum() / 1e12:.2f} trillion")
-
-    return df_gdp
-
-
-def load_state_gdp_data():
-    """
-    Load US state GDP data from BEA file.
-
-    Returns:
-        pd.DataFrame: Raw state GDP data, or None if file not found
-    """
-    state_gdp_raw_path = DATA_INPUT_DIR / f"bea_us_state_gdp_{YEAR}.csv"
-
-    if not state_gdp_raw_path.exists():
-        error_msg = f"""
-State GDP data not found at: {state_gdp_raw_path}
-
-To obtain this data:
-1. Go to: https://apps.bea.gov/itable/?ReqID=70&step=1
-2. Select: SASUMMARY State annual summary statistics (area = "United States", statistic = Gross domestic product (GDP), unit of measure = "Levels")
-3. Download the CSV file for year {YEAR}
-4. Save it as: bea_us_state_gdp_{YEAR}.csv
-5. Place it in your data input directory
-"""
-        raise FileNotFoundError(error_msg)
-
-    print("Loading US state GDP data...")
-    # Parse CSV skipping the first 3 rows (BEA metadata)
-    df_state_gdp_raw = pd.read_csv(state_gdp_raw_path, skiprows=3)
-    df_state_gdp_raw.columns = ["GeoFips", "State", f"gdp_{YEAR}_millions"]
-
-    return df_state_gdp_raw
-
-
-def process_state_gdp_data(df_state_gdp_raw):
-    """
-    Process BEA state GDP data into standardized format.
-
-    Args:
-        df_state_gdp_raw: Raw BEA data
-
-    Returns:
-        pd.DataFrame: Processed state GDP data
-    """
-
-    # Remove the US total row (GeoFips = "00000")
-    df_state_gdp = df_state_gdp_raw[df_state_gdp_raw["GeoFips"] != "00000"].copy()
-
-    # Remove all rows starting from empty line before "Legend/Footnotes" marker
-    # BEA files have footer information after the data, with an empty line before
-    legend_index = (
-        df_state_gdp[
-            df_state_gdp["GeoFips"].str.contains("Legend", case=False, na=False)
-        ].index[0]
-        - 1
-    )
-    df_state_gdp = df_state_gdp.iloc[:legend_index].copy()
-    print(f"  Removed footer rows starting from 'Legend/Footnotes'")
-
-    # Convert GDP from millions to actual dollars
-    df_state_gdp["gdp_total"] = df_state_gdp[f"gdp_{YEAR}_millions"] * 1e6
-
-    # Clean state names
-    df_state_gdp["State"] = df_state_gdp["State"].str.strip()
-
-    # Get state codes
-    state_code_dict = get_state_codes()
-    df_state_gdp["state_code"] = df_state_gdp["State"].map(state_code_dict)
-
-    # Check for missing state codes
-    missing_codes = df_state_gdp[df_state_gdp["state_code"].isna()]
-    if not missing_codes.empty:
-        raise ValueError(
-            f"Could not find state codes for: {missing_codes['State'].tolist()}\n"
-            f"All BEA state names should match Census state codes after filtering."
-        )
-
-    # Select and rename columns
-    df_state_gdp_final = df_state_gdp[
-        ["state_code", "State", "gdp_total", f"gdp_{YEAR}_millions"]
-    ].copy()
-    df_state_gdp_final.columns = [
-        "state_code",
-        "state_name",
-        "gdp_total",
-        "gdp_millions",
-    ]
-    df_state_gdp_final["year"] = YEAR
-
-    # Save processed state GDP data
-    processed_state_gdp_path = DATA_INTERMEDIATE_DIR / f"gdp_{YEAR}_us_state.csv"
-    df_state_gdp_final.to_csv(processed_state_gdp_path, index=False)
-
-    print(
-        f"✓ Processed state GDP data for {len(df_state_gdp_final)} states/territories"
-    )
-    print(
-        f"  Total US GDP: ${df_state_gdp_final['gdp_total'].sum() / 1e12:.2f} trillion"
-    )
-    print(f"✓ Saved to {processed_state_gdp_path}")
-
-    return df_state_gdp_final
-
-
-def get_state_codes():
-    """
-    Get US state codes from Census Bureau.
-
-    Returns:
-        dict: Mapping of state names to abbreviations
-    """
-    state_codes_path = DATA_INPUT_DIR / "census_state_codes.txt"
-
-    if state_codes_path.exists():
-        print("  Loading cached state codes...")
-        df_state_codes = pd.read_csv(state_codes_path, sep="|")
-    else:
-        print("  Downloading state codes from Census Bureau...")
-        response = httpx.get("https://www2.census.gov/geo/docs/reference/state.txt")
-        response.raise_for_status()
-
-        # Save for future use
-        with open(state_codes_path, "w") as f:
-            f.write(response.text)
-        print(f"  Cached state codes to {state_codes_path}")
-
-        df_state_codes = pd.read_csv(io.StringIO(response.text), sep="|")
-
-    # Create mapping dictionary
-    state_code_dict = dict(
-        zip(df_state_codes["STATE_NAME"], df_state_codes["STUSAB"], strict=True)
-    )
-
-    return state_code_dict
-
-
-def main():
-    """Main function to run GDP preprocessing."""
-    # Check if files already exist
-    if check_existing_files():
-        return
-
-    print("=" * 60)
-    print(f"PROCESSING {YEAR} GDP DATA")
-    print("=" * 60)
-
-    # Process country-level GDP from IMF
-    print(f"\n=== Country-Level GDP (IMF) - Year {YEAR} ===")
-    gdp_data = load_country_gdp_data()
-    df_gdp_country = process_country_gdp_data(gdp_data)
-
-    # Process US state-level GDP from BEA
-    print(f"\n=== US State-Level GDP (BEA) - Year {YEAR} ===")
-    df_state_gdp_raw = load_state_gdp_data()
-    df_gdp_state = process_state_gdp_data(df_state_gdp_raw)
-
-    # Final status
-    print(f"\n✅ {YEAR} GDP data preprocessing complete!")
-    print("\n=== Summary Statistics ===")
-    if df_gdp_country is not None:
-        print(f"Countries processed: {len(df_gdp_country)}")
-        print(f"Countries excluded (service not available): {len(EXCLUDED_COUNTRIES)}")
-        print(
-            f"Total global GDP: ${df_gdp_country['gdp_total'].sum() / 1e12:.2f} trillion"
-        )
-    if df_gdp_state is not None:
-        print(f"US states processed: {len(df_gdp_state)}")
-        print(f"Total US GDP: ${df_gdp_state['gdp_total'].sum() / 1e12:.2f} trillion")
-
-
-if __name__ == "__main__":
-    main()

release_2025_09_15/code/preprocess_iso_codes.py

@@ -1,111 +0,0 @@
-"""
-Fetch ISO country code mappings from GeoNames.
-
-This script fetches comprehensive country data from GeoNames countryInfo.txt
-and saves it as a CSV file for use in data preprocessing pipelines.
-"""
-
-import io
-from pathlib import Path
-
-import httpx
-import pandas as pd
-
-
-def fetch_country_mappings(save_raw=True):
-    """
-    Fetch country code mappings from GeoNames.
-
-    Args:
-        save_raw: Whether to save raw data file to data/input
-
-    Returns:
-        pd.DataFrame: DataFrame with country information from GeoNames
-    """
-    # Fetch countryInfo.txt from GeoNames
-    geonames_url = "https://download.geonames.org/export/dump/countryInfo.txt"
-
-    with httpx.Client() as client:
-        response = client.get(geonames_url)
-        response.raise_for_status()
-        content = response.text
-
-    # Save raw file to data/input for reference
-    if save_raw:
-        input_dir = Path("../data/input")
-        input_dir.mkdir(parents=True, exist_ok=True)
-
-        raw_path = input_dir / "geonames_countryInfo.txt"
-        with open(raw_path, "w", encoding="utf-8") as f:
-            f.write(content)
-
-    # Extract column names from the last comment line
-    lines = content.split("\n")
-    header_line = [line for line in lines if line.startswith("#")][-1]
-    column_names = header_line[1:].split("\t")  # Remove # and split by tab
-
-    # Parse the tab-separated file
-    # keep_default_na=False to prevent "NA" (Namibia) from becoming NaN
-    df = pd.read_csv(
-        io.StringIO(content),
-        sep="\t",
-        comment="#",
-        header=None,  # No header row in the data
-        keep_default_na=False,  # Don't interpret "NA" as NaN (needed for Namibia)
-        na_values=[""],  # Only treat empty strings as NaN
-        names=column_names,  # Use the column names from the comment
-    )
-
-    # Rename columns to our standard format
-    df = df.rename(
-        columns={"ISO": "iso_alpha_2", "ISO3": "iso_alpha_3", "Country": "country_name"}
-    )
-
-    return df
-
-
-def create_country_dataframe(geonames_df):
-    """
-    Create a cleaned DataFrame with country codes and names.
-
-    Args:
-        geonames_df: DataFrame from GeoNames with all country information
-
-    Returns:
-        pd.DataFrame: DataFrame with columns [iso_alpha_2, iso_alpha_3, country_name]
-    """
-    # Select only the columns we need
-    df = geonames_df[["iso_alpha_2", "iso_alpha_3", "country_name"]].copy()
-
-    # Sort by country name for consistency
-    df = df.sort_values("country_name").reset_index(drop=True)
-
-    return df
-
-
-def save_country_codes(output_path="../data/intermediate/iso_country_codes.csv"):
-    """
-    Fetch country codes from GeoNames and save to CSV.
-
-    Args:
-        output_path: Path to save the CSV file
-    """
-    # Fetch full GeoNames data
-    geonames_df = fetch_country_mappings()
-
-    # Create cleaned DataFrame with just the columns we need
-    df = create_country_dataframe(geonames_df)
-
-    # Ensure output directory exists
-    output_file = Path(output_path)
-    output_file.parent.mkdir(parents=True, exist_ok=True)
-
-    # Save to CSV
-    df.to_csv(output_file, index=False)
-
-    return df
-
-
-if __name__ == "__main__":
-    # Fetch and save country codes
-    df = save_country_codes()

release_2025_09_15/code/preprocess_onet.py

@@ -1,179 +0,0 @@
-"""
-Preprocess O*NET and SOC data for economic analysis.
-
-This script downloads and processes occupational data from:
-1. O*NET Resource Center for task statements
-2. O*NET Resource Center for SOC structure
-
-Output files:
-- onet_task_statements.csv: O*NET task statements with SOC major groups
-- soc_structure.csv: SOC occupational classification structure
-"""
-
-import io
-import os
-import tempfile
-from pathlib import Path
-
-import httpx
-import pandas as pd
-
-# Global configuration
-DATA_INPUT_DIR = Path("../data/input")
-DATA_INTERMEDIATE_DIR = Path("../data/intermediate")
-
-
-def check_existing_files():
-    """Check if processed O*NET/SOC files already exist."""
-    onet_task_statements_path = DATA_INTERMEDIATE_DIR / "onet_task_statements.csv"
-    soc_structure_path = DATA_INTERMEDIATE_DIR / "soc_structure.csv"
-
-    if onet_task_statements_path.exists() and soc_structure_path.exists():
-        print("✅ SOC/O*NET files already exist:")
-        print(f"  - {onet_task_statements_path}")
-        print(f"  - {soc_structure_path}")
-        print("Skipping SOC preprocessing. Delete these files if you want to re-run.")
-        return True
-    return False
-
-
-def load_task_data():
-    """
-    Load O*NET Task Statements from cache or O*NET Resource Center.
-
-    Returns:
-        pd.DataFrame: O*NET task statements data
-    """
-    # Check if raw data already exists
-    raw_onet_path = DATA_INPUT_DIR / "onet_task_statements_raw.xlsx"
-    if raw_onet_path.exists():
-        df_onet = pd.read_excel(raw_onet_path)
-        return df_onet
-
-    # Download if not cached
-    # O*NET Database version 20.1
-    onet_url = "https://www.onetcenter.org/dl_files/database/db_20_1_excel/Task%20Statements.xlsx"
-
-    print("Downloading O*NET task statements...")
-    try:
-        with httpx.Client(follow_redirects=True) as client:
-            response = client.get(onet_url, timeout=60)
-            response.raise_for_status()
-            excel_content = response.content
-            # Save raw data for future use
-            with open(raw_onet_path, "wb") as f:
-                f.write(excel_content)
-
-            # Save to temporary file for pandas to read
-            with tempfile.NamedTemporaryFile(suffix=".xlsx", delete=False) as tmp_file:
-                tmp_file.write(excel_content)
-                tmp_path = tmp_file.name
-
-            try:
-                df_onet = pd.read_excel(tmp_path)
-                return df_onet
-            finally:
-                os.unlink(tmp_path)
-
-    except Exception as e:
-        raise ConnectionError(f"Failed to download O*NET data: {e}") from e
-
-
-def process_task_data(df_tasks):
-    """
-    Process task statements data.
-
-    Args:
-        df_tasks: Raw task data
-
-    Returns:
-        pd.DataFrame: Processed O*NET data with SOC major groups
-    """
-    # Extract SOC major group from O*NET-SOC Code (first 2 digits)
-    df_tasks["soc_major_group"] = df_tasks["O*NET-SOC Code"].str[:2]
-
-    # Save processed task data
-    processed_tasks_path = DATA_INTERMEDIATE_DIR / "onet_task_statements.csv"
-    df_tasks.to_csv(processed_tasks_path, index=False)
-
-    print(
-        f"✓ Processed {len(df_tasks):,} task statements from {df_tasks['O*NET-SOC Code'].nunique()} occupations"
-    )
-
-    return df_tasks
-
-
-def load_soc_data():
-    """
-    Load SOC Structure from cache or O*NET Resource Center.
-
-    Returns:
-        pd.DataFrame: SOC structure data
-    """
-    # Check if raw data already exists
-    raw_soc_path = DATA_INPUT_DIR / "soc_structure_raw.csv"
-    if raw_soc_path.exists():
-        return pd.read_csv(raw_soc_path)
-
-    # Download if not cached
-    soc_url = "https://www.onetcenter.org/taxonomy/2019/structure/?fmt=csv"
-
-    print("Downloading SOC structure...")
-    try:
-        with httpx.Client(follow_redirects=True) as client:
-            response = client.get(soc_url, timeout=30)
-            response.raise_for_status()
-            soc_content = response.text
-            # Save raw data for future use
-            with open(raw_soc_path, "w") as f:
-                f.write(soc_content)
-
-            # Parse the CSV
-            df_soc = pd.read_csv(io.StringIO(soc_content))
-            return df_soc
-
-    except Exception as e:
-        raise ConnectionError(f"Failed to download SOC structure: {e}") from e
-
-
-def process_soc_data(df_soc):
-    """
-    Process SOC structure data.
-
-    Args:
-        df_soc: Raw SOC structure data
-
-    Returns:
-        pd.DataFrame: Processed SOC structure
-    """
-    # Extract the 2-digit code from Major Group (e.g., "11-0000" -> "11")
-    df_soc["soc_major_group"] = df_soc["Major Group"].str[:2]
-
-    # Save processed SOC structure
-    processed_soc_path = DATA_INTERMEDIATE_DIR / "soc_structure.csv"
-    df_soc.to_csv(processed_soc_path, index=False)
-
-    print(f"✓ Processed {len(df_soc):,} SOC entries")
-
-    return df_soc
-
-
-def main():
-    """Main function to run O*NET/SOC preprocessing."""
-    # Check if files already exist
-    if check_existing_files():
-        return
-
-    # Process Task Statements
-    df_tasks_raw = load_task_data()
-    process_task_data(df_tasks_raw)
-
-    # Process SOC Structure
-    df_soc_raw = load_soc_data()
-    process_soc_data(df_soc_raw)
-
-    print("\n✅ O*NET/SOC data preprocessing complete!")
-
-
-if __name__ == "__main__":
-    main()

release_2025_09_15/code/preprocess_population.py

@@ -1,407 +0,0 @@
-"""
-Preprocess population data for economic analysis.
-
-This script downloads and processes working-age population data (ages 15-64) from:
-1. World Bank API for country-level data
-2. Taiwan National Development Council for Taiwan data (not in World Bank)
-3. US Census Bureau for US state-level data
-
-Output files:
-- working_age_pop_YYYY_country.csv (e.g., working_age_pop_2024_country.csv): Country-level working age population
-- working_age_pop_YYYY_us_state.csv (e.g., working_age_pop_2024_us_state.csv): US state-level working age population
-"""
-
-import io
-import warnings
-from pathlib import Path
-
-import httpx
-import pandas as pd
-
-# Global configuration
-YEAR = 2024
-DATA_INPUT_DIR = Path("../data/input")
-DATA_INTERMEDIATE_DIR = Path("../data/intermediate")
-
-# Countries where Claude AI service is not available
-# These will be excluded from all population data
-EXCLUDED_COUNTRIES = [
-    "AF",  # Afghanistan
-    "BY",  # Belarus
-    "CD",  # Democratic Republic of the Congo
-    "CF",  # Central African Republic
-    "CN",  # China
-    "CU",  # Cuba
-    "ER",  # Eritrea
-    "ET",  # Ethiopia
-    "HK",  # Hong Kong
-    "IR",  # Iran
-    "KP",  # North Korea
-    "LY",  # Libya
-    "ML",  # Mali
-    "MM",  # Myanmar
-    "MO",  # Macau
-    "NI",  # Nicaragua
-    "RU",  # Russia
-    "SD",  # Sudan
-    "SO",  # Somalia
-    "SS",  # South Sudan
-    "SY",  # Syria
-    "VE",  # Venezuela
-    "YE",  # Yemen
-]
-
-
-def check_existing_files():
-    """Check if processed population files already exist."""
-    processed_country_pop_path = (
-        DATA_INTERMEDIATE_DIR / f"working_age_pop_{YEAR}_country.csv"
-    )
-    processed_state_pop_path = (
-        DATA_INTERMEDIATE_DIR / f"working_age_pop_{YEAR}_us_state.csv"
-    )
-
-    if processed_country_pop_path.exists() and processed_state_pop_path.exists():
-        print("✅ Population files already exist:")
-        print(f"  - {processed_country_pop_path}")
-        print(f"  - {processed_state_pop_path}")
-        print(
-            "Skipping population preprocessing. Delete these files if you want to re-run."
-        )
-        return True
-    return False
-
-
-def load_world_bank_population_data():
-    """
-    Load country-level working age population data from cache or World Bank API.
-
-    Returns:
-        pd.DataFrame: Raw population data from World Bank
-    """
-    # Check if raw data already exists
-    raw_country_pop_path = DATA_INPUT_DIR / f"working_age_pop_{YEAR}_country_raw.csv"
-    if raw_country_pop_path.exists():
-        print("Loading cached country population data...")
-        return pd.read_csv(raw_country_pop_path, keep_default_na=False, na_values=[""])
-
-    # Download if not cached
-    url = "https://api.worldbank.org/v2/country/all/indicator/SP.POP.1564.TO"
-    params = {"format": "json", "date": str(YEAR), "per_page": "1000"}
-
-    print("Downloading country population data from World Bank API...")
-    response = httpx.get(url, params=params)
-    response.raise_for_status()
-
-    # World Bank API returns [metadata, data] structure
-    data = response.json()[1]
-    df_raw = pd.json_normalize(data)
-
-    return df_raw
-
-
-def filter_to_country_level_data(df_raw):
-    """
-    Filter World Bank data to exclude regional aggregates and keep only countries.
-
-    The World Bank data starts with regional aggregates (Arab World, Caribbean small states, etc.)
-    followed by actual countries starting with Afghanistan (AFG).
-
-    Args:
-        df_raw: Raw World Bank data
-
-    Returns:
-        pd.DataFrame: Filtered data with only country-level records
-    """
-    # Find Afghanistan (AFG) - the first real country after aggregates
-    afg_index = df_raw[df_raw["countryiso3code"] == "AFG"].index[0]
-
-    # Keep everything from AFG onwards
-    df_filtered = df_raw.iloc[afg_index:].copy()
-    print(f"Filtered to {len(df_filtered)} countries (excluding regional aggregates)")
-
-    return df_filtered
-
-
-def process_country_population_data(df_raw):
-    """
-    Process raw World Bank population data.
-
-    Args:
-        df_raw: Raw data from World Bank API
-
-    Returns:
-        pd.DataFrame: Processed country population data (excluding countries where service is not available)
-    """
-    # Filter to country level only
-    df_country = filter_to_country_level_data(df_raw)
-
-    # Select and rename columns
-    df_processed = df_country[
-        ["countryiso3code", "date", "value", "country.id", "country.value"]
-    ].copy()
-
-    df_processed.columns = [
-        "iso_alpha_3",
-        "year",
-        "working_age_pop",
-        "country_code",
-        "country_name",
-    ]
-
-    # Convert year to int
-    df_processed["year"] = pd.to_numeric(df_processed["year"])
-    df_processed = df_processed.dropna(subset=["working_age_pop"])
-
-    # Remove Channel Islands entry with invalid JG code
-    channel_islands_mask = df_processed["country_code"] == "JG"
-    if channel_islands_mask.any():
-        print(f"Removing Channel Islands entry with invalid code 'JG'")
-        df_processed = df_processed[~channel_islands_mask].copy()
-
-    # Exclude countries where service is not available
-    initial_count = len(df_processed)
-    df_processed = df_processed[~df_processed["country_code"].isin(EXCLUDED_COUNTRIES)]
-    excluded_count = initial_count - len(df_processed)
-
-    if excluded_count > 0:
-        print(f"Excluded {excluded_count} countries where service is not available")
-
-    return df_processed
-
-
-def add_taiwan_population(df_country):
-    """
-    Add Taiwan population data from National Development Council.
-
-    The World Bank API excludes Taiwan, so we use data directly from Taiwan's NDC.
-    Source: https://pop-proj.ndc.gov.tw/main_en/Custom_Detail_Statistics_Search.aspx
-
-    Args:
-        df_country: Country population dataframe
-
-    Returns:
-        pd.DataFrame: Country data with Taiwan added
-    """
-    taiwan_file = DATA_INPUT_DIR / "Population by single age _20250903072924.csv"
-
-    if not taiwan_file.exists():
-        error_msg = f"""
-Taiwan population data not found at: {taiwan_file}
-
-To obtain this data:
-1. Go to: https://pop-proj.ndc.gov.tw/main_en/Custom_Detail_Statistics_Search.aspx?n=175&_Query=258170a1-1394-49fe-8d21-dc80562b72fb&page=1&PageSize=10&ToggleType=
-2. The following options should have been selected:
-   - Estimate type: Medium variant
-   - Gender: Total
-   - Year: {YEAR}
-   - Age: Single age (ages 15-64)
-   - Data attribute: data value
-3. Download the CSV file
-4. Save it as: "Population by single age _20250903072924.csv"
-5. Place it in your data input directory
-
-Note: Taiwan data is not available from World Bank API and must be obtained separately.
-"""
-        raise FileNotFoundError(error_msg)
-
-    print("Adding Taiwan population data from NDC...")
-
-    # Load the NDC data (skip metadata rows)
-    df_taiwan = pd.read_csv(taiwan_file, skiprows=10)
-
-    # Clean the age column and sum population
-    df_taiwan["Age"] = df_taiwan["Age"].str.replace("'", "")
-    df_taiwan["Age"] = pd.to_numeric(df_taiwan["Age"])
-
-    # The data is pre-filtered to ages 15-64, so sum all values
-    taiwan_working_age_pop = df_taiwan["Data value (persons)"].sum()
-
-    # Create Taiwan row
-    taiwan_row = pd.DataFrame(
-        {
-            "iso_alpha_3": ["TWN"],
-            "year": [YEAR],
-            "working_age_pop": [taiwan_working_age_pop],
-            "country_code": ["TW"],
-            "country_name": ["Taiwan"],
-        }
-    )
-
-    # Add Taiwan to the country data
-    df_with_taiwan = pd.concat([df_country, taiwan_row], ignore_index=True)
-    print(f"Added Taiwan: {taiwan_working_age_pop:,.0f} working age population")
-
-    return df_with_taiwan
-
-
-def load_us_state_population_data():
-    """
-    Load US state population data from cache or Census Bureau.
-
-    Returns:
-        pd.DataFrame: Raw US state population data
-    """
-    # Check if raw data already exists
-    raw_state_pop_path = DATA_INPUT_DIR / f"sc-est{YEAR}-agesex-civ.csv"
-    if raw_state_pop_path.exists():
-        print("Loading cached state population data...")
-        return pd.read_csv(raw_state_pop_path)
-
-    # Download if not cached
-    url = f"https://www2.census.gov/programs-surveys/popest/datasets/2020-{YEAR}/state/asrh/sc-est{YEAR}-agesex-civ.csv"
-
-    print("Downloading US state population data from Census Bureau...")
-    response = httpx.get(url)
-    response.raise_for_status()
-
-    df_raw = pd.read_csv(io.StringIO(response.text))
-    return df_raw
-
-
-def process_state_population_data(df_raw):
-    """
-    Process US state population data to get working age population.
-
-    Args:
-        df_raw: Raw Census Bureau data
-
-    Returns:
-        pd.DataFrame: Processed state population data with state codes
-    """
-    # Filter for working age (15-64) and sum by state
-    # SEX=0 means "Both sexes" to avoid double counting
-    df_working_age = df_raw[
-        (df_raw["AGE"] >= 15) & (df_raw["AGE"] <= 64) & (df_raw["SEX"] == 0)
-    ]
-
-    # Sum by state
-    working_age_by_state = (
-        df_working_age.groupby("NAME")[f"POPEST{YEAR}_CIV"].sum().reset_index()
-    )
-    working_age_by_state.columns = ["state", "working_age_pop"]
-
-    # Get state codes
-    state_code_dict = get_state_codes()
-
-    # Filter out "United States" row (national total, not a state)
-    working_age_by_state = working_age_by_state[
-        working_age_by_state["state"] != "United States"
-    ]
-
-    # Map state names to abbreviations
-    working_age_by_state["state_code"] = working_age_by_state["state"].map(
-        state_code_dict
-    )
-
-    # Check for missing state codes (should be none after filtering United States)
-    missing_codes = working_age_by_state[working_age_by_state["state_code"].isna()]
-    if not missing_codes.empty:
-        warnings.warn(
-            f"Could not find state codes for: {missing_codes['state'].tolist()}",
-            UserWarning,
-            stacklevel=2,
-        )
-
-    return working_age_by_state
-
-
-def get_state_codes():
-    """
-    Get US state codes from Census Bureau.
-
-    Returns:
-        dict: Mapping of state names to abbreviations
-    """
-    state_codes_path = DATA_INPUT_DIR / "census_state_codes.txt"
-
-    if state_codes_path.exists():
-        print("Loading cached state codes...")
-        df_state_codes = pd.read_csv(state_codes_path, sep="|")
-    else:
-        print("Downloading state codes from Census Bureau...")
-        response = httpx.get("https://www2.census.gov/geo/docs/reference/state.txt")
-        response.raise_for_status()
-
-        # Save for future use
-        with open(state_codes_path, "w") as f:
-            f.write(response.text)
-        print(f"Cached state codes to {state_codes_path}")
-
-        df_state_codes = pd.read_csv(io.StringIO(response.text), sep="|")
-
-    # Create mapping dictionary
-    state_code_dict = dict(
-        zip(df_state_codes["STATE_NAME"], df_state_codes["STUSAB"], strict=True)
-    )
-
-    return state_code_dict
-
-
-def save_data(df_country, df_state, df_world_bank_raw, df_state_raw):
-    """
-    Save raw and processed population data.
-
-    Args:
-        df_country: Processed country population data
-        df_state: Processed state population data
-        df_world_bank_raw: Raw World Bank data
-        df_state_raw: Raw Census Bureau data
-    """
-    # Save raw data (only if doesn't exist)
-    raw_country_pop_path = DATA_INPUT_DIR / f"working_age_pop_{YEAR}_country_raw.csv"
-    if not raw_country_pop_path.exists():
-        df_world_bank_raw.to_csv(raw_country_pop_path, index=False)
-        print(f"Saved raw country data to {raw_country_pop_path}")
-
-    raw_state_pop_path = DATA_INPUT_DIR / f"sc-est{YEAR}-agesex-civ.csv"
-    if not raw_state_pop_path.exists():
-        df_state_raw.to_csv(raw_state_pop_path, index=False)
-        print(f"Saved raw state data to {raw_state_pop_path}")
-
-    # Save processed data
-    country_output_path = DATA_INTERMEDIATE_DIR / f"working_age_pop_{YEAR}_country.csv"
-    df_country.to_csv(country_output_path, index=False)
-    print(f"Saved processed country population data to {country_output_path}")
-
-    state_output_path = DATA_INTERMEDIATE_DIR / f"working_age_pop_{YEAR}_us_state.csv"
-    df_state.to_csv(state_output_path, index=False)
-    print(f"Saved processed US state population data to {state_output_path}")
-
-
-def main():
-    """Main function to run population preprocessing."""
-    # Check if files already exist
-    if check_existing_files():
-        return
-
-    # Process country-level data
-    print("\n=== Processing Country-Level Population Data ===")
-    df_world_bank_raw = load_world_bank_population_data()
-    df_country = process_country_population_data(df_world_bank_raw)
-    df_country = add_taiwan_population(df_country)
-
-    # Process US state-level data
-    print("\n=== Processing US State-Level Population Data ===")
-    df_state_raw = load_us_state_population_data()
-    df_state = process_state_population_data(df_state_raw)
-
-    # Save all data (raw and processed)
-    print("\n=== Saving Data ===")
-    save_data(df_country, df_state, df_world_bank_raw, df_state_raw)
-
-    print("\n✅ Population data preprocessing complete!")
-
-    # Print summary statistics
-    print("\n=== Summary Statistics ===")
-    print(f"Countries processed: {len(df_country)}")
-    print(f"Countries excluded (service not available): {len(EXCLUDED_COUNTRIES)}")
-    print(
-        f"Total global working age population: {df_country['working_age_pop'].sum():,.0f}"
-    )
-    print(f"US states processed: {len(df_state)}")
-    print(f"Total US working age population: {df_state['working_age_pop'].sum():,.0f}")
-
-
-if __name__ == "__main__":
-    main()

release_2025_09_15/data/input/BTOS_National.xlsx

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:c55e2fc6892941a1a536e87445de0bee8ea327526081389b93b85c54a8d69761
-size 63052

release_2025_09_15/data/input/Population by single age _20250903072924.csv

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:89c1e953dbab481760a966c40bdb121ed4e301b4cd0cbaea8a44990caa91ce8e
-size 2176

release_2025_09_15/data/input/automation_vs_augmentation_v1.csv

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:d1e264882b17618db4f4a00b6f87f48134222bc5c15eefb3d46aae9519e89d11
-size 197

release_2025_09_15/data/input/automation_vs_augmentation_v2.csv

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:0d7d8b1666f3d942d728f9b2177681ca6756edfe01fb8fc130e29264d41a391e
-size 198

release_2025_09_15/data/input/bea_us_state_gdp_2024.csv

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:913bc0d017570e711c71bc838016b3b52cbf49e717d0cabc4cc2d70306acfa5a
-size 1663

release_2025_09_15/data/input/census_state_codes.txt

@@ -1,58 +0,0 @@
-STATE|STUSAB|STATE_NAME|STATENS
-01|AL|Alabama|01779775
-02|AK|Alaska|01785533
-04|AZ|Arizona|01779777
-05|AR|Arkansas|00068085
-06|CA|California|01779778
-08|CO|Colorado|01779779
-09|CT|Connecticut|01779780
-10|DE|Delaware|01779781
-11|DC|District of Columbia|01702382
-12|FL|Florida|00294478
-13|GA|Georgia|01705317
-15|HI|Hawaii|01779782
-16|ID|Idaho|01779783
-17|IL|Illinois|01779784
-18|IN|Indiana|00448508
-19|IA|Iowa|01779785
-20|KS|Kansas|00481813
-21|KY|Kentucky|01779786
-22|LA|Louisiana|01629543
-23|ME|Maine|01779787
-24|MD|Maryland|01714934
-25|MA|Massachusetts|00606926
-26|MI|Michigan|01779789
-27|MN|Minnesota|00662849
-28|MS|Mississippi|01779790
-29|MO|Missouri|01779791
-30|MT|Montana|00767982
-31|NE|Nebraska|01779792
-32|NV|Nevada|01779793
-33|NH|New Hampshire|01779794
-34|NJ|New Jersey|01779795
-35|NM|New Mexico|00897535
-36|NY|New York|01779796
-37|NC|North Carolina|01027616
-38|ND|North Dakota|01779797
-39|OH|Ohio|01085497
-40|OK|Oklahoma|01102857
-41|OR|Oregon|01155107
-42|PA|Pennsylvania|01779798
-44|RI|Rhode Island|01219835
-45|SC|South Carolina|01779799
-46|SD|South Dakota|01785534
-47|TN|Tennessee|01325873
-48|TX|Texas|01779801
-49|UT|Utah|01455989
-50|VT|Vermont|01779802
-51|VA|Virginia|01779803
-53|WA|Washington|01779804
-54|WV|West Virginia|01779805
-55|WI|Wisconsin|01779806
-56|WY|Wyoming|01779807
-60|AS|American Samoa|01802701
-66|GU|Guam|01802705
-69|MP|Northern Mariana Islands|01779809
-72|PR|Puerto Rico|01779808
-74|UM|U.S. Minor Outlying Islands|01878752
-78|VI|U.S. Virgin Islands|01802710

release_2025_09_15/data/input/geonames_countryInfo.txt

@@ -1,302 +0,0 @@
-# ================================
-#
-#
-# CountryCodes:
-# ============
-#
-# The official ISO country code for the United Kingdom is 'GB'. The code 'UK' is reserved.
-#
-# A list of dependent countries is available here:
-# https://spreadsheets.google.com/ccc?key=pJpyPy-J5JSNhe7F_KxwiCA&hl=en
-#
-#
-# The countrycode XK temporarily stands for Kosvo:
-# http://geonames.wordpress.com/2010/03/08/xk-country-code-for-kosovo/								
-#
-#
-# CS (Serbia and Montenegro) with geonameId = 8505033 no longer exists.
-# AN (the Netherlands Antilles) with geonameId = 8505032 was dissolved on 10 October 2010.
-#
-#
-# Currencies :
-# ============
-#
-# A number of territories are not included in ISO 4217, because their currencies are not per se an independent currency,															
-# but a variant of another currency. These currencies are:
-#
-# 1. FO : Faroese krona (1:1 pegged to the Danish krone)				
-# 2. GG : Guernsey pound (1:1 pegged to the pound sterling)
-# 3. JE : Jersey pound (1:1 pegged to the pound sterling)			
-# 4. IM : Isle of Man pound (1:1 pegged to the pound sterling)																		
-# 5. TV : Tuvaluan dollar (1:1 pegged to the Australian dollar).											
-# 6. CK : Cook Islands dollar (1:1 pegged to the New Zealand dollar).				
-#	
-# The following non-ISO codes are, however, sometimes used: GGP for the Guernsey pound, 																		
-# JEP for the Jersey pound and IMP for the Isle of Man pound (http://en.wikipedia.org/wiki/ISO_4217)																		
-#	
-#																		
-# A list of currency symbols is available here : http://forum.geonames.org/gforum/posts/list/437.page																		
-# another list with fractional units is here: http://forum.geonames.org/gforum/posts/list/1961.page																		
-#																		
-#																		
-# Languages :																		
-# ===========																		
-#																		
-# The column 'languages' lists the languages spoken in a country ordered by the number of speakers. The language code is a 'locale' 																		
-# where any two-letter primary-tag is an ISO-639 language abbreviation and any two-letter initial subtag is an ISO-3166 country code.																		
-#																		
-# Example : es-AR is the Spanish variant spoken in Argentina.																		
-#																		
-#ISO	ISO3	ISO-Numeric	fips	Country	Capital	Area(in sq km)	Population	Continent	tld	CurrencyCode	CurrencyName	Phone	Postal Code Format	Postal Code Regex	Languages	geonameid	neighbours	EquivalentFipsCode
-AD	AND	020	AN	Andorra	Andorra la Vella	468	77006	EU	.ad	EUR	Euro	376	AD###	^(?:AD)*(\d{3})$	ca	3041565	ES,FR	
-AE	ARE	784	AE	United Arab Emirates	Abu Dhabi	82880	9630959	AS	.ae	AED	Dirham	971	##### #####	^\d{5}-\d{5}$	ar-AE,fa,en,hi,ur	290557	SA,OM	
-AF	AFG	004	AF	Afghanistan	Kabul	647500	37172386	AS	.af	AFN	Afghani	93			fa-AF,ps,uz-AF,tk	1149361	TM,CN,IR,TJ,PK,UZ	
-AG	ATG	028	AC	Antigua and Barbuda	St. John's	443	96286	NA	.ag	XCD	Dollar	+1-268			en-AG	3576396		
-AI	AIA	660	AV	Anguilla	The Valley	102	13254	NA	.ai	XCD	Dollar	+1-264	AI-####	^(?:AZ)*(\d{4})$	en-AI	3573511		
-AL	ALB	008	AL	Albania	Tirana	28748	2866376	EU	.al	ALL	Lek	355	####	^(\d{4})$	sq,el	783754	MK,GR,ME,RS,XK	
-AM	ARM	051	AM	Armenia	Yerevan	29800	3076200	AS	.am	AMD	Dram	374	######	^(\d{6})$	hy	174982	GE,IR,AZ,TR	
-AO	AGO	024	AO	Angola	Luanda	1246700	30809762	AF	.ao	AOA	Kwanza	244			pt-AO	3351879	CD,NA,ZM,CG	
-AQ	ATA	010	AY	Antarctica		14000000	0	AN	.aq							6697173		
-AR	ARG	032	AR	Argentina	Buenos Aires	2766890	44494502	SA	.ar	ARS	Peso	54	@####@@@	^[A-Z]?\d{4}[A-Z]{0,3}$	es-AR,en,it,de,fr,gn	3865483	CL,BO,UY,PY,BR	
-AS	ASM	016	AQ	American Samoa	Pago Pago	199	55465	OC	.as	USD	Dollar	+1-684	#####-####	96799	en-AS,sm,to	5880801		
-AT	AUT	040	AU	Austria	Vienna	83858	8847037	EU	.at	EUR	Euro	43	####	^(\d{4})$	de-AT,hr,hu,sl	2782113	CH,DE,HU,SK,CZ,IT,SI,LI	
-AU	AUS	036	AS	Australia	Canberra	7686850	24992369	OC	.au	AUD	Dollar	61	####	^(\d{4})$	en-AU	2077456		
-AW	ABW	533	AA	Aruba	Oranjestad	193	105845	NA	.aw	AWG	Guilder	297			nl-AW,pap,es,en	3577279		
-AX	ALA	248		Aland Islands	Mariehamn	1580	26711	EU	.ax	EUR	Euro	+358-18	#####	^(?:FI)*(\d{5})$	sv-AX	661882		FI
-AZ	AZE	031	AJ	Azerbaijan	Baku	86600	9942334	AS	.az	AZN	Manat	994	AZ ####	^(?:AZ )*(\d{4})$	az,ru,hy	587116	GE,IR,AM,TR,RU	
-BA	BIH	070	BK	Bosnia and Herzegovina	Sarajevo	51129	3323929	EU	.ba	BAM	Marka	387	#####	^(\d{5})$	bs,hr-BA,sr-BA	3277605	HR,ME,RS	
-BB	BRB	052	BB	Barbados	Bridgetown	431	286641	NA	.bb	BBD	Dollar	+1-246	BB#####	^(?:BB)*(\d{5})$	en-BB	3374084		
-BD	BGD	050	BG	Bangladesh	Dhaka	144000	161356039	AS	.bd	BDT	Taka	880	####	^(\d{4})$	bn-BD,en	1210997	MM,IN	
-BE	BEL	056	BE	Belgium	Brussels	30510	11422068	EU	.be	EUR	Euro	32	####	^(\d{4})$	nl-BE,fr-BE,de-BE	2802361	DE,NL,LU,FR	
-BF	BFA	854	UV	Burkina Faso	Ouagadougou	274200	19751535	AF	.bf	XOF	Franc	226			fr-BF,mos	2361809	NE,BJ,GH,CI,TG,ML	
-BG	BGR	100	BU	Bulgaria	Sofia	110910	7000039	EU	.bg	BGN	Lev	359	####	^(\d{4})$	bg,tr-BG,rom	732800	MK,GR,RO,TR,RS	
-BH	BHR	048	BA	Bahrain	Manama	665	1569439	AS	.bh	BHD	Dinar	973	####|###	^(\d{3}\d?)$	ar-BH,en,fa,ur	290291		
-BI	BDI	108	BY	Burundi	Gitega	27830	11175378	AF	.bi	BIF	Franc	257			fr-BI,rn	433561	TZ,CD,RW	
-BJ	BEN	204	BN	Benin	Porto-Novo	112620	11485048	AF	.bj	XOF	Franc	229			fr-BJ	2395170	NE,TG,BF,NG	
-BL	BLM	652	TB	Saint Barthelemy	Gustavia	21	8450	NA	.gp	EUR	Euro	590	#####	^(\d{5})$	fr	3578476		
-BM	BMU	060	BD	Bermuda	Hamilton	53	63968	NA	.bm	BMD	Dollar	+1-441	@@ ##	^([A-Z]{2}\d{2})$	en-BM,pt	3573345		
-BN	BRN	096	BX	Brunei	Bandar Seri Begawan	5770	428962	AS	.bn	BND	Dollar	673	@@####	^([A-Z]{2}\d{4})$	ms-BN,en-BN	1820814	MY	
-BO	BOL	068	BL	Bolivia	Sucre	1098580	11353142	SA	.bo	BOB	Boliviano	591			es-BO,qu,ay	3923057	PE,CL,PY,BR,AR	
-BQ	BES	535		Bonaire, Saint Eustatius and Saba 		328	18012	NA	.bq	USD	Dollar	599			nl,pap,en	7626844		
-BR	BRA	076	BR	Brazil	Brasilia	8511965	209469333	SA	.br	BRL	Real	55	#####-###	^\d{5}-\d{3}$	pt-BR,es,en,fr	3469034	SR,PE,BO,UY,GY,PY,GF,VE,CO,AR	
-BS	BHS	044	BF	Bahamas	Nassau	13940	385640	NA	.bs	BSD	Dollar	+1-242			en-BS	3572887		
-BT	BTN	064	BT	Bhutan	Thimphu	47000	754394	AS	.bt	BTN	Ngultrum	975			dz	1252634	CN,IN	
-BV	BVT	074	BV	Bouvet Island		49	0	AN	.bv	NOK	Krone					3371123		
-BW	BWA	072	BC	Botswana	Gaborone	600370	2254126	AF	.bw	BWP	Pula	267			en-BW,tn-BW	933860	ZW,ZA,NA	
-BY	BLR	112	BO	Belarus	Minsk	207600	9485386	EU	.by	BYN	Belarusian ruble	375	######	^(\d{6})$	be,ru	630336	PL,LT,UA,RU,LV	
-BZ	BLZ	084	BH	Belize	Belmopan	22966	383071	NA	.bz	BZD	Dollar	501			en-BZ,es	3582678	GT,MX	
-CA	CAN	124	CA	Canada	Ottawa	9984670	37058856	NA	.ca	CAD	Dollar	1	@#@ #@#	^([ABCEGHJKLMNPRSTVXY]\d[ABCEGHJKLMNPRSTVWXYZ]) ?(\d[ABCEGHJKLMNPRSTVWXYZ]\d)$ 	en-CA,fr-CA,iu	6251999	US	
-CC	CCK	166	CK	Cocos Islands	West Island	14	628	AS	.cc	AUD	Dollar	61	####	^(\d{4})$	ms-CC,en	1547376		
-CD	COD	180	CG	Democratic Republic of the Congo	Kinshasa	2345410	84068091	AF	.cd	CDF	Franc	243			fr-CD,ln,ktu,kg,sw,lua	203312	TZ,CF,SS,RW,ZM,BI,UG,CG,AO	
-CF	CAF	140	CT	Central African Republic	Bangui	622984	4666377	AF	.cf	XAF	Franc	236			fr-CF,sg,ln,kg	239880	TD,SD,CD,SS,CM,CG	
-CG	COG	178	CF	Republic of the Congo	Brazzaville	342000	5244363	AF	.cg	XAF	Franc	242			fr-CG,kg,ln-CG	2260494	CF,GA,CD,CM,AO	
-CH	CHE	756	SZ	Switzerland	Bern	41290	8516543	EU	.ch	CHF	Franc	41	####	^(\d{4})$	de-CH,fr-CH,it-CH,rm	2658434	DE,IT,LI,FR,AT	
-CI	CIV	384	IV	Ivory Coast	Yamoussoukro	322460	25069229	AF	.ci	XOF	Franc	225			fr-CI	2287781	LR,GH,GN,BF,ML	
-CK	COK	184	CW	Cook Islands	Avarua	240	21388	OC	.ck	NZD	Dollar	682			en-CK,mi	1899402		
-CL	CHL	152	CI	Chile	Santiago	756950	18729160	SA	.cl	CLP	Peso	56	#######	^(\d{7})$	es-CL	3895114	PE,BO,AR	
-CM	CMR	120	CM	Cameroon	Yaounde	475440	25216237	AF	.cm	XAF	Franc	237			en-CM,fr-CM	2233387	TD,CF,GA,GQ,CG,NG	
-CN	CHN	156	CH	China	Beijing	9596960	1411778724	AS	.cn	CNY	Yuan Renminbi	86	######	^(\d{6})$	zh-CN,yue,wuu,dta,ug,za	1814991	LA,BT,TJ,KZ,MN,AF,NP,MM,KG,PK,KP,RU,VN,IN	
-CO	COL	170	CO	Colombia	Bogota	1138910	49648685	SA	.co	COP	Peso	57	######	^(\d{6})$	es-CO	3686110	EC,PE,PA,BR,VE	
-CR	CRI	188	CS	Costa Rica	San Jose	51100	4999441	NA	.cr	CRC	Colon	506	#####	^(\d{5})$	es-CR,en	3624060	PA,NI	
-CU	CUB	192	CU	Cuba	Havana	110860	11338138	NA	.cu	CUP	Peso	53	CP #####	^(?:CP)*(\d{5})$	es-CU,pap	3562981	US	
-CV	CPV	132	CV	Cabo Verde	Praia	4033	543767	AF	.cv	CVE	Escudo	238	####	^(\d{4})$	pt-CV	3374766		
-CW	CUW	531	UC	Curacao	 Willemstad	444	159849	NA	.cw	ANG	Guilder	599			nl,pap	7626836		
-CX	CXR	162	KT	Christmas Island	Flying Fish Cove	135	1500	OC	.cx	AUD	Dollar	61	####	^(\d{4})$	en,zh,ms-CX	2078138		
-CY	CYP	196	CY	Cyprus	Nicosia	9250	1189265	EU	.cy	EUR	Euro	357	####	^(\d{4})$	el-CY,tr-CY,en	146669		
-CZ	CZE	203	EZ	Czechia	Prague	78866	10625695	EU	.cz	CZK	Koruna	420	### ##	^\d{3}\s?\d{2}$	cs,sk	3077311	PL,DE,SK,AT	
-DE	DEU	276	GM	Germany	Berlin	357021	82927922	EU	.de	EUR	Euro	49	#####	^(\d{5})$	de	2921044	CH,PL,NL,DK,BE,CZ,LU,FR,AT	
-DJ	DJI	262	DJ	Djibouti	Djibouti	23000	958920	AF	.dj	DJF	Franc	253			fr-DJ,ar,so-DJ,aa	223816	ER,ET,SO	
-DK	DNK	208	DA	Denmark	Copenhagen	43094	5797446	EU	.dk	DKK	Krone	45	####	^(\d{4})$	da-DK,en,fo,de-DK	2623032	DE	
-DM	DMA	212	DO	Dominica	Roseau	754	71625	NA	.dm	XCD	Dollar	+1-767			en-DM	3575830		
-DO	DOM	214	DR	Dominican Republic	Santo Domingo	48730	10627165	NA	.do	DOP	Peso	+1-809 and 1-829	#####	^(\d{5})$	es-DO	3508796	HT	
-DZ	DZA	012	AG	Algeria	Algiers	2381740	42228429	AF	.dz	DZD	Dinar	213	#####	^(\d{5})$	ar-DZ	2589581	NE,EH,LY,MR,TN,MA,ML	
-EC	ECU	218	EC	Ecuador	Quito	283560	17084357	SA	.ec	USD	Dollar	593	@####@	^([a-zA-Z]\d{4}[a-zA-Z])$	es-EC	3658394	PE,CO	
-EE	EST	233	EN	Estonia	Tallinn	45226	1320884	EU	.ee	EUR	Euro	372	#####	^(\d{5})$	et,ru	453733	RU,LV	
-EG	EGY	818	EG	Egypt	Cairo	1001450	98423595	AF	.eg	EGP	Pound	20	#####	^(\d{5})$	ar-EG,en,fr	357994	LY,SD,IL,PS	
-EH	ESH	732	WI	Western Sahara	El-Aaiun	266000	273008	AF	.eh	MAD	Dirham	212			ar,mey	2461445	DZ,MR,MA	
-ER	ERI	232	ER	Eritrea	Asmara	121320	6209262	AF	.er	ERN	Nakfa	291			aa-ER,ar,tig,kun,ti-ER	338010	ET,SD,DJ	
-ES	ESP	724	SP	Spain	Madrid	504782	46723749	EU	.es	EUR	Euro	34	#####	^(\d{5})$	es-ES,ca,gl,eu,oc	2510769	AD,PT,GI,FR,MA	
-ET	ETH	231	ET	Ethiopia	Addis Ababa	1127127	109224559	AF	.et	ETB	Birr	251	####	^(\d{4})$	am,en-ET,om-ET,ti-ET,so-ET,sid	337996	ER,KE,SD,SS,SO,DJ	
-FI	FIN	246	FI	Finland	Helsinki	337030	5518050	EU	.fi	EUR	Euro	358	#####	^(?:FI)*(\d{5})$	fi-FI,sv-FI,smn	660013	NO,RU,SE	
-FJ	FJI	242	FJ	Fiji	Suva	18270	883483	OC	.fj	FJD	Dollar	679			en-FJ,fj	2205218		
-FK	FLK	238	FK	Falkland Islands	Stanley	12173	2638	SA	.fk	FKP	Pound	500	FIQQ 1ZZ	FIQQ 1ZZ	en-FK	3474414		
-FM	FSM	583	FM	Micronesia	Palikir	702	112640	OC	.fm	USD	Dollar	691	#####	^(\d{5})$	en-FM,chk,pon,yap,kos,uli,woe,nkr,kpg	2081918		
-FO	FRO	234	FO	Faroe Islands	Torshavn	1399	48497	EU	.fo	DKK	Krone	298	###	^(?:FO)*(\d{3})$	fo,da-FO	2622320		
-FR	FRA	250	FR	France	Paris	547030	66987244	EU	.fr	EUR	Euro	33	#####	^(\d{5})$	fr-FR,frp,br,co,ca,eu,oc	3017382	CH,DE,BE,LU,IT,AD,MC,ES	
-GA	GAB	266	GB	Gabon	Libreville	267667	2119275	AF	.ga	XAF	Franc	241			fr-GA	2400553	CM,GQ,CG	
-GB	GBR	826	UK	United Kingdom	London	244820	66488991	EU	.uk	GBP	Pound	44	@# #@@|@## #@@|@@# #@@|@@## #@@|@#@ #@@|@@#@ #@@|GIR0AA	^([Gg][Ii][Rr]\s?0[Aa]{2})|((([A-Za-z][0-9]{1,2})|(([A-Za-z][A-Ha-hJ-Yj-y][0-9]{1,2})|(([A-Za-z][0-9][A-Za-z])|([A-Za-z][A-Ha-hJ-Yj-y][0-9]?[A-Za-z]))))\s?[0-9][A-Za-z]{2})$	en-GB,cy-GB,gd	2635167	IE	
-GD	GRD	308	GJ	Grenada	St. George's	344	111454	NA	.gd	XCD	Dollar	+1-473			en-GD	3580239		
-GE	GEO	268	GG	Georgia	Tbilisi	69700	3731000	AS	.ge	GEL	Lari	995	####	^(\d{4})$	ka,ru,hy,az	614540	AM,AZ,TR,RU	
-GF	GUF	254	FG	French Guiana	Cayenne	91000	195506	SA	.gf	EUR	Euro	594	#####	^((97|98)3\d{2})$	fr-GF	3381670	SR,BR	
-GG	GGY	831	GK	Guernsey	St Peter Port	78	65228	EU	.gg	GBP	Pound	+44-1481	@# #@@|@## #@@|@@# #@@|@@## #@@|@#@ #@@|@@#@ #@@|GIR0AA	^((?:(?:[A-PR-UWYZ][A-HK-Y]\d[ABEHMNPRV-Y0-9]|[A-PR-UWYZ]\d[A-HJKPS-UW0-9])\s\d[ABD-HJLNP-UW-Z]{2})|GIR\s?0AA)$	en,nrf	3042362		
-GH	GHA	288	GH	Ghana	Accra	239460	29767108	AF	.gh	GHS	Cedi	233			en-GH,ak,ee,tw	2300660	CI,TG,BF	
-GI	GIB	292	GI	Gibraltar	Gibraltar	6.5	33718	EU	.gi	GIP	Pound	350	GX11 1AA	GX11 1AA	en-GI,es,it,pt	2411586	ES	
-GL	GRL	304	GL	Greenland	Nuuk	2166086	56025	NA	.gl	DKK	Krone	299	####	^(\d{4})$	kl,da-GL,en	3425505		
-GM	GMB	270	GA	Gambia	Banjul	11300	2280102	AF	.gm	GMD	Dalasi	220			en-GM,mnk,wof,wo,ff	2413451	SN	
-GN	GIN	324	GV	Guinea	Conakry	245857	12414318	AF	.gn	GNF	Franc	224			fr-GN	2420477	LR,SN,SL,CI,GW,ML	
-GP	GLP	312	GP	Guadeloupe	Basse-Terre	1780	443000	NA	.gp	EUR	Euro	590	#####	^((97|98)\d{3})$	fr-GP	3579143		
-GQ	GNQ	226	EK	Equatorial Guinea	Malabo	28051	1308974	AF	.gq	XAF	Franc	240			es-GQ,fr,pt	2309096	GA,CM	
-GR	GRC	300	GR	Greece	Athens	131940	10727668	EU	.gr	EUR	Euro	30	### ##	^(\d{5})$	el-GR,en,fr	390903	AL,MK,TR,BG	
-GS	SGS	239	SX	South Georgia and the South Sandwich Islands	Grytviken	3903	30	AN	.gs	GBP	Pound		SIQQ 1ZZ	SIQQ 1ZZ	en	3474415		
-GT	GTM	320	GT	Guatemala	Guatemala City	108890	17247807	NA	.gt	GTQ	Quetzal	502	#####	^(\d{5})$	es-GT	3595528	MX,HN,BZ,SV	
-GU	GUM	316	GQ	Guam	Hagatna	549	165768	OC	.gu	USD	Dollar	+1-671	969##	^(969\d{2})$	en-GU,ch-GU	4043988		
-GW	GNB	624	PU	Guinea-Bissau	Bissau	36120	1874309	AF	.gw	XOF	Franc	245	####	^(\d{4})$	pt-GW,pov	2372248	SN,GN	
-GY	GUY	328	GY	Guyana	Georgetown	214970	779004	SA	.gy	GYD	Dollar	592			en-GY	3378535	SR,BR,VE	
-HK	HKG	344	HK	Hong Kong	Hong Kong	1092	7396076	AS	.hk	HKD	Dollar	852	######	^(\d{6})$	zh-HK,yue,zh,en	1819730		
-HM	HMD	334	HM	Heard Island and McDonald Islands		412	0	AN	.hm	AUD	Dollar	 	####	^(\d{4})$		1547314		
-HN	HND	340	HO	Honduras	Tegucigalpa	112090	9587522	NA	.hn	HNL	Lempira	504	#####	^(\d{6})$	es-HN,cab,miq	3608932	GT,NI,SV	
-HR	HRV	191	HR	Croatia	Zagreb	56542	3871833	EU	.hr	EUR	Euro	385	#####	^(?:HR)*(\d{5})$	hr-HR,sr	3202326	HU,SI,BA,ME,RS	
-HT	HTI	332	HA	Haiti	Port-au-Prince	27750	11123176	NA	.ht	HTG	Gourde	509	HT####	^(?:HT)*(\d{4})$	ht,fr-HT	3723988	DO	
-HU	HUN	348	HU	Hungary	Budapest	93030	9768785	EU	.hu	HUF	Forint	36	####	^(\d{4})$	hu-HU	719819	SK,SI,RO,UA,HR,AT,RS	
-ID	IDN	360	ID	Indonesia	Jakarta	1919440	267663435	AS	.id	IDR	Rupiah	62	#####	^(\d{5})$	id,en,nl,jv	1643084	PG,TL,MY	
-IE	IRL	372	EI	Ireland	Dublin	70280	4853506	EU	.ie	EUR	Euro	353	@@@ @@@@	^(D6W|[AC-FHKNPRTV-Y][0-9]{2})\s?([AC-FHKNPRTV-Y0-9]{4})	en-IE,ga-IE	2963597	GB	
-IL	ISR	376	IS	Israel	Jerusalem	20770	8883800	AS	.il	ILS	Shekel	972	#######	^(\d{7}|\d{5})$	he,ar-IL,en-IL,	294640	SY,JO,LB,EG,PS	
-IM	IMN	833	IM	Isle of Man	Douglas	572	84077	EU	.im	GBP	Pound	+44-1624	@# #@@|@## #@@|@@# #@@|@@## #@@|@#@ #@@|@@#@ #@@|GIR0AA	^((?:(?:[A-PR-UWYZ][A-HK-Y]\d[ABEHMNPRV-Y0-9]|[A-PR-UWYZ]\d[A-HJKPS-UW0-9])\s\d[ABD-HJLNP-UW-Z]{2})|GIR\s?0AA)$	en,gv	3042225		
-IN	IND	356	IN	India	New Delhi	3287590	1352617328	AS	.in	INR	Rupee	91	######	^(\d{6})$	en-IN,hi,bn,te,mr,ta,ur,gu,kn,ml,or,pa,as,bh,sat,ks,ne,sd,kok,doi,mni,sit,sa,fr,lus,inc	1269750	CN,NP,MM,BT,PK,BD	
-IO	IOT	086	IO	British Indian Ocean Territory	Diego Garcia	60	4000	AS	.io	USD	Dollar	246	BBND 1ZZ	BBND 1ZZ	en-IO	1282588		
-IQ	IRQ	368	IZ	Iraq	Baghdad	437072	38433600	AS	.iq	IQD	Dinar	964	#####	^(\d{5})$	ar-IQ,ku,hy	99237	SY,SA,IR,JO,TR,KW	
-IR	IRN	364	IR	Iran	Tehran	1648000	81800269	AS	.ir	IRR	Rial	98	##########	^(\d{10})$	fa-IR,ku	130758	TM,AF,IQ,AM,PK,AZ,TR	
-IS	ISL	352	IC	Iceland	Reykjavik	103000	353574	EU	.is	ISK	Krona	354	###	^(\d{3})$	is,en,de,da,sv,no	2629691		
-IT	ITA	380	IT	Italy	Rome	301230	60431283	EU	.it	EUR	Euro	39	#####	^(\d{5})$	it-IT,de-IT,fr-IT,sc,ca,co,sl	3175395	CH,VA,SI,SM,FR,AT	
-JE	JEY	832	JE	Jersey	Saint Helier	116	90812	EU	.je	GBP	Pound	+44-1534	@# #@@|@## #@@|@@# #@@|@@## #@@|@#@ #@@|@@#@ #@@|GIR0AA	^((?:(?:[A-PR-UWYZ][A-HK-Y]\d[ABEHMNPRV-Y0-9]|[A-PR-UWYZ]\d[A-HJKPS-UW0-9])\s\d[ABD-HJLNP-UW-Z]{2})|GIR\s?0AA)$	en,fr,nrf	3042142		
-JM	JAM	388	JM	Jamaica	Kingston	10991	2934855	NA	.jm	JMD	Dollar	+1-876			en-JM	3489940		
-JO	JOR	400	JO	Jordan	Amman	92300	9956011	AS	.jo	JOD	Dinar	962	#####	^(\d{5})$	ar-JO,en	248816	SY,SA,IQ,IL,PS	
-JP	JPN	392	JA	Japan	Tokyo	377835	126529100	AS	.jp	JPY	Yen	81	###-####	^\d{3}-\d{4}$	ja	1861060		
-KE	KEN	404	KE	Kenya	Nairobi	582650	51393010	AF	.ke	KES	Shilling	254	#####	^(\d{5})$	en-KE,sw-KE	192950	ET,TZ,SS,SO,UG	
-KG	KGZ	417	KG	Kyrgyzstan	Bishkek	198500	6315800	AS	.kg	KGS	Som	996	######	^(\d{6})$	ky,uz,ru	1527747	CN,TJ,UZ,KZ	
-KH	KHM	116	CB	Cambodia	Phnom Penh	181040	16249798	AS	.kh	KHR	Riels	855	#####	^(\d{5})$	km,fr,en	1831722	LA,TH,VN	
-KI	KIR	296	KR	Kiribati	Tarawa	811	115847	OC	.ki	AUD	Dollar	686			en-KI,gil	4030945		
-KM	COM	174	CN	Comoros	Moroni	2170	832322	AF	.km	KMF	Franc	269			ar,fr-KM	921929		
-KN	KNA	659	SC	Saint Kitts and Nevis	Basseterre	261	52441	NA	.kn	XCD	Dollar	+1-869			en-KN	3575174		
-KP	PRK	408	KN	North Korea	Pyongyang	120540	25549819	AS	.kp	KPW	Won	850	###-###	^(\d{6})$	ko-KP	1873107	CN,KR,RU	
-KR	KOR	410	KS	South Korea	Seoul	98480	51635256	AS	.kr	KRW	Won	82	#####	^(\d{5})$	ko-KR,en	1835841	KP	
-XK	XKX	0	KV	Kosovo	Pristina	10908	1845300	EU		EUR	Euro				sq,sr	831053	RS,AL,MK,ME	
-KW	KWT	414	KU	Kuwait	Kuwait City	17820	4137309	AS	.kw	KWD	Dinar	965	#####	^(\d{5})$	ar-KW,en	285570	SA,IQ	
-KY	CYM	136	CJ	Cayman Islands	George Town	262	64174	NA	.ky	KYD	Dollar	+1-345			en-KY	3580718		
-KZ	KAZ	398	KZ	Kazakhstan	Nur-Sultan	2717300	18276499	AS	.kz	KZT	Tenge	7	######	^(\d{6})$	kk,ru	1522867	TM,CN,KG,UZ,RU	
-LA	LAO	418	LA	Laos	Vientiane	236800	7061507	AS	.la	LAK	Kip	856	#####	^(\d{5})$	lo,fr,en	1655842	CN,MM,KH,TH,VN	
-LB	LBN	422	LE	Lebanon	Beirut	10400	6848925	AS	.lb	LBP	Pound	961	#### ####|####	^(\d{4}(\d{4})?)$	ar-LB,fr-LB,en,hy	272103	SY,IL	
-LC	LCA	662	ST	Saint Lucia	Castries	616	181889	NA	.lc	XCD	Dollar	+1-758			en-LC	3576468		
-LI	LIE	438	LS	Liechtenstein	Vaduz	160	37910	EU	.li	CHF	Franc	423	####	^(\d{4})$	de-LI	3042058	CH,AT	
-LK	LKA	144	CE	Sri Lanka	Colombo	65610	21670000	AS	.lk	LKR	Rupee	94	#####	^(\d{5})$	si,ta,en	1227603		
-LR	LBR	430	LI	Liberia	Monrovia	111370	4818977	AF	.lr	LRD	Dollar	231	####	^(\d{4})$	en-LR	2275384	SL,CI,GN	
-LS	LSO	426	LT	Lesotho	Maseru	30355	2108132	AF	.ls	LSL	Loti	266	###	^(\d{3})$	en-LS,st,zu,xh	932692	ZA	
-LT	LTU	440	LH	Lithuania	Vilnius	65200	2789533	EU	.lt	EUR	Euro	370	LT-#####	^(?:LT)*(\d{5})$	lt,ru,pl	597427	PL,BY,RU,LV	
-LU	LUX	442	LU	Luxembourg	Luxembourg	2586	607728	EU	.lu	EUR	Euro	352	L-####	^(?:L-)?\d{4}$	lb,de-LU,fr-LU	2960313	DE,BE,FR	
-LV	LVA	428	LG	Latvia	Riga	64589	1926542	EU	.lv	EUR	Euro	371	LV-####	^(?:LV)*(\d{4})$	lv,ru,lt	458258	LT,EE,BY,RU	
-LY	LBY	434	LY	Libya	Tripoli	1759540	6678567	AF	.ly	LYD	Dinar	218			ar-LY,it,en	2215636	TD,NE,DZ,SD,TN,EG	
-MA	MAR	504	MO	Morocco	Rabat	446550	36029138	AF	.ma	MAD	Dirham	212	#####	^(\d{5})$	ar-MA,ber,fr	2542007	DZ,EH,ES	
-MC	MCO	492	MN	Monaco	Monaco	1.95	38682	EU	.mc	EUR	Euro	377	#####	^(\d{5})$	fr-MC,en,it	2993457	FR	
-MD	MDA	498	MD	Moldova	Chisinau	33843	3545883	EU	.md	MDL	Leu	373	MD-####	^MD-\d{4}$	ro,ru,gag,tr	617790	RO,UA	
-ME	MNE	499	MJ	Montenegro	Podgorica	14026	622345	EU	.me	EUR	Euro	382	#####	^(\d{5})$	sr,hu,bs,sq,hr,rom	3194884	AL,HR,BA,RS,XK	
-MF	MAF	663	RN	Saint Martin	Marigot	53	37264	NA	.gp	EUR	Euro	590	#####	^(\d{5})$	fr	3578421	SX	
-MG	MDG	450	MA	Madagascar	Antananarivo	587040	26262368	AF	.mg	MGA	Ariary	261	###	^(\d{3})$	fr-MG,mg	1062947		
-MH	MHL	584	RM	Marshall Islands	Majuro	181.3	58413	OC	.mh	USD	Dollar	692	#####-####	^969\d{2}(-\d{4})$	mh,en-MH	2080185		
-MK	MKD	807	MK	North Macedonia	Skopje	25333	2082958	EU	.mk	MKD	Denar	389	####	^(\d{4})$	mk,sq,tr,rmm,sr	718075	AL,GR,BG,RS,XK	
-ML	MLI	466	ML	Mali	Bamako	1240000	19077690	AF	.ml	XOF	Franc	223			fr-ML,bm	2453866	SN,NE,DZ,CI,GN,MR,BF	
-MM	MMR	104	BM	Myanmar	Nay Pyi Taw	678500	53708395	AS	.mm	MMK	Kyat	95	#####	^(\d{5})$	my	1327865	CN,LA,TH,BD,IN	
-MN	MNG	496	MG	Mongolia	Ulaanbaatar	1565000	3170208	AS	.mn	MNT	Tugrik	976	######	^(\d{6})$	mn,ru	2029969	CN,RU	
-MO	MAC	446	MC	Macao	Macao	254	631636	AS	.mo	MOP	Pataca	853	######	^(\d{6})$	zh,zh-MO,pt	1821275		
-MP	MNP	580	CQ	Northern Mariana Islands	Saipan	477	56882	OC	.mp	USD	Dollar	+1-670	#####	^9695\d{1}$	fil,tl,zh,ch-MP,en-MP	4041468		
-MQ	MTQ	474	MB	Martinique	Fort-de-France	1100	432900	NA	.mq	EUR	Euro	596	#####	^(\d{5})$	fr-MQ	3570311		
-MR	MRT	478	MR	Mauritania	Nouakchott	1030700	4403319	AF	.mr	MRU	Ouguiya	222			ar-MR,fuc,snk,fr,mey,wo	2378080	SN,DZ,EH,ML	
-MS	MSR	500	MH	Montserrat	Plymouth	102	9341	NA	.ms	XCD	Dollar	+1-664			en-MS	3578097		
-MT	MLT	470	MT	Malta	Valletta	316	483530	EU	.mt	EUR	Euro	356	@@@ ####	^[A-Z]{3}\s?\d{4}$	mt,en-MT	2562770		
-MU	MUS	480	MP	Mauritius	Port Louis	2040	1265303	AF	.mu	MUR	Rupee	230			en-MU,bho,fr	934292		
-MV	MDV	462	MV	Maldives	Male	300	515696	AS	.mv	MVR	Rufiyaa	960	#####	^(\d{5})$	dv,en	1282028		
-MW	MWI	454	MI	Malawi	Lilongwe	118480	17563749	AF	.mw	MWK	Kwacha	265	######	^(\d{6})$	ny,yao,tum,swk	927384	TZ,MZ,ZM	
-MX	MEX	484	MX	Mexico	Mexico City	1972550	126190788	NA	.mx	MXN	Peso	52	#####	^(\d{5})$	es-MX	3996063	GT,US,BZ	
-MY	MYS	458	MY	Malaysia	Kuala Lumpur	329750	31528585	AS	.my	MYR	Ringgit	60	#####	^(\d{5})$	ms-MY,en,zh,ta,te,ml,pa,th	1733045	BN,TH,ID	
-MZ	MOZ	508	MZ	Mozambique	Maputo	801590	29495962	AF	.mz	MZN	Metical	258	####	^(\d{4})$	pt-MZ,vmw	1036973	ZW,TZ,SZ,ZA,ZM,MW	
-NA	NAM	516	WA	Namibia	Windhoek	825418	2448255	AF	.na	NAD	Dollar	264			en-NA,af,de,hz,naq	3355338	ZA,BW,ZM,AO	
-NC	NCL	540	NC	New Caledonia	Noumea	19060	284060	OC	.nc	XPF	Franc	687	#####	^(\d{5})$	fr-NC	2139685		
-NE	NER	562	NG	Niger	Niamey	1267000	22442948	AF	.ne	XOF	Franc	227	####	^(\d{4})$	fr-NE,ha,kr,dje	2440476	TD,BJ,DZ,LY,BF,NG,ML	
-NF	NFK	574	NF	Norfolk Island	Kingston	34.6	1828	OC	.nf	AUD	Dollar	672	####	^(\d{4})$	en-NF	2155115		
-NG	NGA	566	NI	Nigeria	Abuja	923768	195874740	AF	.ng	NGN	Naira	234	######	^(\d{6})$	en-NG,ha,yo,ig,ff	2328926	TD,NE,BJ,CM	
-NI	NIC	558	NU	Nicaragua	Managua	129494	6465513	NA	.ni	NIO	Cordoba	505	###-###-#	^(\d{7})$	es-NI,en	3617476	CR,HN	
-NL	NLD	528	NL	The Netherlands	Amsterdam	41526	17231017	EU	.nl	EUR	Euro	31	#### @@	^(\d{4}\s?[a-zA-Z]{2})$	nl-NL,fy-NL	2750405	DE,BE	
-NO	NOR	578	NO	Norway	Oslo	324220	5314336	EU	.no	NOK	Krone	47	####	^(\d{4})$	no,nb,nn,se,fi	3144096	FI,RU,SE	
-NP	NPL	524	NP	Nepal	Kathmandu	140800	28087871	AS	.np	NPR	Rupee	977	#####	^(\d{5})$	ne,en	1282988	CN,IN	
-NR	NRU	520	NR	Nauru	Yaren	21	12704	OC	.nr	AUD	Dollar	674	NRU68	NRU68	na,en-NR	2110425		
-NU	NIU	570	NE	Niue	Alofi	260	2166	OC	.nu	NZD	Dollar	683	####	^(\d{4})$	niu,en-NU	4036232		
-NZ	NZL	554	NZ	New Zealand	Wellington	268680	4885500	OC	.nz	NZD	Dollar	64	####	^(\d{4})$	en-NZ,mi	2186224		
-OM	OMN	512	MU	Oman	Muscat	212460	4829483	AS	.om	OMR	Rial	968	###	^(\d{3})$	ar-OM,en,bal,ur	286963	SA,YE,AE	
-PA	PAN	591	PM	Panama	Panama City	78200	4176873	NA	.pa	PAB	Balboa	507	#####	^(\d{5})$	es-PA,en	3703430	CR,CO	
-PE	PER	604	PE	Peru	Lima	1285220	31989256	SA	.pe	PEN	Sol	51	#####	^(\d{5})$	es-PE,qu,ay	3932488	EC,CL,BO,BR,CO	
-PF	PYF	258	FP	French Polynesia	Papeete	4167	277679	OC	.pf	XPF	Franc	689	#####	^((97|98)7\d{2})$	fr-PF,ty	4030656		
-PG	PNG	598	PP	Papua New Guinea	Port Moresby	462840	8606316	OC	.pg	PGK	Kina	675	###	^(\d{3})$	en-PG,ho,meu,tpi	2088628	ID	
-PH	PHL	608	RP	Philippines	Manila	300000	106651922	AS	.ph	PHP	Peso	63	####	^(\d{4})$	tl,en-PH,fil,ceb,ilo,hil,war,pam,bik,bcl,pag,mrw,tsg,mdh,cbk,krj,sgd,msb,akl,ibg,yka,mta,abx	1694008		
-PK	PAK	586	PK	Pakistan	Islamabad	803940	212215030	AS	.pk	PKR	Rupee	92	#####	^(\d{5})$	ur-PK,en-PK,pa,sd,ps,brh	1168579	CN,AF,IR,IN	
-PL	POL	616	PL	Poland	Warsaw	312685	37978548	EU	.pl	PLN	Zloty	48	##-###	^\d{2}-\d{3}$	pl	798544	DE,LT,SK,CZ,BY,UA,RU	
-PM	SPM	666	SB	Saint Pierre and Miquelon	Saint-Pierre	242	7012	NA	.pm	EUR	Euro	508	#####	^(97500)$	fr-PM	3424932		
-PN	PCN	612	PC	Pitcairn	Adamstown	47	46	OC	.pn	NZD	Dollar	870	PCRN 1ZZ	PCRN 1ZZ	en-PN	4030699		
-PR	PRI	630	RQ	Puerto Rico	San Juan	9104	3195153	NA	.pr	USD	Dollar	+1-787 and 1-939	#####-####	^00[679]\d{2}(?:-\d{4})?$	en-PR,es-PR	4566966		
-PS	PSE	275	WE	Palestinian Territory	East Jerusalem	5970	4569087	AS	.ps	ILS	Shekel	970			ar-PS	6254930	JO,IL,EG	
-PT	PRT	620	PO	Portugal	Lisbon	92391	10281762	EU	.pt	EUR	Euro	351	####-###	^\d{4}-\d{3}\s?[a-zA-Z]{0,25}$	pt-PT,mwl	2264397	ES	
-PW	PLW	585	PS	Palau	Melekeok	458	17907	OC	.pw	USD	Dollar	680	96940	^(96940)$	pau,sov,en-PW,tox,ja,fil,zh	1559582		
-PY	PRY	600	PA	Paraguay	Asuncion	406750	6956071	SA	.py	PYG	Guarani	595	####	^(\d{4})$	es-PY,gn	3437598	BO,BR,AR	
-QA	QAT	634	QA	Qatar	Doha	11437	2781677	AS	.qa	QAR	Rial	974			ar-QA,es	289688	SA	
-RE	REU	638	RE	Reunion	Saint-Denis	2517	776948	AF	.re	EUR	Euro	262	#####	^((97|98)(4|7|8)\d{2})$	fr-RE	935317		
-RO	ROU	642	RO	Romania	Bucharest	237500	19473936	EU	.ro	RON	Leu	40	######	^(\d{6})$	ro,hu,rom	798549	MD,HU,UA,BG,RS	
-RS	SRB	688	RI	Serbia	Belgrade	88361	6982084	EU	.rs	RSD	Dinar	381	#####	^(\d{5})$	sr,hu,bs,rom	6290252	AL,HU,MK,RO,HR,BA,BG,ME,XK	
-RU	RUS	643	RS	Russia	Moscow	17100000	144478050	EU	.ru	RUB	Ruble	7	######	^(\d{6})$	ru,tt,xal,cau,ady,kv,ce,tyv,cv,udm,tut,mns,bua,myv,mdf,chm,ba,inh,kbd,krc,av,sah,nog	2017370	GE,CN,BY,UA,KZ,LV,PL,EE,LT,FI,MN,NO,AZ,KP	
-RW	RWA	646	RW	Rwanda	Kigali	26338	12301939	AF	.rw	RWF	Franc	250			rw,en-RW,fr-RW,sw	49518	TZ,CD,BI,UG	
-SA	SAU	682	SA	Saudi Arabia	Riyadh	1960582	33699947	AS	.sa	SAR	Rial	966	#####	^(\d{5})$	ar-SA	102358	QA,OM,IQ,YE,JO,AE,KW	
-SB	SLB	090	BP	Solomon Islands	Honiara	28450	652858	OC	.sb	SBD	Dollar	677			en-SB,tpi	2103350		
-SC	SYC	690	SE	Seychelles	Victoria	455	96762	AF	.sc	SCR	Rupee	248			en-SC,fr-SC	241170		
-SD	SDN	729	SU	Sudan	Khartoum	1861484	41801533	AF	.sd	SDG	Pound	249	#####	^(\d{5})$	ar-SD,en,fia	366755	SS,TD,EG,ET,ER,LY,CF	
-SS	SSD	728	OD	South Sudan	Juba	644329	8260490	AF	.ss	SSP	Pound	211			en	7909807	CD,CF,ET,KE,SD,UG	
-SE	SWE	752	SW	Sweden	Stockholm	449964	10183175	EU	.se	SEK	Krona	46	### ##	^(?:SE)?\d{3}\s\d{2}$	sv-SE,se,sma,fi-SE	2661886	NO,FI	
-SG	SGP	702	SN	Singapore	Singapore	692.7	5638676	AS	.sg	SGD	Dollar	65	######	^(\d{6})$	cmn,en-SG,ms-SG,ta-SG,zh-SG	1880251		
-SH	SHN	654	SH	Saint Helena	Jamestown	410	7460	AF	.sh	SHP	Pound	290	STHL 1ZZ	^(STHL1ZZ)$	en-SH	3370751		
-SI	SVN	705	SI	Slovenia	Ljubljana	20273	2067372	EU	.si	EUR	Euro	386	####	^(?:SI)*(\d{4})$	sl,sh	3190538	HU,IT,HR,AT	
-SJ	SJM	744	SV	Svalbard and Jan Mayen	Longyearbyen	62049	2550	EU	.sj	NOK	Krone	47	####	^(\d{4})$	no,ru	607072		
-SK	SVK	703	LO	Slovakia	Bratislava	48845	5447011	EU	.sk	EUR	Euro	421	### ##	^\d{3}\s?\d{2}$	sk,hu	3057568	PL,HU,CZ,UA,AT	
-SL	SLE	694	SL	Sierra Leone	Freetown	71740	7650154	AF	.sl	SLE	Leone	232			en-SL,men,tem	2403846	LR,GN	
-SM	SMR	674	SM	San Marino	San Marino	61.2	33785	EU	.sm	EUR	Euro	378	4789#	^(4789\d)$	it-SM	3168068	IT	
-SN	SEN	686	SG	Senegal	Dakar	196190	15854360	AF	.sn	XOF	Franc	221	#####	^(\d{5})$	fr-SN,wo,fuc,mnk	2245662	GN,MR,GW,GM,ML	
-SO	SOM	706	SO	Somalia	Mogadishu	637657	15008154	AF	.so	SOS	Shilling	252	@@  #####	^([A-Z]{2}\d{5})$	so-SO,ar-SO,it,en-SO	51537	ET,KE,DJ	
-SR	SUR	740	NS	Suriname	Paramaribo	163270	575991	SA	.sr	SRD	Dollar	597			nl-SR,en,srn,hns,jv	3382998	GY,BR,GF	
-ST	STP	678	TP	Sao Tome and Principe	Sao Tome	1001	197700	AF	.st	STN	Dobra	239			pt-ST	2410758		
-SV	SLV	222	ES	El Salvador	San Salvador	21040	6420744	NA	.sv	USD	Dollar	503	CP ####	^(?:CP)*(\d{4})$	es-SV	3585968	GT,HN	
-SX	SXM	534	NN	Sint Maarten	Philipsburg	21	40654	NA	.sx	ANG	Guilder	599			nl,en	7609695	MF	
-SY	SYR	760	SY	Syria	Damascus	185180	16906283	AS	.sy	SYP	Pound	963			ar-SY,ku,hy,arc,fr,en	163843	IQ,JO,IL,TR,LB	
-SZ	SWZ	748	WZ	Eswatini	Mbabane	17363	1136191	AF	.sz	SZL	Lilangeni	268	@###	^([A-Z]\d{3})$	en-SZ,ss-SZ	934841	ZA,MZ	
-TC	TCA	796	TK	Turks and Caicos Islands	Cockburn Town	430	37665	NA	.tc	USD	Dollar	+1-649	TKCA 1ZZ	^(TKCA 1ZZ)$	en-TC	3576916		
-TD	TCD	148	CD	Chad	N'Djamena	1284000	15477751	AF	.td	XAF	Franc	235	TKCA 1ZZ	^(TKCA 1ZZ)$	fr-TD,ar-TD,sre	2434508	NE,LY,CF,SD,CM,NG	
-TF	ATF	260	FS	French Southern Territories	Port-aux-Francais	7829	140	AN	.tf	EUR	Euro				fr	1546748		
-TG	TGO	768	TO	Togo	Lome	56785	7889094	AF	.tg	XOF	Franc	228			fr-TG,ee,hna,kbp,dag,ha	2363686	BJ,GH,BF	
-TH	THA	764	TH	Thailand	Bangkok	514000	69428524	AS	.th	THB	Baht	66	#####	^(\d{5})$	th,en	1605651	LA,MM,KH,MY	
-TJ	TJK	762	TI	Tajikistan	Dushanbe	143100	9100837	AS	.tj	TJS	Somoni	992	######	^(\d{6})$	tg,ru	1220409	CN,AF,KG,UZ	
-TK	TKL	772	TL	Tokelau		10	1466	OC	.tk	NZD	Dollar	690			tkl,en-TK	4031074		
-TL	TLS	626	TT	Timor Leste	Dili	15007	1267972	OC	.tl	USD	Dollar	670			tet,pt-TL,id,en	1966436	ID	
-TM	TKM	795	TX	Turkmenistan	Ashgabat	488100	5850908	AS	.tm	TMT	Manat	993	######	^(\d{6})$	tk,ru,uz	1218197	AF,IR,UZ,KZ	
-TN	TUN	788	TS	Tunisia	Tunis	163610	11565204	AF	.tn	TND	Dinar	216	####	^(\d{4})$	ar-TN,fr	2464461	DZ,LY	
-TO	TON	776	TN	Tonga	Nuku'alofa	748	103197	OC	.to	TOP	Pa'anga	676			to,en-TO	4032283		
-TR	TUR	792	TU	Turkey	Ankara	780580	82319724	AS	.tr	TRY	Lira	90	#####	^(\d{5})$	tr-TR,ku,diq,az,av	298795	SY,GE,IQ,IR,GR,AM,AZ,BG	
-TT	TTO	780	TD	Trinidad and Tobago	Port of Spain	5128	1389858	NA	.tt	TTD	Dollar	+1-868			en-TT,hns,fr,es,zh	3573591		
-TV	TUV	798	TV	Tuvalu	Funafuti	26	11508	OC	.tv	AUD	Dollar	688			tvl,en,sm,gil	2110297		
-TW	TWN	158	TW	Taiwan	Taipei	35980	23451837	AS	.tw	TWD	Dollar	886	#####	^(\d{5})$	zh-TW,zh,nan,hak	1668284		
-TZ	TZA	834	TZ	Tanzania	Dodoma	945087	56318348	AF	.tz	TZS	Shilling	255			sw-TZ,en,ar	149590	MZ,KE,CD,RW,ZM,BI,UG,MW	
-UA	UKR	804	UP	Ukraine	Kyiv	603700	44622516	EU	.ua	UAH	Hryvnia	380	#####	^(\d{5})$	uk,ru-UA,rom,pl,hu	690791	PL,MD,HU,SK,BY,RO,RU	
-UG	UGA	800	UG	Uganda	Kampala	236040	42723139	AF	.ug	UGX	Shilling	256			en-UG,lg,sw,ar	226074	TZ,KE,SS,CD,RW	
-UM	UMI	581		United States Minor Outlying Islands		0	0	OC	.um	USD	Dollar	1			en-UM	5854968		
-US	USA	840	US	United States	Washington	9629091	327167434	NA	.us	USD	Dollar	1	#####-####	^\d{5}(-\d{4})?$	en-US,es-US,haw,fr	6252001	CA,MX,CU	
-UY	URY	858	UY	Uruguay	Montevideo	176220	3449299	SA	.uy	UYU	Peso	598	#####	^(\d{5})$	es-UY	3439705	BR,AR	
-UZ	UZB	860	UZ	Uzbekistan	Tashkent	447400	32955400	AS	.uz	UZS	Som	998	######	^(\d{6})$	uz,ru,tg	1512440	TM,AF,KG,TJ,KZ	
-VA	VAT	336	VT	Vatican	Vatican City	0.44	921	EU	.va	EUR	Euro	379	#####	^(\d{5})$	la,it,fr	3164670	IT	
-VC	VCT	670	VC	Saint Vincent and the Grenadines	Kingstown	389	110211	NA	.vc	XCD	Dollar	+1-784			en-VC,fr	3577815		
-VE	VEN	862	VE	Venezuela	Caracas	912050	28870195	SA	.ve	VES	Bolivar Soberano	58	####	^(\d{4})$	es-VE	3625428	GY,BR,CO	
-VG	VGB	092	VI	British Virgin Islands	Road Town	153	29802	NA	.vg	USD	Dollar	+1-284			en-VG	3577718		
-VI	VIR	850	VQ	U.S. Virgin Islands	Charlotte Amalie	352	106977	NA	.vi	USD	Dollar	+1-340	#####-####	^008\d{2}(?:-\d{4})?$	en-VI	4796775		
-VN	VNM	704	VM	Vietnam	Hanoi	329560	95540395	AS	.vn	VND	Dong	84	######	^(\d{6})$	vi,en,fr,zh,km	1562822	CN,LA,KH	
-VU	VUT	548	NH	Vanuatu	Port Vila	12200	292680	OC	.vu	VUV	Vatu	678			bi,en-VU,fr-VU	2134431		
-WF	WLF	876	WF	Wallis and Futuna	Mata Utu	274	16025	OC	.wf	XPF	Franc	681	#####	^(986\d{2})$	wls,fud,fr-WF	4034749		
-WS	WSM	882	WS	Samoa	Apia	2944	196130	OC	.ws	WST	Tala	685	AS 96799	AS 96799	sm,en-WS	4034894		
-YE	YEM	887	YM	Yemen	Sanaa	527970	28498687	AS	.ye	YER	Rial	967			ar-YE	69543	SA,OM	
-YT	MYT	175	MF	Mayotte	Mamoudzou	374	279471	AF	.yt	EUR	Euro	262	#####	^(\d{5})$	fr-YT	1024031		
-ZA	ZAF	710	SF	South Africa	Pretoria	1219912	57779622	AF	.za	ZAR	Rand	27	####	^(\d{4})$	zu,xh,af,nso,en-ZA,tn,st,ts,ss,ve,nr	953987	ZW,SZ,MZ,BW,NA,LS	
-ZM	ZMB	894	ZA	Zambia	Lusaka	752614	17351822	AF	.zm	ZMW	Kwacha	260	#####	^(\d{5})$	en-ZM,bem,loz,lun,lue,ny,toi	895949	ZW,TZ,MZ,CD,NA,MW,AO	
-ZW	ZWE	716	ZI	Zimbabwe	Harare	390580	16868409	AF	.zw	ZWG	Zimbabwe Gold	263			en-ZW,sn,nr,nd	878675	ZA,MZ,BW,ZM	
-CS	SCG	891	YI	Serbia and Montenegro	Belgrade	102350	10829175	EU	.cs	RSD	Dinar	381	#####	^(\d{5})$	cu,hu,sq,sr	8505033	AL,HU,MK,RO,HR,BA,BG	
-AN	ANT	530	NT	Netherlands Antilles	Willemstad	960	300000	NA	.an	ANG	Guilder	599			nl-AN,en,es	8505032	GP	

release_2025_09_15/data/input/imf_gdp_raw_2024.json

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:d8583c093381da17225f57ee69ab39285f4c9557d53fa1ce5a8ce1160950c509
-size 265358

release_2025_09_15/data/input/onet_task_statements_raw.xlsx

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:373cdc961891d04bcd29db66c43c7cf412d61fe3ef1f49e634dd979f4d5a3a95
-size 1204658

release_2025_09_15/data/input/sc-est2024-agesex-civ.csv

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:334210a5080a6e470db22e42346ba7e6d0d43490887e08c5ed3ece62a7adfa9c
-size 818707

release_2025_09_15/data/input/soc_structure_raw.csv

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:05eb5e689fb471b7a66962b57bba6666dee2c3e6a6854f0f84faf423af68dd17
-size 77176

release_2025_09_15/data/input/task_pct_v1.csv

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:8de89c99f762146c9e46b2202c3501e2a14f11c5b44c61c8007021127b6c676e
-size 461306

release_2025_09_15/data/input/task_pct_v2.csv

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:0c20f184cd4a1e3d8ef3d77f500b32b62431ce61a3c2f133c3af7fa8429f97db
-size 435372

release_2025_09_15/data/input/working_age_pop_2024_country_raw.csv

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:7c86dcb133a3f9f54f5f22e74683f5d6c5cc97faa9ddc2cdd466a4422cd4124c
-size 22974

release_2025_09_15/data/intermediate/aei_raw_1p_api_2025-08-04_to_2025-08-11.csv

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:c0fc061ea7d4feb71a7bd88c528d54e2d3a11e2045574f1e1fb2d594eebffd0f
-size 7027019

release_2025_09_15/data/intermediate/aei_raw_claude_ai_2025-08-04_to_2025-08-11.csv

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:c8ef9c5eee0c42febc73e358ecc7d2358e0a0ce3b50122c0c15ae8ec569aceff
-size 18894517

release_2025_09_15/data/intermediate/gdp_2024_country.csv

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:e0618d6ba634a612b97b1c82f521ab38a387216069818a86f50c9aaf8e2bda6c
-size 4115

release_2025_09_15/data/intermediate/gdp_2024_us_state.csv

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:cb1573e8143bd407c2ea7c43f5a6822852568c596dbde843fc5d8692c9e967ec
-size 2179

release_2025_09_15/data/intermediate/iso_country_codes.csv

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:eee318d4ab2c2c30f5a7da11f2bc7e0e36c246f6be5bb9b323fdb12b8e4809e0
-size 4564

release_2025_09_15/data/intermediate/onet_task_statements.csv

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:88427f8d2a9f37a7c08b5420c6c66a01cdae6467b716bbbd31989128504b8ebb
-size 3650862

release_2025_09_15/data/intermediate/soc_structure.csv

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:97dee70470182ac642872839f71a4a938c03677829aadca9bfbf250cb4021863
-size 78834

release_2025_09_15/data/intermediate/working_age_pop_2024_country.csv

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:3a9e0edc0453702e8efb63d7cab57e5b1a689bc09e070626bbf513e37edd5dd3
-size 6321

release_2025_09_15/data/intermediate/working_age_pop_2024_us_state.csv

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:e2d0fb7239934f4f6d0ae3444ab12ad8ff1dd323b71ccfc4295d074b537f17ec
-size 1079

release_2025_09_15/data/output/aei_enriched_claude_ai_2025-08-04_to_2025-08-11.csv

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:48a2c39f8a98ce7c2ba72767cbe3760fd55ba4a64a193abfecefc76d19852c09
-size 26840881

release_2025_09_15/data/output/request_hierarchy_tree_1p_api.json

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:83ad607dace603931ef663768edc63738fe3547b41e5ab47739b49e3b1cdbad7
-size 302699

release_2025_09_15/data/output/request_hierarchy_tree_claude_ai.json

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:79f9f7939ba8c2dda1a5e52967dd9c6def3238e9fe024772330a411c849de7e0
-size 438531

release_2025_09_15/data_documentation.md

@@ -1,373 +0,0 @@
-# Data Documentation
-
-This document describes the data sources and variables used in the third Anthropic Economic Index (AEI) report.
-
-## Claude.ai Usage Data
-
-### Overview
-The core dataset contains Claude AI usage metrics aggregated by geography and analysis dimensions (facets).
-
-**Source files**:
-- `aei_raw_claude_ai_2025-08-04_to_2025-08-11.csv` (pre-enrichment data in data/intermediate/)
-- `aei_enriched_claude_ai_2025-08-04_to_2025-08-11.csv` (enriched data in data/output/)
-
-**Note on data sources**: The AEI raw file contains raw counts and percentages. Derived metrics (indices, tiers, per capita calculations, automation/augmentation percentages) are calculated during the enrichment process in `aei_report_v3_preprocessing_claude_ai.ipynb`.
-
-### Data Schema
-Each row represents one metric value for a specific geography and facet combination:
-
-| Column | Type | Description |
-|--------|------|-------------|
-| `geo_id` | string | Geographic identifier (ISO-2 country code for countries, US state code, or "GLOBAL", ISO-3 country codes in enriched data) |
-| `geography` | string | Geographic level: "country", "state_us", or "global" |
-| `date_start` | date | Start of data collection period |
-| `date_end` | date | End of data collection period |
-| `platform_and_product` | string | "Claude AI (Free and Pro)" |
-| `facet` | string | Analysis dimension (see Facets below) |
-| `level` | integer | Sub-level within facet (0-2) |
-| `variable` | string | Metric name (see Variables below) |
-| `cluster_name` | string | Specific entity within facet (task, pattern, etc.). For intersections, format is "base::category" |
-| `value` | float | Numeric metric value |
-
-### Facets
-- **country**: Country-level aggregations
-- **state_us**: US state-level aggregations
-- **onet_task**: O*NET occupational tasks
-- **collaboration**: Human-AI collaboration patterns
-- **request**: Request complexity levels (0=highest granularity, 1=middle granularity, 2=lowest granularity)
-- **onet_task::collaboration**: Intersection of tasks and collaboration patterns
-- **request::collaboration**: Intersection of request categories and collaboration patterns
-
-### Core Variables
-
-Variables follow the pattern `{prefix}_{suffix}` with specific meanings:
-
-**From AEI processing**: `*_count`, `*_pct`
-**From enrichment**: `*_per_capita`, `*_per_capita_index`, `*_pct_index`, `*_tier`, `automation_pct`, `augmentation_pct`, `soc_pct`
-
-#### Usage Metrics
-- **usage_count**: Total number of conversations/interactions in a geography
-- **usage_pct**: Percentage of total usage (relative to parent geography - gobal for countries, US for states)
-- **usage_per_capita**: Usage count divided by working age population
-- **usage_per_capita_index**: Concentration index showing if a geography has more/less usage than expected based on population share (1.0 = proportional, >1.0 = over-representation, <1.0 = under-representation)
-- **usage_tier**: Usage adoption tier (0 = no/little adoption, 1-4 = quartiles of adoption among geographies with sufficient usage)
-
-#### Content Facet Metrics
-**O*NET Task Metrics**:
-- **onet_task_count**: Number of conversations using this specific O*NET task
-- **onet_task_pct**: Percentage of geographic total using this task
-- **onet_task_pct_index**: Specialization index comparing task usage to baseline (global for countries, US for states)
-- **onet_task_collaboration_count**: Number of conversations with both this task and collaboration pattern (intersection)
-- **onet_task_collaboration_pct**: Percentage of the base task's total that has this collaboration pattern (sums to 100% within each task)
-
-#### Occupation Metrics
-- **soc_pct**: Percentage of classified O*NET tasks associated with this SOC major occupation group (e.g., Management, Computer and Mathematical)
-
-**Request Metrics**:
-- **request_count**: Number of conversations in this request category level
-- **request_pct**: Percentage of geographic total in this category
-- **request_pct_index**: Specialization index comparing request usage to baseline
-- **request_collaboration_count**: Number of conversations with both this request category and collaboration pattern (intersection)
-- **request_collaboration_pct**: Percentage of the base request's total that has this collaboration pattern (sums to 100% within each request)
-
-**Collaboration Pattern Metrics**:
-- **collaboration_count**: Number of conversations with this collaboration pattern
-- **collaboration_pct**: Percentage of geographic total with this pattern
-- **collaboration_pct_index**: Specialization index comparing pattern to baseline
-- **automation_pct**: Percentage of classifiable collaboration that is automation-focused (directive, feedback loop patterns)
-- **augmentation_pct**: Percentage of classifiable collaboration that is augmentation-focused (validation, task iteration, learning patterns)
-
-#### Demographic & Economic Metrics
-- **working_age_pop**: Population aged 15-64 (working age definition used by World Bank)
-- **gdp_per_working_age_capita**: Total GDP divided by working age population (in USD)
-
-#### Special Values
-- **not_classified**: Indicates data that was filtered for privacy protection or could not be classified
-- **none**: Indicates the absence of the attribute (e.g., no collaboration, no task selected)
-
-### Data Processing Notes
-- **Minimum Observations**: 200 conversations per country, 100 per US state (applied in enrichment step, not raw preprocessing)
-- **Population Base**: Working-age population (ages 15-64)
-- **not_classified**:
-  - For regular facets: Captures filtered/unclassified conversations
-  - For intersection facets: Each base cluster has its own not_classified (e.g., "task1::not_classified")
-- **Intersection Percentages**: Calculated relative to base cluster totals, ensuring each base cluster's percentages sum to 100%
-- **Percentage Index Calculations**:
-  - Exclude `not_classified` and `none` categories from index calculations as they are not meaningful
-- **Country Codes**: ISO-2 format (e.g., "US" in raw data), ISO-3 (e.g., "USA", "GBR", "FRA") for countries after enrichment
-- **Variable Definitions**: See Core Variables section above
-
-## 1P API Usage Data
-
-### Overview
-Dataset containing first-party API usage metrics along various dimensions based on a sample of 1P API traffic and analyzed using privacy-preserving methods.
-
-**Source file**: `aei_raw_1p_api_2025-08-04_to_2025-08-11.csv` (in data/intermediate/)
-
-### Data Schema
-Each row represents one metric value for a specific facet combination at global level:
-
-| Column | Type | Description |
-|--------|------|-------------|
-| `geo_id` | string | Geographic identifier (always "GLOBAL" for API data) |
-| `geography` | string | Geographic level (always "global" for API data) |
-| `date_start` | date | Start of data collection period |
-| `date_end` | date | End of data collection period |
-| `platform_and_product` | string | "1P API" |
-| `facet` | string | Analysis dimension (see Facets below) |
-| `level` | integer | Sub-level within facet (0-2) |
-| `variable` | string | Metric name (see Variables below) |
-| `cluster_name` | string | Specific entity within facet. For intersections, format is "base::category" or "base::index"/"base::count" for mean value metrics |
-| `value` | float | Numeric metric value |
-
-### Facets
-- **onet_task**: O*NET occupational tasks
-- **collaboration**: Human-AI collaboration patterns
-- **request**: Request categories (hierarchical levels 0-2 from bottom-up taxonomy)
-- **onet_task::collaboration**: Intersection of tasks and collaboration patterns
-- **onet_task::prompt_tokens**: Mean prompt tokens per task (normalized, average = 1.0)
-- **onet_task::completion_tokens**: Mean completion tokens per task (normalized, average = 1.0)
-- **onet_task::cost**: Mean cost per task (normalized, average = 1.0)
-- **request::collaboration**: Intersection of request categories and collaboration patterns
-
-### Core Variables
-
-#### Usage Metrics
-- **collaboration_count**: Number of 1P API records with this collaboration pattern
-- **collaboration_pct**: Percentage of total with this pattern
-
-#### Content Facet Metrics
-**O*NET Task Metrics**:
-- **onet_task_count**: Number of 1P API records using this specific O*NET task
-- **onet_task_pct**: Percentage of total using this task
-- **onet_task_collaboration_count**: Records with both this task and collaboration pattern
-- **onet_task_collaboration_pct**: Percentage of the task's total with this collaboration pattern
-
-**Mean Value Intersection Metrics** (unique to API data):
-- **prompt_tokens_index**: Re-indexed mean prompt tokens (1.0 = average across all tasks)
-- **prompt_tokens_count**: Number of records for this metric
-- **completion_tokens_index**: Re-indexed mean completion tokens (1.0 = average across all tasks)
-- **completion_tokens_count**: Number of records for this metric
-- **cost_index**: Re-indexed mean cost (1.0 = average across all tasks)
-- **cost_count**: Number of records for this metric
-
-**Request Metrics**:
-- **request_count**: Number of 1P API records in this request category
-- **request_pct**: Percentage of total in this category
-- **request_collaboration_count**: Records with both this request category and collaboration pattern
-- **request_collaboration_pct**: Percentage of the request's total with this collaboration pattern
-
-## Claude.ai Request Hierarchy
-
-Contains the hierarchy of request clusters for Claude.ai usage with their names and descriptions.
-
-**Source file**: `request_hierarchy_tree_claude_ai.json` (in data/output/)
-
-## 1P API Request Hierarchy
-
-Contains the hierarchy of request clusters for 1P API usage with their names and descriptions.
-
-**Source file**: `request_hierarchy_tree_1p_api.json` (in data/output/)
-
-## Claude.ai Usage Data from Prior Anthropic Economic Index Releases
-
-Data on task usage and automation/augmentation patterns from the first and second Anthropic Economic Index reports.
-
-- **Source**: Anthropic/EconomicIndex dataset on Hugging Face
-- **URL**: https://huggingface.co/datasets/Anthropic/EconomicIndex/tree/main/release_2025_03_27
-- **License**: Creative Commons Attribution 4.0 License (https://creativecommons.org/licenses/by/4.0/)
-- **Files**:
-  - `automation_vs_augmentation_v1.csv`
-  - `automation_vs_augmentation_v2.csv`
-  - `task_pct_v1.csv`
-  - `task_pct_v2.csv`
-
-## External Data Sources
-
-We use external data to enrich Claude usage data with external economic and demographic sources.
-
-### ISO Country Codes
-
-**ISO 3166 Country Codes**
-
-International standard codes for representing countries and territories, used for mapping IP-based geolocation data to standardized country identifiers.
-
-- **Standard**: ISO 3166-1
-- **Source**: GeoNames geographical database
-- **URL**: https://download.geonames.org/export/dump/countryInfo.txt
-- **License**: Creative Commons Attribution 4.0 License (https://creativecommons.org/licenses/by/4.0/)
-- **Attribution note**: Data in the data/intermediate and data/output folders have been processed and modified from original source; modifications to data in data/intermediate include extracting only tabular data, selecting a subset of columns, and renaming columns; modifications to data in data/output include transforming data to long format
-- **Download date**: September 2, 2025
-- **Output files**:
-  - `geonames_countryInfo.txt` (raw GeoNames data in data/input/)
-  - `iso_country_codes.csv` (processed country codes in data/intermediate/)
-- **Key fields**:
-  - `iso_alpha_2`: Two-letter country code (e.g., "US", "GB", "FR")
-  - `iso_alpha_3`: Three-letter country code (e.g., "USA", "GBR", "FRA")
-  - `country_name`: Country name from GeoNames
-- **Usage**: Maps IP-based country identification to standardized ISO codes for consistent geographic aggregation
-
-### US State Codes
-
-**State FIPS Codes and USPS Abbreviations**
-
-Official state and territory codes including FIPS codes and two-letter USPS abbreviations for all U.S. states, territories, and the District of Columbia.
-
-- **Series**: State FIPS Codes
-- **Source**: U.S. Census Bureau, Geography Division
-- **URL**: https://www2.census.gov/geo/docs/reference/state.txt
-- **License**: Public Domain (U.S. Government Work)
-- **Download date**: September 2, 2025
-- **Output files**:
-  - `census_state_codes.txt` (raw pipe-delimited text file in data/input/)
-- **Usage**: Maps state names to two-letter abbreviations (e.g., "California" → "CA")
-
-### Population Data
-
-### US State Population
-
-**State Characteristics Estimates - Age and Sex - Civilian Population**
-
-Annual estimates of the civilian population by single year of age, sex, race, and Hispanic origin for states and the District of Columbia.
-
-- **Series**: SC-EST2024-AGESEX-CIV
-- **Source**: U.S. Census Bureau, Population Division
-- **URL**: https://www2.census.gov/programs-surveys/popest/datasets/2020-2024/state/asrh/sc-est2024-agesex-civ.csv
-- **License**: Public Domain (U.S. Government Work)
-- **Download date**: September 2, 2025
-- **Output files**:
-  - `sc-est2024-agesex-civ.csv` (raw Census data in data/input/)
-  - `working_age_pop_2024_us_state.csv` (processed data summed for ages 15-64 by state in data/intermediate/)
-- **Documentation**: https://www2.census.gov/programs-surveys/popest/technical-documentation/file-layouts/2020-2024/SC-EST2024-AGESEX-CIV.pdf
-
-### Country Population
-
-**Population ages 15-64, total**
-
-Total population between the ages 15 to 64. Population is based on the de facto definition of population, which counts all residents regardless of legal status or citizenship.
-
-- **Series**: SP.POP.1564.TO
-- **Source**: World Population Prospects, United Nations (UN), publisher: UN Population Division; Staff estimates, World Bank (WB)
-- **URL**: https://api.worldbank.org/v2/country/all/indicator/SP.POP.1564.TO?format=json&date=2024&per_page=1000
-- **License**: Creative Commons Attribution 4.0 License (https://creativecommons.org/licenses/by/4.0/)
-- **Attribution note**: Data in the data/intermediate folder have been processed and modified from original source; modifications to data in data/input include changing the file format; modifications to data/intermediate include adding Taiwan population data, removing non-country aggregates, removing invalid country codes, removing excluded countries, and renaming columns; modifications to data in data/output include transforming data to long format
-- **Download date**: September 2, 2025
-- **Output files**:
-  - `working_age_pop_2024_country_raw.csv` (raw World Bank data in data/input/)
-  - `working_age_pop_2024_country.csv` (processed country-level data including Taiwan in data/intermediate/)
-
-### Taiwan Population
-
-**Population by single age**
-
-Population projections by single year of age for Taiwan (Republic of China). This data supplements the World Bank country data which excludes Taiwan.
-
-- **Series**: Population by single age (Medium variant, Total gender)
-- **Source**: National Development Council, Population Projections for the R.O.C (Taiwan)
-- **URL**: https://pop-proj.ndc.gov.tw/main_en/Custom_Detail_Statistics_Search.aspx?n=175&_Query=258170a1-1394-49fe-8d21-dc80562b72fb&page=1&PageSize=10&ToggleType=
-- **License**: Open Government Data License (Taiwan) (https://data.gov.tw/en/license)
-- **Update date**: 2025.06.17
-- **Download date**: September 2, 2025
-- **Reference year**: 2024
-- **Variable name in script**: `df_taiwan` (raw data), added to `df_working_age_pop_country`
-- **Output files**:
-  - `Population by single age _20250802235608.csv` (raw data in data/input/, pre-filtered to ages 15-64)
-  - Merged into `working_age_pop_2024_country.csv` (processed country-level data in data/intermediate/)
-
-## GDP Data
-
-### Country GDP
-
-**Gross Domestic Product, Current Prices (Billions of U.S. Dollars)**
-
-Total gross domestic product at current market prices for all countries and territories.
-
-- **Series**: NGDPD
-- **Source**: International Monetary Fund (IMF), World Economic Outlook Database
-- **URL**: https://www.imf.org/external/datamapper/api/v1/NGDPD
-- **License**: IMF Data Terms and Conditions (https://www.imf.org/en/About/copyright-and-terms#data)
-- **Reference year**: 2024
-- **Download date**: September 2, 2025
-- **Output files**:
-  - `imf_gdp_raw_2024.json` (raw API response in data/input/)
-  - `gdp_2024_country.csv` (processed country GDP data in data/intermediate/)
-
-### US State GDP
-
-**SASUMMARY State Annual Summary Statistics: Personal Income, GDP, Consumer Spending, Price Indexes, and Employment**
-
-Gross domestic product by state in millions of current U.S. dollars.
-
-- **Series**: SASUMMARY (Gross Domestic Product by State)
-- **Source**: U.S. Bureau of Economic Analysis (BEA)
-- **URL**: https://apps.bea.gov/itable/?ReqID=70&step=1
-- **License**: Public Domain (U.S. Government Work)
-- **Download date**: September 2, 2025
-- **Reference year**: 2024
-- **Output files**:
-  - `bea_us_state_gdp_2024.csv` (raw data in data/input/, manually downloaded from BEA)
-  - `gdp_2024_us_state.csv` (processed state GDP data in data/intermediate/)
-- **Citation**: U.S. Bureau of Economic Analysis, "SASUMMARY State annual summary statistics: personal income, GDP, consumer spending, price indexes, and employment" (accessed September 2, 2025)
-
-## SOC and O*NET Data
-
-### O*NET Task Statements
-
-**O*NET Task Statements Dataset**
-
-Comprehensive database of task statements associated with occupations in the O*NET-SOC taxonomy, providing detailed work activities for each occupation.
-
-- **Database Version**: O*NET Database 20.1
-- **Source**: O*NET Resource Center, U.S. Department of Labor
-- **URL**: https://www.onetcenter.org/dl_files/database/db_20_1_excel/Task%20Statements.xlsx
-- **License**: Public Domain (U.S. Government Work)
-- **Download date**: September 2, 2025
-- **Output files**:
-  - `onet_task_statements_raw.xlsx` (raw Excel file in data/input/)
-  - `onet_task_statements.csv` (processed data with soc_major_group in data/intermediate/)
-- **Key fields**:
-  - `O*NET-SOC Code`: Full occupation code (e.g., "11-1011.00")
-  - `Title`: Occupation title
-  - `Task ID`: Unique task identifier
-  - `Task`: Description of work task
-  - `Task Type`: Core or Supplemental
-  - `soc_major_group`: First 2 digits of SOC code (e.g., "11" for Management)
-- **Notes**:
-  - SOC major group codes extracted from O*NET-SOC codes for aggregation
-  - Used to map Claude usage patterns to occupational categories
-
-### SOC Structure
-
-**Standard Occupational Classification (SOC) Structure**
-
-Hierarchical classification system for occupations, providing standardized occupation titles and codes.
-
-- **SOC Version**: 2019
-- **Source**: O*NET Resource Center (SOC taxonomy)
-- **URL**: https://www.onetcenter.org/taxonomy/2019/structure/?fmt=csv
-- **License**: Public Domain (U.S. Government Work)
-- **Download date**: September 2, 2025
-- **Variable name in script**: `df_soc` (SOC structure dataframe)
-- **Output files**:
-  - `soc_structure_raw.csv` (raw data in data/input/)
-  - `soc_structure.csv` (processed SOC structure in data/intermediate/)
-- **Key fields**:
-  - `Major Group`: SOC major group code (e.g., "11-0000")
-  - `Minor Group`: SOC minor group code
-  - `Broad Occupation`: Broad occupation code
-  - `Detailed Occupation`: Detailed occupation code
-  - `soc_major_group`: 2-digit major group code (e.g., "11")
-  - `SOC or O*NET-SOC 2019 Title`: Occupation group title
-- **Notes**:
-  - Provides hierarchical structure for occupational classification
-
-### Business Trends and Outlook Survey
-
-Core questions, National.
-
-- **Source**: U.S. Census Bureau
-- **URL**: https://www.census.gov/hfp/btos/downloads/National.xlsx
-- **License**: Public Domain (U.S. Government Work)
-- **Download date**: September 5, 2025
-- **Reference periods**: Ending in September 2023 and August 2025
-- **Input file**: `BTOS_National.xlsx`