policyengine 1.0.1__py3-none-any.whl

policyengine/__init__.py

@@ -0,0 +1 @@
+from .simulation import Simulation

policyengine/constants.py

@@ -0,0 +1,20 @@
+"""Mainly simulation options and parameters."""
+
+# Datasets
+
+ENHANCED_FRS = "hf://policyengine/policyengine-uk-data/enhanced_frs_2022_23.h5"
+FRS = "hf://policyengine/policyengine-uk-data/frs_2022_23.h5"
+
+ENHANCED_CPS = "hf://policyengine/policyengine-us-data/enhanced_cps_2024.h5"
+CPS = "hf://policyengine/policyengine-us-data/cps_2023.h5"
+POOLED_CPS = "hf://policyengine/policyengine-us-data/pooled_3_year_cps_2023.h5"
+
+DATASETS = {
+    "uk": {"frs": FRS, "enhanced_frs": ENHANCED_FRS},
+    "us": {"cps": CPS, "enhanced_cps": ENHANCED_CPS, "pooled_cps": POOLED_CPS},
+}
+
+DEFAULT_DATASETS = {
+    "uk": ENHANCED_FRS,
+    "us": CPS,
+}

policyengine/outputs/household/comparison/net_income_change.py

@@ -0,0 +1,4 @@
+def net_income_change(simulation):
+    baseline_net_income = simulation.calculate("household/baseline/net_income")
+    reform_net_income = simulation.calculate("household/reform/net_income")
+    return reform_net_income - baseline_net_income

policyengine/outputs/household/single/net_income.py

@@ -0,0 +1,2 @@
+def net_income(simulation):
+    return simulation.selected.calculate("household_net_income").sum()

policyengine/outputs/macro/comparison/budget.py

@@ -0,0 +1,44 @@
+from policyengine import Simulation
+
+
+def budget(simulation: Simulation):
+    """Calculate the budgetary impact of the given simulation.
+
+    Args:
+        simulation (Simulation): The simulation for which the revenue impact is to be calculated.
+
+    Returns:
+        dict: A dictionary containing the budgetary impact details with the following keys:
+            - budgetary_impact (float): The overall budgetary impact.
+            - tax_revenue_impact (float): The impact on tax revenue.
+            - state_tax_revenue_impact (float): The impact on state tax revenue.
+            - benefit_spending_impact (float): The impact on benefit spending.
+            - households (int): The number of households.
+            - baseline_net_income (float): The total net income in the baseline scenario.
+    """
+    baseline = simulation.calculate("macro/baseline")
+    reform = simulation.calculate("macro/reform")
+
+    tax_revenue_impact = (
+        reform["gov"]["balance"]["total_tax"]
+        - baseline["gov"]["balance"]["total_tax"]
+    )
+    state_tax_revenue_impact = (
+        reform["gov"]["balance"]["total_state_tax"]
+        - baseline["gov"]["balance"]["total_state_tax"]
+    )
+    benefit_spending_impact = (
+        reform["gov"]["balance"]["total_spending"]
+        - baseline["gov"]["balance"]["total_spending"]
+    )
+    budgetary_impact = tax_revenue_impact - benefit_spending_impact
+    households = sum(baseline["household"]["demographics"]["household_weight"])
+    baseline_net_income = baseline["household"]["finance"]["total_net_income"]
+    return dict(
+        budgetary_impact=budgetary_impact,
+        tax_revenue_impact=tax_revenue_impact,
+        state_tax_revenue_impact=state_tax_revenue_impact,
+        benefit_spending_impact=benefit_spending_impact,
+        households=households,
+        baseline_net_income=baseline_net_income,
+    )

policyengine/outputs/macro/comparison/decile/income.py

@@ -0,0 +1,51 @@
+from policyengine import Simulation
+from microdf import MicroSeries
+
+
+def income(simulation: Simulation):
+    """Calculate the impact of the reform on income deciles.
+
+    Args:
+        simulation (Simulation): The simulation for which the impact is to be calculated.
+
+    Returns:
+        dict: A dictionary containing the impact details with the following keys:
+            - relative (dict): A dictionary with keys representing deciles and values as relative income changes.
+            - average (dict): A dictionary with keys representing deciles and values as average income changes.
+    """
+    baseline = simulation.calculate("macro/baseline")
+    reform = simulation.calculate("macro/reform")
+
+    baseline_income = MicroSeries(
+        baseline["household"]["finance"]["household_net_income"],
+        weights=baseline["household"]["demographics"]["household_weight"],
+    )
+    reform_income = MicroSeries(
+        reform["household"]["finance"]["household_net_income"],
+        weights=baseline_income.weights,
+    )
+
+    # Filter out negative decile values
+    decile = MicroSeries(
+        baseline["household"]["finance"]["household_income_decile"]
+    )
+    baseline_income_filtered = baseline_income[decile >= 0]
+    reform_income_filtered = reform_income[decile >= 0]
+
+    income_change = reform_income_filtered - baseline_income_filtered
+    rel_income_change_by_decile = (
+        income_change.groupby(decile).sum()
+        / baseline_income_filtered.groupby(decile).sum()
+    )
+
+    avg_income_change_by_decile = (
+        income_change.groupby(decile).sum()
+        / baseline_income_filtered.groupby(decile).count()
+    )
+    rel_decile_dict = rel_income_change_by_decile.to_dict()
+    avg_decile_dict = avg_income_change_by_decile.to_dict()
+    result = dict(
+        relative={int(k): v for k, v in rel_decile_dict.items()},
+        average={int(k): v for k, v in avg_decile_dict.items()},
+    )
+    return result

policyengine/outputs/macro/comparison/decile/wealth.py

@@ -0,0 +1,52 @@
+from policyengine import Simulation
+from microdf import MicroSeries
+
+
+def wealth(simulation: Simulation):
+    """Calculate the impact of the reform on wealth deciles.
+
+    Args:
+        simulation (Simulation): The simulation for which the impact is to be calculated.
+
+    Returns:
+        dict: A dictionary containing the impact details with the following keys:
+            - relative (dict): A dictionary with keys representing deciles and values as relative income changes.
+            - average (dict): A dictionary with keys representing deciles and values as average income changes.
+    """
+    if simulation.country != "uk":
+        return {}
+
+    baseline = simulation.calculate("macro/baseline")
+    reform = simulation.calculate("macro/reform")
+
+    baseline_income = MicroSeries(
+        baseline["household"]["finance"]["household_net_income"],
+        weights=baseline["household"]["demographics"]["household_weight"],
+    )
+    reform_income = MicroSeries(
+        reform["household"]["finance"]["household_net_income"],
+        weights=baseline_income.weights,
+    )
+
+    # Filter out negative decile values
+    decile = MicroSeries(baseline["household"]["finance"]["wealth_decile"])
+    baseline_income_filtered = baseline_income[decile >= 0]
+    reform_income_filtered = reform_income[decile >= 0]
+
+    income_change = reform_income_filtered - baseline_income_filtered
+    rel_income_change_by_decile = (
+        income_change.groupby(decile).sum()
+        / baseline_income_filtered.groupby(decile).sum()
+    )
+
+    avg_income_change_by_decile = (
+        income_change.groupby(decile).sum()
+        / baseline_income_filtered.groupby(decile).count()
+    )
+    rel_decile_dict = rel_income_change_by_decile.to_dict()
+    avg_decile_dict = avg_income_change_by_decile.to_dict()
+    result = dict(
+        relative={int(k): v for k, v in rel_decile_dict.items()},
+        average={int(k): v for k, v in avg_decile_dict.items()},
+    )
+    return result

policyengine/outputs/macro/comparison/detailed_budget.py

@@ -0,0 +1,28 @@
+from policyengine import Simulation
+
+
+def detailed_budget(simulation: Simulation):
+    """Calculate the detailed budgetary impact of the given simulation.
+
+    Args:
+        simulation (Simulation): The simulation for which the budgetary impact is to be calculated.
+
+    Returns:
+        dict: A dictionary containing the detailed budgetary impact for each program with the following keys:
+            - baseline (float): The baseline budgetary impact of the program.
+            - reform (float): The reform budgetary impact of the program.
+            - difference (float): The difference between the reform and baseline budgetary impacts.
+    """
+    baseline = simulation.calculate("macro/baseline")
+    reform = simulation.calculate("macro/reform")
+    result = {}
+    if simulation.country == "uk":
+        for program in baseline["gov"]["programs"]:
+            # baseline[programs][program] = total budgetary impact of program
+            result[program] = dict(
+                baseline=baseline["gov"]["programs"][program],
+                reform=reform["gov"]["programs"][program],
+                difference=reform["gov"]["programs"][program]
+                - baseline["gov"]["programs"][program],
+            )
+    return result

policyengine/outputs/macro/comparison/inequality.py

@@ -0,0 +1,34 @@
+from policyengine import Simulation
+
+
+def inequality(simulation: Simulation):
+    """Calculate the impact of the reform on inequality.
+
+    Args:
+        simulation (Simulation): The simulation for which the impact is to be calculated.
+
+    Returns:
+        dict: A dictionary containing the inequality impact details with the following keys:
+            - gini (dict): A dictionary with baseline and reform Gini coefficients.
+            - top_10_pct_share (dict): A dictionary with baseline and reform top 10% income share.
+            - top_1_pct_share (dict): A dictionary with baseline and reform top 1% income share.
+    """
+    baseline = simulation.calculate("macro/baseline")["household"][
+        "inequality"
+    ]
+    reform = simulation.calculate("macro/reform")["household"]["inequality"]
+
+    return dict(
+        gini=dict(
+            baseline=baseline["gini"],
+            reform=reform["gini"],
+        ),
+        top_10_pct_share=dict(
+            baseline=baseline["top_10_percent_share"],
+            reform=reform["top_10_percent_share"],
+        ),
+        top_1_pct_share=dict(
+            baseline=baseline["top_1_percent_share"],
+            reform=reform["top_1_percent_share"],
+        ),
+    )

policyengine/outputs/macro/comparison/labor_supply_response.py

@@ -0,0 +1,109 @@
+from policyengine import Simulation
+from microdf import MicroSeries
+import numpy as np
+
+
+def labor_supply_response(simulation: Simulation) -> dict:
+    baseline = simulation.calculate("macro/baseline")
+    reform = simulation.calculate("macro/reform")
+
+    substitution_lsr = (
+        reform["household"]["labor_supply"]["substitution_lsr"]
+        - baseline["household"]["labor_supply"]["substitution_lsr"]
+    )
+    income_lsr = (
+        reform["household"]["labor_supply"]["income_lsr"]
+        - baseline["household"]["labor_supply"]["income_lsr"]
+    )
+    total_change = substitution_lsr + income_lsr
+    revenue_change = (
+        reform["household"]["labor_supply"]["budgetary_impact_lsr"]
+        - baseline["household"]["labor_supply"]["budgetary_impact_lsr"]
+    )
+
+    substitution_lsr_hh = np.array(
+        reform["household"]["labor_supply"]["substitution_lsr_hh"]
+    ) - np.array(baseline["household"]["labor_supply"]["substitution_lsr_hh"])
+    income_lsr_hh = np.array(
+        reform["household"]["labor_supply"]["income_lsr_hh"]
+    ) - np.array(baseline["household"]["labor_supply"]["income_lsr_hh"])
+    decile = np.array(
+        baseline["household"]["finance"]["household_income_decile"]
+    )
+    household_weight = baseline["household"]["demographics"][
+        "household_weight"
+    ]
+
+    total_lsr_hh = substitution_lsr_hh + income_lsr_hh
+
+    emp_income = MicroSeries(
+        baseline["household"]["finance"]["employment_income_hh"],
+        weights=household_weight,
+    )
+    self_emp_income = MicroSeries(
+        baseline["household"]["finance"]["self_employment_income_hh"],
+        weights=household_weight,
+    )
+    earnings = emp_income + self_emp_income
+    original_earnings = earnings - total_lsr_hh
+    substitution_lsr_hh = MicroSeries(
+        substitution_lsr_hh, weights=household_weight
+    )
+    income_lsr_hh = MicroSeries(income_lsr_hh, weights=household_weight)
+
+    decile_avg = dict(
+        income=income_lsr_hh.groupby(decile).mean().to_dict(),
+        substitution=substitution_lsr_hh.groupby(decile).mean().to_dict(),
+    )
+    decile_rel = dict(
+        income=(
+            income_lsr_hh.groupby(decile).sum()
+            / original_earnings.groupby(decile).sum()
+        ).to_dict(),
+        substitution=(
+            substitution_lsr_hh.groupby(decile).sum()
+            / original_earnings.groupby(decile).sum()
+        ).to_dict(),
+    )
+
+    relative_lsr = dict(
+        income=(income_lsr_hh.sum() / original_earnings.sum()),
+        substitution=(substitution_lsr_hh.sum() / original_earnings.sum()),
+    )
+
+    decile_rel["income"] = {
+        int(k): v for k, v in decile_rel["income"].items() if k > 0
+    }
+    decile_rel["substitution"] = {
+        int(k): v for k, v in decile_rel["substitution"].items() if k > 0
+    }
+
+    hours = dict(
+        baseline=baseline["household"]["labor_supply"]["weekly_hours"],
+        reform=reform["household"]["labor_supply"]["weekly_hours"],
+        change=reform["household"]["labor_supply"]["weekly_hours"]
+        - baseline["household"]["labor_supply"]["weekly_hours"],
+        income_effect=reform["household"]["labor_supply"][
+            "weekly_hours_income_effect"
+        ]
+        - baseline["household"]["labor_supply"]["weekly_hours_income_effect"],
+        substitution_effect=reform["household"]["labor_supply"][
+            "weekly_hours_substitution_effect"
+        ]
+        - baseline["household"]["labor_supply"][
+            "weekly_hours_substitution_effect"
+        ],
+    )
+
+    return dict(
+        substitution_lsr=substitution_lsr,
+        income_lsr=income_lsr,
+        relative_lsr=relative_lsr,
+        total_change=total_change,
+        revenue_change=revenue_change,
+        decile=dict(
+            average=decile_avg,
+            relative=decile_rel,
+        ),
+        hours=hours,
+    )

policyengine/outputs/macro/comparison/local_areas/parliamentary_constituencies/data.py

@@ -0,0 +1,27 @@
+from policyengine import Simulation
+
+
+def data(simulation: Simulation) -> dict:
+    if not simulation.options.get("include_constituencies"):
+        return {}
+
+    constituency_baseline = simulation.calculate(
+        "macro/baseline/gov/local_areas/parliamentary_constituencies"
+    )
+    constituency_reform = simulation.calculate(
+        "macro/reform/gov/local_areas/parliamentary_constituencies"
+    )
+
+    result = {}
+
+    for constituency in constituency_baseline:
+        result[constituency] = {}
+        for key in constituency_baseline[constituency]:
+            result[constituency][key] = {
+                "change": constituency_reform[constituency][key]
+                - constituency_baseline[constituency][key],
+                "baseline": constituency_baseline[constituency][key],
+                "reform": constituency_reform[constituency][key],
+            }
+
+    return result

policyengine/outputs/macro/comparison/local_areas/parliamentary_constituencies/heatmap.py

@@ -0,0 +1,136 @@
+from policyengine import Simulation
+import pandas as pd
+from policyengine.utils.huggingface import download
+import plotly.express as px
+from policyengine.utils.charts import *
+
+
+def heatmap(
+    simulation: Simulation,
+    variable: str = None,
+    aggregator: str = None,
+    relative: bool = None,
+) -> dict:
+    if not simulation.options.get("include_constituencies"):
+        return {}
+
+    options = {}
+
+    if variable is not None:
+        options["variables"] = [variable]
+    if aggregator is not None:
+        options["aggregator"] = aggregator
+
+    constituency_baseline = simulation.calculate(
+        "macro/baseline/gov/local_areas/parliamentary_constituencies",
+        **options,
+    )
+    constituency_reform = simulation.calculate(
+        "macro/reform/gov/local_areas/parliamentary_constituencies", **options
+    )
+
+    result = {}
+
+    constituency_names_file_path = download(
+        repo="policyengine/policyengine-uk-data",
+        repo_filename="constituencies_2024.csv",
+        local_folder=None,
+        version=None,
+    )
+    constituency_names = pd.read_csv(constituency_names_file_path)
+    hex_map_locations = pd.read_csv(
+        "/Users/nikhilwoodruff/uk-local-area-calibration/policyengine_uk_local_areas/hex_map/hex_map_2024.csv"
+    ).set_index("code")
+
+    if variable is None:
+        variable = "household_net_income"
+    if relative is None:
+        relative = True
+
+    for constituency in constituency_baseline:
+        if relative:
+            result[constituency] = (
+                constituency_reform[constituency][variable]
+                / constituency_baseline[constituency][variable]
+                - 1
+            )
+        else:
+            result[constituency] = (
+                constituency_reform[constituency][variable]
+                - constituency_baseline[constituency][variable]
+            )
+
+    constituency_names["x"] = hex_map_locations.loc[
+        constituency_names["code"]
+    ]["x"].values
+    constituency_names["y"] = hex_map_locations.loc[
+        constituency_names["code"]
+    ]["y"].values
+    x_range = constituency_names["x"].max() - constituency_names["x"].min()
+    y_range = constituency_names["y"].max() - constituency_names["y"].min()
+    # Expand x range to preserve aspect ratio
+    expanded_lower_x_range = -(y_range - x_range) / 2
+    expanded_upper_x_range = x_range - expanded_lower_x_range
+    constituency_names.x = (
+        constituency_names.x - (constituency_names.y % 2 == 0) * 0.5
+    )
+    constituency_names["Relative change"] = (
+        pd.Series(list(result.values()), index=list(result.keys()))
+        .loc[constituency_names["name"]]
+        .values
+    )
+
+    label = simulation.baseline.tax_benefit_system.variables[variable].label
+
+    fig = px.scatter(
+        constituency_names,
+        x="x",
+        y="y",
+        color="Relative change",
+        hover_name="name",
+        title=f"{'Relative change' if relative else 'Change'} in {label} by parliamentary constituency",
+    )
+
+    format_fig(fig)
+
+    # Show hexagons on scatter points
+
+    fig.update_traces(
+        marker=dict(
+            symbol="hexagon", line=dict(width=0, color="lightgray"), size=15
+        )
+    )
+    fig.update_layout(
+        xaxis_tickvals=[],
+        xaxis_title="",
+        yaxis_tickvals=[],
+        yaxis_title="",
+        xaxis_range=[expanded_lower_x_range, expanded_upper_x_range],
+        yaxis_range=[
+            constituency_names["y"].min(),
+            constituency_names["y"].max(),
+        ],
+    ).update_traces(marker_size=10).update_layout(
+        xaxis_range=[30, 85], yaxis_range=[-50, 2]
+    )
+
+    x_min = fig.data[0]["marker"]["color"].min()
+    x_max = fig.data[0]["marker"]["color"].max()
+    max_abs = max(abs(x_min), abs(x_max))
+
+    fig.update_layout(
+        coloraxis=dict(
+            cmin=-max_abs,
+            cmax=max_abs,
+            colorscale=[
+                [0, DARK_GRAY],
+                [0.5, "lightgray"],
+                [1, BLUE],
+            ],
+            colorbar=dict(
+                tickformat=".0%" if relative else ",.0f",
+            ),
+        )
+    )
+
+    return fig

policyengine/outputs/macro/comparison/poverty/age.py

@@ -0,0 +1,81 @@
+from policyengine import Simulation
+from microdf import MicroSeries
+
+
+def age(simulation: Simulation):
+    """Calculate the impact of the reform on poverty by age.
+
+    Args:
+        simulation (Simulation): The simulation for which the impact is to be calculated.
+
+    Returns:
+        dict: A dictionary containing the poverty and deep poverty impact details with the following keys:
+            - poverty (dict): A dictionary with keys representing age groups and values as dictionaries with baseline and reform poverty rates.
+            - deep_poverty (dict): A dictionary with keys representing age groups and values as dictionaries with baseline and reform deep poverty rates.
+    """
+    baseline = simulation.calculate("macro/baseline")["household"]["finance"]
+    reform = simulation.calculate("macro/reform")["household"]["finance"]
+    baseline_demographics = simulation.calculate("macro/baseline")[
+        "household"
+    ]["demographics"]
+
+    baseline_poverty = MicroSeries(
+        baseline["person_in_poverty"],
+        weights=baseline_demographics["person_weight"],
+    )
+    baseline_deep_poverty = MicroSeries(
+        baseline["person_in_deep_poverty"],
+        weights=baseline_demographics["person_weight"],
+    )
+    reform_poverty = MicroSeries(
+        reform["person_in_poverty"], weights=baseline_poverty.weights
+    )
+    reform_deep_poverty = MicroSeries(
+        reform["person_in_deep_poverty"], weights=baseline_poverty.weights
+    )
+    age = MicroSeries(baseline_demographics["age"])
+
+    poverty = dict(
+        child=dict(
+            baseline=float(baseline_poverty[age < 18].mean()),
+            reform=float(reform_poverty[age < 18].mean()),
+        ),
+        adult=dict(
+            baseline=float(baseline_poverty[(age >= 18) & (age < 65)].mean()),
+            reform=float(reform_poverty[(age >= 18) & (age < 65)].mean()),
+        ),
+        senior=dict(
+            baseline=float(baseline_poverty[age >= 65].mean()),
+            reform=float(reform_poverty[age >= 65].mean()),
+        ),
+        all=dict(
+            baseline=float(baseline_poverty.mean()),
+            reform=float(reform_poverty.mean()),
+        ),
+    )
+
+    deep_poverty = dict(
+        child=dict(
+            baseline=float(baseline_deep_poverty[age < 18].mean()),
+            reform=float(reform_deep_poverty[age < 18].mean()),
+        ),
+        adult=dict(
+            baseline=float(
+                baseline_deep_poverty[(age >= 18) & (age < 65)].mean()
+            ),
+            reform=float(reform_deep_poverty[(age >= 18) & (age < 65)].mean()),
+        ),
+        senior=dict(
+            baseline=float(baseline_deep_poverty[age >= 65].mean()),
+            reform=float(reform_deep_poverty[age >= 65].mean()),
+        ),
+        all=dict(
+            baseline=float(baseline_deep_poverty.mean()),
+            reform=float(reform_deep_poverty.mean()),
+        ),
+    )
+
+    return dict(
+        poverty=poverty,
+        deep_poverty=deep_poverty,
+    )

policyengine/outputs/macro/comparison/poverty/gender.py

@@ -0,0 +1,65 @@
+from policyengine import Simulation
+from microdf import MicroSeries
+
+
+def gender(simulation: Simulation):
+    """Calculate the impact of the reform on poverty by gender.
+
+    Args:
+        simulation (Simulation): The simulation for which the impact is to be calculated.
+
+    Returns:
+        dict: A dictionary containing the poverty and deep poverty impact details with the following keys:
+            - poverty (dict): A dictionary with keys representing genders and values as dictionaries with baseline and reform poverty rates.
+            - deep_poverty (dict): A dictionary with keys representing genders and values as dictionaries with baseline and reform deep poverty rates.
+    """
+    baseline = simulation.calculate("macro/baseline")["household"]["finance"]
+    reform = simulation.calculate("macro/reform")["household"]["finance"]
+    baseline_demographics = simulation.calculate("macro/baseline")[
+        "household"
+    ]["demographics"]
+
+    if baseline_demographics["is_male"] is None:
+        return {}
+    baseline_poverty = MicroSeries(
+        baseline["person_in_poverty"],
+        weights=baseline_demographics["person_weight"],
+    )
+    baseline_deep_poverty = MicroSeries(
+        baseline["person_in_deep_poverty"],
+        weights=baseline_demographics["person_weight"],
+    )
+    reform_poverty = MicroSeries(
+        reform["person_in_poverty"], weights=baseline_poverty.weights
+    )
+    reform_deep_poverty = MicroSeries(
+        reform["person_in_deep_poverty"], weights=baseline_poverty.weights
+    )
+    is_male = MicroSeries(baseline_demographics["is_male"])
+
+    poverty = dict(
+        male=dict(
+            baseline=float(baseline_poverty[is_male].mean()),
+            reform=float(reform_poverty[is_male].mean()),
+        ),
+        female=dict(
+            baseline=float(baseline_poverty[~is_male].mean()),
+            reform=float(reform_poverty[~is_male].mean()),
+        ),
+    )
+
+    deep_poverty = dict(
+        male=dict(
+            baseline=float(baseline_deep_poverty[is_male].mean()),
+            reform=float(reform_deep_poverty[is_male].mean()),
+        ),
+        female=dict(
+            baseline=float(baseline_deep_poverty[~is_male].mean()),
+            reform=float(reform_deep_poverty[~is_male].mean()),
+        ),
+    )
+
+    return dict(
+        poverty=poverty,
+        deep_poverty=deep_poverty,
+    )