EconomicIndex_release_2025_03_27

.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,32 +40,4 @@ Data released under CC-BY, code released under MIT License
 
 ## Contact
 
-For inquiries, contact econ-research@anthropic.com.
-
-## 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}, 
-      author={Kunal Handa and Alex Tamkin and Miles McCain and Saffron Huang and Esin Durmus and Sarah Heck and Jared Mueller and Jerry Hong and Stuart Ritchie and Tim Belonax and Kevin K. Troy and Dario Amodei and Jared Kaplan and Jack Clark and Deep Ganguli},
-      year={2025},
-      eprint={2503.04761},
-      archivePrefix={arXiv},
-      primaryClass={cs.CY},
-      url={https://arxiv.org/abs/2503.04761}, 
-}
-```
+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).

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`