PolicyEngine-UK 2.34.4__tar.gz → 2.35.0__tar.gz

policyengine_uk-2.35.0/.gitignore

@@ -0,0 +1,57 @@
+# Python builds
+
+*.egg-info
+*.pyc
+build
+dist
+
+# Editors
+
+.project
+.pydevproject
+.settings
+.spyderproject
+.vscode/settings.json
+.vscode/launch.json
+.vscode/dryrun.log
+.vscode/targets.log
+.vscode/configurationCache.log
+
+# OS stuff
+
+.DS_Store
+*~
+
+# Data storage
+
+person.csv
+benunit.csv
+household.csv
+
+# Jupyter book
+
+docs/book/_build/
+docs/book/.ipynb_checkpoints
+**/.ipynb_checkpoints
+Untitled.ipynb
+
+# Config files
+
+policyengine_uk/tools/datasets.yml
+
+# Temporary files
+policyengine_uk/calibration/*.csv
+policyengine_uk/calibration/*.yaml
+policyengine_uk/calibration/*.h5
+
+# Microdata
+
+**/*.h5
+**/*.csv
+**/*.pkl
+**/*.log
+**/ukmod.json
+
+*.ipynb
+!docs/**/*.ipynb
+!uprating_growth_factors.csv

policyengine_uk-2.35.0/.vscode/README.md

@@ -0,0 +1,15 @@
+# VS Code Auxiliary Files
+
+This folder contains some helper files that speed up development within Visual Studio Code:
+
+- ```launch.json``` describes the behaviour when debugging Python files within the repo.
+- ```snippets/``` contains code snippets for creating PolicyEngine constructs.
+
+## Code Snippets
+
+The ```snippets/``` folder contains two files:
+
+- ```python.json``` contains snippets for creating variables, formulas and initialising new variables files.
+- ```yaml.json``` contains snippets for creating tests and parameters.
+
+There is a variety of extensions that automatically read in the code snippets, such as [Project Snippets](https://marketplace.visualstudio.com/items?itemName=rebornix.project-snippets), or the same can be achieved by pasting the contents of the files into the user snippets files (accessible via <kbd>CTRL</kbd>+<kbd>SHIFT</kbd>+<kbd>P</kbd> and selecting ```Preferences: configure user snippets```).

{policyengine_uk-2.34.4 → policyengine_uk-2.35.0}/CHANGELOG.md

@@ -5,6 +5,18 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), 
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.35.0] - 2025-07-11 13:43:26
+
+### Changed
+
+- Earnings uprated with OBR average earnings rather than per-capita employment income.
+
+## [2.34.5] - 2025-07-10 16:14:53
+
+### Fixed
+
+- HBAI documentation updated to include Healthy Start vouchers and external child payments.
+
 ## [2.34.4] - 2025-07-10 16:12:40
 
 ### Added
@@ -1885,6 +1897,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 
 
+[2.35.0]: https://github.com/PolicyEngine/openfisca-uk/compare/2.34.5...2.35.0
+[2.34.5]: https://github.com/PolicyEngine/openfisca-uk/compare/2.34.4...2.34.5
 [2.34.4]: https://github.com/PolicyEngine/openfisca-uk/compare/2.34.3...2.34.4
 [2.34.3]: https://github.com/PolicyEngine/openfisca-uk/compare/2.34.2...2.34.3
 [2.34.2]: https://github.com/PolicyEngine/openfisca-uk/compare/2.34.1...2.34.2

policyengine_uk-2.35.0/PKG-INFO

@@ -0,0 +1,72 @@
+Metadata-Version: 2.4
+Name: policyengine-uk
+Version: 2.35.0
+Summary: PolicyEngine tax and benefit system for the UK
+Project-URL: Homepage, https://github.com/PolicyEngine/policyengine-uk
+Project-URL: Repository, https://github.com/PolicyEngine/policyengine-uk
+Author-email: PolicyEngine <nikhil@policyengine.org>
+Maintainer-email: Nikhil Woodruff <nikhil.woodruff@outlook.com>
+License: AGPL-3.0
+License-File: LICENSE
+Keywords: benefit,microsimulation,social,tax
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: License :: OSI Approved :: GNU Affero General Public License v3
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: Python
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Requires-Python: >=3.10
+Requires-Dist: microdf-python
+Requires-Dist: policyengine-core>=3.6.4
+Provides-Extra: dev
+Requires-Dist: black; extra == 'dev'
+Requires-Dist: coverage; extra == 'dev'
+Requires-Dist: furo<2023; extra == 'dev'
+Requires-Dist: jupyter-book; extra == 'dev'
+Requires-Dist: linecheck; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: setuptools; extra == 'dev'
+Requires-Dist: snowballstemmer<3,>=2; extra == 'dev'
+Requires-Dist: sphinx-argparse<1,>=0.3.2; extra == 'dev'
+Requires-Dist: sphinx-math-dollar<2,>=1.2.1; extra == 'dev'
+Requires-Dist: tqdm; extra == 'dev'
+Requires-Dist: wheel; extra == 'dev'
+Requires-Dist: yaml-changelog>=0.1.7; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# PolicyEngine UK
+
+[![PyPI version](https://badge.fury.io/py/policyengine-uk.svg)](https://badge.fury.io/py/policyengine-uk)
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+
+PolicyEngine UK is [PolicyEngine](https://policyengine.org)'s microsimulation model of the UK tax-benefit system.
+It uses the PolicyEngine Core microsimulation framework, which is based on [OpenFisca](https://openfisca.org).
+
+The elements are described in different folders. All the modelling happens within the `policyengine_uk` folder.
+
+- The rates and other system parameters are in the `parameters` folder.
+- The formulas and inputs are in the `variables` folder.
+- This country package comes also with reforms in the `reforms` folder.
+
+The files that are outside from the `policyengine_uk` folder are used to set up the development environment. Installation instructions are located along with other documentation in the `docs` folder.
+
+The model supports multiple different input datasets provided by the user, one of which is the Family Resources Survey,[^1] containing microdata on household incomes across the UK.
+PolicyEngine UK enhances this dataset by fusing it to other surveys and reweighting it to minimize a comprehensive loss metric that measures the difference from an array of administrative totals.
+
+[^1]: Department for Work and Pensions, Office for National Statistics, NatCen Social Research. (2021). Family Resources Survey, 2019-2020. [data collection]. UK Data Service. SN: 8802, http://doi.org/10.5255/UKDA-SN-8802-1
+
+
+## Fast setup instructions
+
+1. Run `pip install policyengine-uk`
+
+2. Run `policyengine-uk` and go through the prompt to setup microdata.
+
+
+## Contact
+
+The primary maintainer for PolicyEngine UK is Nikhil Woodruff, co-founder and CTO of PolicyEngine (nikhil@policyengine.org).
+
+
+## Citation
+
+You may cite the source of your analysis as "PolicyEngine UK release #.#.#, author's calculations."

policyengine_uk-2.35.0/policyengine_uk/data/economic_assumptions.py

@@ -0,0 +1,192 @@
+import pandas as pd
+from pathlib import Path
+from policyengine_uk.data.dataset_schema import UKDataset
+
+START_YEAR = 2020
+END_YEAR = 2029
+
+
+def create_policyengine_uprating_factors_table(print_diff=True):
+    from policyengine_uk.system import system
+
+    df = pd.DataFrame()
+
+    variable_names = []
+    years = []
+    index_values = []
+
+    parameter_by_variable = {}
+
+    for variable in system.variables.values():
+        if variable.uprating is not None:
+            parameter = system.parameters.get_child(variable.uprating)
+            parameter_by_variable[variable.name] = parameter.name
+            start_value = parameter(START_YEAR)
+            for year in range(START_YEAR, END_YEAR + 1):
+                variable_names.append(variable.name)
+                years.append(str(year))  # Convert to string here
+                growth = parameter(year) / start_value
+                index_values.append(round(growth, 3))
+
+    df["Variable"] = variable_names
+    df["Year"] = years
+    df["Value"] = index_values
+
+    # Convert to there is a column for each year
+    df = df.pivot(index="Variable", columns="Year", values="Value")
+    df = df.sort_values("Variable")
+
+    # Create a table with growth factors by year
+
+    df_growth = df.copy()
+    for year in range(END_YEAR, START_YEAR, -1):
+        year_str = str(year)
+        prev_year_str = str(year - 1)
+        df_growth[year_str] = round(
+            df_growth[year_str] / df_growth[prev_year_str] - 1, 3
+        )
+    df_growth[str(START_YEAR)] = 0
+
+    file_path = Path(__file__).parent / "uprating_growth_factors.csv"
+
+    # Read old CSV if it exists
+    old_df = None
+    if file_path.exists():
+        old_df = pd.read_csv(file_path, index_col=0)
+        # Ensure all columns are strings in old_df
+        old_df.columns = old_df.columns.astype(str)
+
+    # Prepare new dataframe
+    df_growth["Parameter"] = df.index.map(parameter_by_variable)
+    df_growth = df_growth[
+        ["Parameter"] + [str(year) for year in range(START_YEAR, END_YEAR + 1)]
+    ]
+
+    # Print diff if old CSV existed and print_diff is True
+    if old_df is not None and print_diff:
+        print_csv_diff(old_df, df_growth)
+        # Save new CSV
+        df_growth.to_csv(file_path)
+
+    return pd.read_csv(file_path)
+
+
+def print_csv_diff(old_df, new_df):
+    """Print differences between old and new dataframes."""
+    print("\n" + "=" * 80)
+    print("CSV diff report")
+    print("=" * 80)
+
+    # Check for new rows
+    new_rows = set(new_df.index) - set(old_df.index)
+    if new_rows:
+        print(f"\n✅ New rows added ({len(new_rows)}):")
+        for row in sorted(new_rows):
+            print(f"  - {row}")
+
+    # Check for deleted rows
+    deleted_rows = set(old_df.index) - set(new_df.index)
+    if deleted_rows:
+        print(f"\n❌ Rows deleted ({len(deleted_rows)}):")
+        for row in sorted(deleted_rows):
+            print(f"  - {row}")
+
+    # Check for changed values
+    common_rows = set(old_df.index) & set(new_df.index)
+    common_cols = set(old_df.columns) & set(new_df.columns)
+
+    changes = []
+    for row in common_rows:
+        for col in common_cols:
+            old_val = old_df.loc[row, col]
+            new_val = new_df.loc[row, col]
+
+            # Handle NaN values
+            if pd.isna(old_val) and pd.isna(new_val):
+                continue
+            elif pd.isna(old_val) or pd.isna(new_val):
+                changes.append((row, col, old_val, new_val))
+            elif old_val != new_val:
+                changes.append((row, col, old_val, new_val))
+
+    if changes:
+        print(f"\n🔄 Value changes ({len(changes)}):")
+        print(
+            f"{'Variable':<30} {'Column':<15} {'Old value':<15} {'New value':<15}"
+        )
+        print("-" * 75)
+        for row, col, old_val, new_val in sorted(changes):
+            old_str = str(old_val) if not pd.isna(old_val) else "NaN"
+            new_str = str(new_val) if not pd.isna(new_val) else "NaN"
+            print(f"{row:<30} {str(col):<15} {old_str:<15} {new_str:<15}")
+
+    # Check for new columns
+    new_cols = set(new_df.columns) - set(old_df.columns)
+    if new_cols:
+        print(f"\n✅ New columns added ({len(new_cols)}):")
+        for col in sorted(new_cols):
+            print(f"  - {col}")
+
+    # Check for deleted columns
+    deleted_cols = set(old_df.columns) - set(new_df.columns)
+    if deleted_cols:
+        print(f"\n❌ Columns deleted ({len(deleted_cols)}):")
+        for col in sorted(deleted_cols):
+            print(f"  - {col}")
+
+    if not (new_rows or deleted_rows or changes or new_cols or deleted_cols):
+        print("\n✨ No changes detected - CSV is identical!")
+
+    print("\n" + "=" * 80 + "\n")
+
+
+def convert_yoy_growth_to_index(
+    growth_factors: pd.DataFrame,
+):
+    """
+    Convert year-on-year growth factors to an index.
+    """
+    growth_factors = growth_factors.copy()
+    # Get the first year column (skip 'Variable' and 'Parameter' columns)
+    year_columns = [
+        col
+        for col in growth_factors.columns
+        if col not in ["Variable", "Parameter"]
+    ]
+    index = growth_factors[year_columns[0]] * 0 + 1
+    for year in year_columns:
+        index *= 1 + growth_factors[year]
+        growth_factors[year] = index
+    return growth_factors
+
+
+def apply_growth_factors(
+    dataset: UKDataset,
+    growth_factors: pd.DataFrame,
+    start_year: int,
+    end_year: int,
+):
+    start_year = str(start_year)
+    end_year = str(end_year)
+    dataset = dataset.copy()
+    growth_factors_indices = convert_yoy_growth_to_index(growth_factors)
+    for i in range(len(growth_factors)):
+        variable = growth_factors["Variable"].values[i]
+        start_index = growth_factors_indices[start_year].values[i]
+        end_index = growth_factors_indices[end_year].values[i]
+
+        for table in dataset.tables:
+            if variable in table.columns:
+                table[variable] *= end_index / start_index
+
+    return dataset
+
+
+BASELINE_GROWFACTORS = create_policyengine_uprating_factors_table(
+    print_diff=False
+)
+
+
+if __name__ == "__main__":
+    # Print diff when running as script
+    create_policyengine_uprating_factors_table(print_diff=True)

{policyengine_uk-2.34.4 → policyengine_uk-2.35.0}/policyengine_uk/data/uprating_growth_factors.csv

@@ -19,13 +19,15 @@ dla_m_reported,gov.obr.consumer_price_index,0,0.039,0.101,0.057,0.023,0.032,0.02
 dla_sc_reported,gov.obr.consumer_price_index,0,0.039,0.101,0.057,0.023,0.032,0.02,0.02,0.02,0.02
 domestic_energy_consumption,gov.obr.consumer_price_index,0,0.039,0.101,0.057,0.023,0.032,0.02,0.02,0.02,0.02
 education_consumption,gov.obr.consumer_price_index,0,0.039,0.101,0.057,0.023,0.032,0.02,0.02,0.02,0.02
-employee_pension_contributions,gov.obr.per_capita.employment_income,0,0.072,0.074,0.062,0.05,0.033,0.02,0.019,0.023,0.026
-employer_pension_contributions,gov.obr.per_capita.employment_income,0,0.072,0.074,0.062,0.05,0.033,0.02,0.019,0.023,0.026
-employment_income,gov.obr.per_capita.employment_income,0,0.072,0.074,0.062,0.05,0.033,0.02,0.019,0.023,0.026
-employment_income_before_lsr,gov.obr.per_capita.employment_income,0,0.072,0.074,0.062,0.05,0.033,0.02,0.019,0.023,0.026
+employee_pension_contributions,gov.obr.average_earnings,0,0.058,0.065,0.068,0.047,0.038,0.021,0.021,0.023,0.025
+employer_pension_contributions,gov.obr.average_earnings,0,0.058,0.065,0.068,0.047,0.038,0.021,0.021,0.023,0.025
+employment_income,gov.obr.average_earnings,0,0.058,0.065,0.068,0.047,0.038,0.021,0.021,0.023,0.025
+employment_income_before_lsr,gov.obr.average_earnings,0,0.058,0.065,0.068,0.047,0.038,0.021,0.021,0.023,0.025
 esa_contrib_reported,gov.obr.consumer_price_index,0,0.039,0.101,0.057,0.023,0.032,0.02,0.02,0.02,0.02
 esa_income_reported,gov.obr.consumer_price_index,0,0.039,0.101,0.057,0.023,0.032,0.02,0.02,0.02,0.02
 food_and_non_alcoholic_beverages_consumption,gov.obr.consumer_price_index,0,0.039,0.101,0.057,0.023,0.032,0.02,0.02,0.02,0.02
+free_school_fruit_veg,gov.obr.consumer_price_index,0,0.039,0.101,0.057,0.023,0.032,0.02,0.02,0.02,0.02
+free_school_meals,gov.obr.consumer_price_index,0,0.039,0.101,0.057,0.023,0.032,0.02,0.02,0.02,0.02
 free_school_milk,gov.obr.consumer_price_index,0,0.039,0.101,0.057,0.023,0.032,0.02,0.02,0.02,0.02
 gross_financial_wealth,household.wealth.financial_assets,0,0.014,-0.108,0.004,0.03,0.032,0.034,0.034,0.036,0.0
 health_consumption,gov.obr.consumer_price_index,0,0.039,0.101,0.057,0.023,0.032,0.02,0.02,0.02,0.02
@@ -54,7 +56,7 @@ other_residential_property_value,household.wealth.financial_assets,0,0.014,-0.10
 owned_land,household.wealth.financial_assets,0,0.014,-0.108,0.004,0.03,0.032,0.034,0.034,0.036,0.0
 pension_credit_reported,gov.obr.consumer_price_index,0,0.039,0.101,0.057,0.023,0.032,0.02,0.02,0.02,0.02
 pension_income,gov.obr.per_capita.gdp,0,0.125,0.092,0.05,0.038,0.028,0.028,0.031,0.033,0.033
-personal_pension_contributions,gov.obr.per_capita.employment_income,0,0.072,0.074,0.062,0.05,0.033,0.02,0.019,0.023,0.026
+personal_pension_contributions,gov.obr.average_earnings,0,0.058,0.065,0.068,0.047,0.038,0.021,0.021,0.023,0.025
 petrol_spending,gov.obr.consumer_price_index,0,0.039,0.101,0.057,0.023,0.032,0.02,0.02,0.02,0.02
 pip_dl_reported,gov.obr.consumer_price_index,0,0.039,0.101,0.057,0.023,0.032,0.02,0.02,0.02,0.02
 pip_m_reported,gov.obr.consumer_price_index,0,0.039,0.101,0.057,0.023,0.032,0.02,0.02,0.02,0.02

policyengine_uk-2.35.0/policyengine_uk/tests/microsimulation/README.md

@@ -0,0 +1,126 @@
+# PolicyEngine UK reform impact tests
+
+This directory contains automated tests to monitor when model changes affect the fiscal impacts of policy reforms. It helps ensure that updates to the PolicyEngine UK model don't unexpectedly change reform outcomes.
+
+## Overview
+
+The testing framework consists of three main components:
+
+1. **reforms_config.yaml** - Configuration file containing reform definitions and their expected impacts
+2. **test_reform_impacts.py** - Pytest test suite that verifies reforms produce expected impacts
+3. **update_reform_impacts.py** - Script to update expected impacts when model changes are intentional
+
+## Quick start
+
+### Running tests
+
+To check if current model produces expected reform impacts:
+
+```bash
+pytest test_reform_impacts.py
+```
+
+To run with more detail:
+
+```bash
+pytest test_reform_impacts.py -v
+```
+
+### Updating expected impacts
+
+When model changes are intentional and you need to update the baseline expectations:
+
+```bash
+# Preview changes without updating
+python update_reform_impacts.py --dry-run
+
+# Update the configuration file
+python update_reform_impacts.py
+
+# Update with detailed output
+python update_reform_impacts.py --verbose
+```
+
+## Configuration file structure
+
+The `reforms_config.yaml` file defines each reform with:
+
+```yaml
+reforms:
+  - name: "Description of the reform"
+    expected_impact: 10.5  # Fiscal impact in billions
+    parameters:
+      "gov.some.parameter": 0.25
+      "gov.another.parameter": 1000
+```
+
+## Workflow
+
+### Regular testing
+
+1. Run `pytest policyengine_uk/tests/microsimulation/test_reform_impacts.py` as part of your CI/CD pipeline
+2. Tests will fail if any reform impact differs by more than £0.1 billion from expected
+3. This catches unintended consequences of model changes
+
+### After intentional model changes
+
+1. Run `python policyengine_uk/tests/microsimulation/update_reform_impacts.py --dry-run` to preview impact changes
+2. Review the changes to ensure they're expected
+3. Run `python policyengine_uk/tests/microsimulation/update_reform_impacts.py` to update the configuration
+4. Commit both the model changes and updated `reforms_config.yaml`
+
+### Adding new reforms
+
+1. Add a new entry to `reforms_config.yaml`:
+   ```yaml
+   - name: "Your new reform description"
+     expected_impact: 0.0  # Initial placeholder
+     parameters:
+       "gov.parameter.to.change": new_value
+   ```
+
+2. Run `python policyengine_uk/tests/microsimulation/update_reform_impacts.py` to calculate the actual impact
+3. Run `pytest policyengine_uk/tests/microsimulation/test_reform_impacts.py` to verify the test passes
+
+## Test tolerance
+
+Tests allow for a tolerance of £0.1 billion in fiscal impacts. This accounts for:
+- Minor numerical differences in calculations
+- Small variations from microsimulation sampling
+
+If you need to adjust this tolerance, modify the assertion in `test_reform_impacts.py`.
+
+## Troubleshooting
+
+### Tests failing after model update
+
+1. Check if the changes are expected by running the update script with `--dry-run`
+2. If changes are expected, update the configuration file
+3. If changes are unexpected, investigate the model modifications
+
+### Import errors
+
+Ensure you have the required dependencies:
+```bash
+pip install policyengine-uk pytest pyyaml
+```
+
+### Configuration file not found
+
+The tests expect `reforms_config.yaml` to be in the same directory as the test file. You can specify a different path:
+
+```bash
+python update_reform_impacts.py --config /path/to/reforms_config.yaml
+```
+
+## Example reforms
+
+The configuration includes various UK tax and benefit reforms:
+- Income tax rate changes (basic, higher, additional rates)
+- Personal allowance adjustments
+- National Insurance contribution rates
+- VAT rate changes
+- Universal Credit taper rate modifications
+- Child benefit amount changes
+
+Each reform's fiscal impact is measured as the change in government balance (in billions) for the year 2029.

policyengine_uk-2.35.0/policyengine_uk/tests/microsimulation/reforms_config.yaml

@@ -0,0 +1,33 @@
+reforms:
+- name: Raise basic rate by 1pp
+  expected_impact: 7.8
+  parameters:
+    gov.hmrc.income_tax.rates.uk[0].rate: 0.21
+- name: Raise higher rate by 1pp
+  expected_impact: 5.0
+  parameters:
+    gov.hmrc.income_tax.rates.uk[1].rate: 0.42
+- name: Raise personal allowance by ~800GBP/year
+  expected_impact: 0.8
+  parameters:
+    gov.hmrc.income_tax.allowances.personal_allowance.amount: 13000
+- name: Raise child benefit by 25GBP/week per additional child
+  expected_impact: -1.3
+  parameters:
+    gov.hmrc.child_benefit.amount.additional: 25
+- name: Reduce Universal Credit taper rate to 20%
+  expected_impact: -38.2
+  parameters:
+    gov.dwp.universal_credit.means_test.reduction_rate: 0.2
+- name: Raise Class 1 main employee NICs rate to 10%
+  expected_impact: 12.4
+  parameters:
+    gov.hmrc.national_insurance.class_1.rates.employee.main: 0.1
+- name: Raise VAT standard rate by 2pp
+  expected_impact: 19.5
+  parameters:
+    gov.hmrc.vat.standard_rate: 0.22
+- name: Raise additional rate by 3pp
+  expected_impact: 4.5
+  parameters:
+    gov.hmrc.income_tax.rates.uk[2].rate: 0.48

policyengine_uk-2.35.0/policyengine_uk/tests/microsimulation/test_reform_impacts.py

@@ -0,0 +1,83 @@
+"""
+Test suite for PolicyEngine UK reform fiscal impacts.
+This file tests that model changes don't unexpectedly change reform impacts.
+"""
+
+import pytest
+import yaml
+from pathlib import Path
+from policyengine_uk import Microsimulation
+
+
+# Load configuration from YAML file
+config_path = Path(__file__).parent / "reforms_config.yaml"
+with open(config_path, "r") as f:
+    config = yaml.safe_load(f)
+
+reforms_data = config["reforms"]
+
+# Initialize baseline simulation
+baseline = Microsimulation()
+
+
+def get_fiscal_impact(reform: dict) -> float:
+    """
+    Calculate the fiscal impact of a reform in billions.
+
+    Args:
+        reform: Dictionary of reform parameters
+
+    Returns:
+        Fiscal impact in billions (positive = revenue increase)
+    """
+    baseline_revenue = baseline.calculate("gov_balance", 2029).sum()
+    reform_simulation = Microsimulation(reform=reform)
+    reform_revenue = reform_simulation.calculate("gov_balance", 2029).sum()
+    return (reform_revenue - baseline_revenue) / 1e9
+
+
+# Extract test parameters from configuration
+test_params = [
+    (reform["parameters"], reform["name"], reform["expected_impact"])
+    for reform in reforms_data
+]
+
+reform_names = [reform["name"] for reform in reforms_data]
+
+
+@pytest.mark.parametrize(
+    "reform, reform_name, expected_impact",
+    test_params,
+    ids=reform_names,
+)
+def test_reform_fiscal_impacts(reform, reform_name, expected_impact):
+    """Test that each reform produces the expected fiscal impact."""
+    impact = get_fiscal_impact(reform)
+
+    # Allow for small numerical differences (0.1 billion tolerance)
+    assert (
+        abs(impact - expected_impact) < 0.1
+    ), f"Impact for {reform_name} is {impact:.1f} billion, expected {expected_impact:.1f} billion"
+
+
+def test_config_file_exists():
+    """Test that the configuration file exists and is valid."""
+    assert config_path.exists(), "reforms_config.yaml file not found"
+    assert "reforms" in config, "reforms key not found in configuration"
+    assert len(config["reforms"]) > 0, "No reforms defined in configuration"
+
+
+def test_all_reforms_have_required_fields():
+    """Test that all reforms have the required fields."""
+    required_fields = ["name", "expected_impact", "parameters"]
+
+    for i, reform in enumerate(reforms_data):
+        for field in required_fields:
+            assert (
+                field in reform
+            ), f"Reform {i} missing required field: {field}"
+
+        assert isinstance(
+            reform["parameters"], dict
+        ), f"Reform {i} parameters must be a dictionary"
+        assert len(reform["parameters"]) > 0, f"Reform {i} has no parameters"