policyengine 3.1.13__py3-none-any.whl → 3.1.15__py3-none-any.whl

policyengine/core/tax_benefit_model_version.py

@@ -24,7 +24,15 @@ class TaxBenefitModelVersion(BaseModel):
 
     variables: list["Variable"] = Field(default_factory=list)
     parameters: list["Parameter"] = Field(default_factory=list)
-    parameter_values: list["ParameterValue"] = Field(default_factory=list)
+
+    @property
+    def parameter_values(self) -> list["ParameterValue"]:
+        """Aggregate all parameter values from all parameters."""
+        return [
+            pv
+            for parameter in self.parameters
+            for pv in parameter.parameter_values
+        ]
 
     # Lookup dicts for O(1) access (excluded from serialization)
     variables_by_name: dict[str, "Variable"] = Field(

policyengine/outputs/decile_impact.py

@@ -2,6 +2,10 @@ import pandas as pd
 from pydantic import ConfigDict
 
 from policyengine.core import Output, OutputCollection, Simulation
+from policyengine.core.dataset import Dataset
+from policyengine.core.dynamic import Dynamic
+from policyengine.core.policy import Policy
+from policyengine.core.tax_benefit_model_version import TaxBenefitModelVersion
 
 
 class DecileImpact(Output):
@@ -93,8 +97,11 @@ class DecileImpact(Output):
 
 
 def calculate_decile_impacts(
-    baseline_simulation: Simulation,
-    reform_simulation: Simulation,
+    dataset: Dataset,
+    tax_benefit_model_version: TaxBenefitModelVersion,
+    baseline_policy: Policy | None = None,
+    reform_policy: Policy | None = None,
+    dynamic: Dynamic | None = None,
     income_variable: str = "equiv_hbai_household_net_income",
     entity: str | None = None,
     quantiles: int = 10,
@@ -104,6 +111,19 @@ def calculate_decile_impacts(
     Returns:
         OutputCollection containing list of DecileImpact objects and DataFrame
     """
+    baseline_simulation = Simulation(
+        dataset=dataset,
+        tax_benefit_model_version=tax_benefit_model_version,
+        policy=baseline_policy,
+        dynamic=dynamic,
+    )
+    reform_simulation = Simulation(
+        dataset=dataset,
+        tax_benefit_model_version=tax_benefit_model_version,
+        policy=reform_policy,
+        dynamic=dynamic,
+    )
+
     results = []
     for decile in range(1, quantiles + 1):
         impact = DecileImpact(

policyengine/tax_benefit_models/uk/__init__.py

@@ -5,7 +5,12 @@ from importlib.util import find_spec
 if find_spec("policyengine_uk") is not None:
     from policyengine.core import Dataset
 
-    from .analysis import general_policy_reform_analysis
+    from .analysis import (
+        UKHouseholdInput,
+        UKHouseholdOutput,
+        calculate_household_impact,
+        economic_impact_analysis,
+    )
     from .datasets import (
         PolicyEngineUKDataset,
         UKYearData,
@@ -37,7 +42,10 @@ if find_spec("policyengine_uk") is not None:
         "PolicyEngineUKLatest",
         "uk_model",
         "uk_latest",
-        "general_policy_reform_analysis",
+        "economic_impact_analysis",
+        "calculate_household_impact",
+        "UKHouseholdInput",
+        "UKHouseholdOutput",
         "ProgrammeStatistics",
     ]
 else:

policyengine/tax_benefit_models/uk/analysis.py

@@ -1,17 +1,175 @@
 """General utility functions for UK policy reform analysis."""
 
+import tempfile
+from pathlib import Path
+from typing import Any
+
 import pandas as pd
-from pydantic import BaseModel
+from microdf import MicroDataFrame
+from pydantic import BaseModel, Field, create_model
 
 from policyengine.core import OutputCollection, Simulation
+from policyengine.core.policy import Policy
 from policyengine.outputs.decile_impact import (
     DecileImpact,
     calculate_decile_impacts,
 )
 
+from .datasets import PolicyEngineUKDataset, UKYearData
+from .model import uk_latest
 from .outputs import ProgrammeStatistics
 
 
+def _create_entity_output_model(
+    entity: str, variables: list[str]
+) -> type[BaseModel]:
+    """Create a dynamic Pydantic model for entity output variables."""
+    fields = {var: (float, ...) for var in variables}
+    return create_model(f"{entity.title()}Output", **fields)
+
+
+# Create output models dynamically from uk_latest.entity_variables
+PersonOutput = _create_entity_output_model(
+    "person", uk_latest.entity_variables["person"]
+)
+BenunitOutput = _create_entity_output_model(
+    "benunit", uk_latest.entity_variables["benunit"]
+)
+HouseholdEntityOutput = _create_entity_output_model(
+    "household", uk_latest.entity_variables["household"]
+)
+
+
+class UKHouseholdOutput(BaseModel):
+    """Output from a UK household calculation with all entity data."""
+
+    person: list[dict[str, Any]]
+    benunit: list[dict[str, Any]]
+    household: dict[str, Any]
+
+
+class UKHouseholdInput(BaseModel):
+    """Input for a UK household calculation."""
+
+    people: list[dict[str, Any]]
+    benunit: dict[str, Any] = Field(default_factory=dict)
+    household: dict[str, Any] = Field(default_factory=dict)
+    year: int = 2026
+
+
+def calculate_household_impact(
+    household_input: UKHouseholdInput,
+    policy: Policy | None = None,
+) -> UKHouseholdOutput:
+    """Calculate tax and benefit impacts for a single UK household."""
+    n_people = len(household_input.people)
+
+    # Build person data with defaults
+    person_data = {
+        "person_id": list(range(n_people)),
+        "person_benunit_id": [0] * n_people,
+        "person_household_id": [0] * n_people,
+        "person_weight": [1.0] * n_people,
+    }
+    # Add user-provided person fields
+    for i, person in enumerate(household_input.people):
+        for key, value in person.items():
+            if key not in person_data:
+                person_data[key] = [
+                    0.0
+                ] * n_people  # Default to 0 for numeric fields
+            person_data[key][i] = value
+
+    # Build benunit data with defaults
+    benunit_data = {
+        "benunit_id": [0],
+        "benunit_weight": [1.0],
+    }
+    for key, value in household_input.benunit.items():
+        benunit_data[key] = [value]
+
+    # Build household data with defaults (required for uprating)
+    household_data = {
+        "household_id": [0],
+        "household_weight": [1.0],
+        "region": ["LONDON"],
+        "tenure_type": ["RENT_PRIVATELY"],
+        "council_tax": [0.0],
+        "rent": [0.0],
+    }
+    for key, value in household_input.household.items():
+        household_data[key] = [value]
+
+    # Create MicroDataFrames
+    person_df = MicroDataFrame(
+        pd.DataFrame(person_data), weights="person_weight"
+    )
+    benunit_df = MicroDataFrame(
+        pd.DataFrame(benunit_data), weights="benunit_weight"
+    )
+    household_df = MicroDataFrame(
+        pd.DataFrame(household_data), weights="household_weight"
+    )
+
+    # Create temporary dataset
+    tmpdir = tempfile.mkdtemp()
+    filepath = str(Path(tmpdir) / "household_impact.h5")
+
+    dataset = PolicyEngineUKDataset(
+        name="Household impact calculation",
+        description="Single household for impact calculation",
+        filepath=filepath,
+        year=household_input.year,
+        data=UKYearData(
+            person=person_df,
+            benunit=benunit_df,
+            household=household_df,
+        ),
+    )
+
+    # Run simulation
+    simulation = Simulation(
+        dataset=dataset,
+        tax_benefit_model_version=uk_latest,
+        policy=policy,
+    )
+    simulation.run()
+
+    # Extract all output variables defined in entity_variables
+    output_data = simulation.output_dataset.data
+
+    def safe_convert(value):
+        """Convert value to float if numeric, otherwise return as string."""
+        try:
+            return float(value)
+        except (ValueError, TypeError):
+            return str(value)
+
+    person_outputs = []
+    for i in range(n_people):
+        person_dict = {}
+        for var in uk_latest.entity_variables["person"]:
+            person_dict[var] = safe_convert(output_data.person[var].iloc[i])
+        person_outputs.append(person_dict)
+
+    benunit_outputs = []
+    for i in range(len(output_data.benunit)):
+        benunit_dict = {}
+        for var in uk_latest.entity_variables["benunit"]:
+            benunit_dict[var] = safe_convert(output_data.benunit[var].iloc[i])
+        benunit_outputs.append(benunit_dict)
+
+    household_dict = {}
+    for var in uk_latest.entity_variables["household"]:
+        household_dict[var] = safe_convert(output_data.household[var].iloc[0])
+
+    return UKHouseholdOutput(
+        person=person_outputs,
+        benunit=benunit_outputs,
+        household=household_dict,
+    )
+
+
 class PolicyReformAnalysis(BaseModel):
     """Complete policy reform analysis result."""
 
@@ -19,7 +177,7 @@ class PolicyReformAnalysis(BaseModel):
     programme_statistics: OutputCollection[ProgrammeStatistics]
 
 
-def general_policy_reform_analysis(
+def economic_impact_analysis(
     baseline_simulation: Simulation,
     reform_simulation: Simulation,
 ) -> PolicyReformAnalysis:
@@ -28,10 +186,23 @@ def general_policy_reform_analysis(
     Returns:
         PolicyReformAnalysis containing decile impacts and programme statistics
     """
+    baseline_simulation.ensure()
+    reform_simulation.ensure()
+
+    assert len(baseline_simulation.dataset.data.household) > 100, (
+        "Baseline simulation must have more than 100 households"
+    )
+    assert len(reform_simulation.dataset.data.household) > 100, (
+        "Reform simulation must have more than 100 households"
+    )
+
     # Decile impact
     decile_impacts = calculate_decile_impacts(
-        baseline_simulation=baseline_simulation,
-        reform_simulation=reform_simulation,
+        dataset=baseline_simulation.dataset,
+        tax_benefit_model_version=baseline_simulation.tax_benefit_model_version,
+        baseline_policy=baseline_simulation.policy,
+        reform_policy=reform_simulation.policy,
+        dynamic=baseline_simulation.dynamic,
     )
 
     # Major programmes to analyse

policyengine/tax_benefit_models/uk/datasets.py

@@ -196,8 +196,8 @@ def load_datasets(
         for year in years:
             filepath = f"{data_folder}/{Path(dataset).stem}_year_{year}.h5"
             uk_dataset = PolicyEngineUKDataset(
-                name=f"{dataset}-year-{year}",
-                description=f"UK Dataset for year {year} based on {dataset}",
+                name=f"{Path(dataset).stem}-year-{year}",
+                description=f"UK Dataset for year {year} based on {Path(dataset).stem}",
                 filepath=filepath,
                 year=int(year),
             )

policyengine/tax_benefit_models/uk/model.py

@@ -9,12 +9,10 @@ from microdf import MicroDataFrame
 
 from policyengine.core import (
     Parameter,
-    ParameterValue,
     TaxBenefitModel,
     TaxBenefitModelVersion,
     Variable,
 )
-from policyengine.utils import parse_safe_date
 
 from .datasets import PolicyEngineUKDataset, UKYearData
 
@@ -108,6 +106,11 @@ class PolicyEngineUKLatest(TaxBenefitModelVersion):
             "rent",
             "council_tax",
             "tenure_type",
+            # Poverty measures
+            "in_poverty_bhc",
+            "in_poverty_ahc",
+            "in_relative_poverty_bhc",
+            "in_relative_poverty_ahc",
         ],
     }
 

policyengine/tax_benefit_models/us/__init__.py

@@ -5,7 +5,12 @@ from importlib.util import find_spec
 if find_spec("policyengine_us") is not None:
     from policyengine.core import Dataset
 
-    from .analysis import general_policy_reform_analysis
+    from .analysis import (
+        USHouseholdInput,
+        USHouseholdOutput,
+        calculate_household_impact,
+        economic_impact_analysis,
+    )
     from .datasets import (
         PolicyEngineUSDataset,
         USYearData,
@@ -37,7 +42,10 @@ if find_spec("policyengine_us") is not None:
         "PolicyEngineUSLatest",
         "us_model",
         "us_latest",
-        "general_policy_reform_analysis",
+        "economic_impact_analysis",
+        "calculate_household_impact",
+        "USHouseholdInput",
+        "USHouseholdOutput",
         "ProgramStatistics",
     ]
 else:

policyengine/tax_benefit_models/us/analysis.py

@@ -1,17 +1,193 @@
 """General utility functions for US policy reform analysis."""
 
+import tempfile
+from pathlib import Path
+from typing import Any
+
 import pandas as pd
-from pydantic import BaseModel
+from microdf import MicroDataFrame
+from pydantic import BaseModel, Field
 
 from policyengine.core import OutputCollection, Simulation
+from policyengine.core.policy import Policy
 from policyengine.outputs.decile_impact import (
     DecileImpact,
     calculate_decile_impacts,
 )
 
+from .datasets import PolicyEngineUSDataset, USYearData
+from .model import us_latest
 from .outputs import ProgramStatistics
 
 
+class USHouseholdOutput(BaseModel):
+    """Output from a US household calculation with all entity data."""
+
+    person: list[dict[str, Any]]
+    marital_unit: list[dict[str, Any]]
+    family: list[dict[str, Any]]
+    spm_unit: list[dict[str, Any]]
+    tax_unit: list[dict[str, Any]]
+    household: dict[str, Any]
+
+
+class USHouseholdInput(BaseModel):
+    """Input for a US household calculation."""
+
+    people: list[dict[str, Any]]
+    marital_unit: dict[str, Any] = Field(default_factory=dict)
+    family: dict[str, Any] = Field(default_factory=dict)
+    spm_unit: dict[str, Any] = Field(default_factory=dict)
+    tax_unit: dict[str, Any] = Field(default_factory=dict)
+    household: dict[str, Any] = Field(default_factory=dict)
+    year: int = 2024
+
+
+def calculate_household_impact(
+    household_input: USHouseholdInput,
+    policy: Policy | None = None,
+) -> USHouseholdOutput:
+    """Calculate tax and benefit impacts for a single US household."""
+    n_people = len(household_input.people)
+
+    # Build person data with defaults
+    person_data = {
+        "person_id": list(range(n_people)),
+        "person_household_id": [0] * n_people,
+        "person_marital_unit_id": [0] * n_people,
+        "person_family_id": [0] * n_people,
+        "person_spm_unit_id": [0] * n_people,
+        "person_tax_unit_id": [0] * n_people,
+        "person_weight": [1.0] * n_people,
+    }
+    # Add user-provided person fields
+    for i, person in enumerate(household_input.people):
+        for key, value in person.items():
+            if key not in person_data:
+                person_data[key] = [
+                    0.0
+                ] * n_people  # Default to 0 for numeric fields
+            person_data[key][i] = value
+
+    # Build entity data with defaults
+    household_data = {
+        "household_id": [0],
+        "household_weight": [1.0],
+    }
+    for key, value in household_input.household.items():
+        household_data[key] = [value]
+
+    marital_unit_data = {
+        "marital_unit_id": [0],
+        "marital_unit_weight": [1.0],
+    }
+    for key, value in household_input.marital_unit.items():
+        marital_unit_data[key] = [value]
+
+    family_data = {
+        "family_id": [0],
+        "family_weight": [1.0],
+    }
+    for key, value in household_input.family.items():
+        family_data[key] = [value]
+
+    spm_unit_data = {
+        "spm_unit_id": [0],
+        "spm_unit_weight": [1.0],
+    }
+    for key, value in household_input.spm_unit.items():
+        spm_unit_data[key] = [value]
+
+    tax_unit_data = {
+        "tax_unit_id": [0],
+        "tax_unit_weight": [1.0],
+    }
+    for key, value in household_input.tax_unit.items():
+        tax_unit_data[key] = [value]
+
+    # Create MicroDataFrames
+    person_df = MicroDataFrame(
+        pd.DataFrame(person_data), weights="person_weight"
+    )
+    household_df = MicroDataFrame(
+        pd.DataFrame(household_data), weights="household_weight"
+    )
+    marital_unit_df = MicroDataFrame(
+        pd.DataFrame(marital_unit_data), weights="marital_unit_weight"
+    )
+    family_df = MicroDataFrame(
+        pd.DataFrame(family_data), weights="family_weight"
+    )
+    spm_unit_df = MicroDataFrame(
+        pd.DataFrame(spm_unit_data), weights="spm_unit_weight"
+    )
+    tax_unit_df = MicroDataFrame(
+        pd.DataFrame(tax_unit_data), weights="tax_unit_weight"
+    )
+
+    # Create temporary dataset
+    tmpdir = tempfile.mkdtemp()
+    filepath = str(Path(tmpdir) / "household_impact.h5")
+
+    dataset = PolicyEngineUSDataset(
+        name="Household impact calculation",
+        description="Single household for impact calculation",
+        filepath=filepath,
+        year=household_input.year,
+        data=USYearData(
+            person=person_df,
+            household=household_df,
+            marital_unit=marital_unit_df,
+            family=family_df,
+            spm_unit=spm_unit_df,
+            tax_unit=tax_unit_df,
+        ),
+    )
+
+    # Run simulation
+    simulation = Simulation(
+        dataset=dataset,
+        tax_benefit_model_version=us_latest,
+        policy=policy,
+    )
+    simulation.run()
+
+    # Extract all output variables defined in entity_variables
+    output_data = simulation.output_dataset.data
+
+    def safe_convert(value):
+        """Convert value to float if numeric, otherwise return as string."""
+        try:
+            return float(value)
+        except (ValueError, TypeError):
+            return str(value)
+
+    def extract_entity_outputs(
+        entity_name: str, entity_data, n_rows: int
+    ) -> list[dict[str, Any]]:
+        outputs = []
+        for i in range(n_rows):
+            row_dict = {}
+            for var in us_latest.entity_variables[entity_name]:
+                row_dict[var] = safe_convert(entity_data[var].iloc[i])
+            outputs.append(row_dict)
+        return outputs
+
+    return USHouseholdOutput(
+        person=extract_entity_outputs("person", output_data.person, n_people),
+        marital_unit=extract_entity_outputs(
+            "marital_unit", output_data.marital_unit, 1
+        ),
+        family=extract_entity_outputs("family", output_data.family, 1),
+        spm_unit=extract_entity_outputs("spm_unit", output_data.spm_unit, 1),
+        tax_unit=extract_entity_outputs("tax_unit", output_data.tax_unit, 1),
+        household={
+            var: safe_convert(output_data.household[var].iloc[0])
+            for var in us_latest.entity_variables["household"]
+        },
+    )
+
+
 class PolicyReformAnalysis(BaseModel):
     """Complete policy reform analysis result."""
 
@@ -19,7 +195,7 @@ class PolicyReformAnalysis(BaseModel):
     program_statistics: OutputCollection[ProgramStatistics]
 
 
-def general_policy_reform_analysis(
+def economic_impact_analysis(
     baseline_simulation: Simulation,
     reform_simulation: Simulation,
 ) -> PolicyReformAnalysis:
@@ -28,10 +204,23 @@ def general_policy_reform_analysis(
     Returns:
         PolicyReformAnalysis containing decile impacts and program statistics
     """
+    baseline_simulation.ensure()
+    reform_simulation.ensure()
+
+    assert len(baseline_simulation.dataset.data.household) > 100, (
+        "Baseline simulation must have more than 100 households"
+    )
+    assert len(reform_simulation.dataset.data.household) > 100, (
+        "Reform simulation must have more than 100 households"
+    )
+
     # Decile impact (using household_net_income for US)
     decile_impacts = calculate_decile_impacts(
-        baseline_simulation=baseline_simulation,
-        reform_simulation=reform_simulation,
+        dataset=baseline_simulation.dataset,
+        tax_benefit_model_version=baseline_simulation.tax_benefit_model_version,
+        baseline_policy=baseline_simulation.policy,
+        reform_policy=reform_simulation.policy,
+        dynamic=baseline_simulation.dynamic,
         income_variable="household_net_income",
     )
 

policyengine/tax_benefit_models/us/datasets.py

@@ -317,8 +317,8 @@ def load_datasets(
         for year in years:
             filepath = f"{data_folder}/{Path(dataset).stem}_year_{year}.h5"
             us_dataset = PolicyEngineUSDataset(
-                name=f"{dataset}-year-{year}",
-                description=f"US Dataset for year {year} based on {dataset}",
+                name=f"{Path(dataset).stem}-year-{year}",
+                description=f"US Dataset for year {year} based on {Path(dataset).stem}",
                 filepath=filepath,
                 year=year,
             )

policyengine/tax_benefit_models/us/model.py

@@ -9,12 +9,10 @@ from microdf import MicroDataFrame
 
 from policyengine.core import (
     Parameter,
-    ParameterValue,
     TaxBenefitModel,
     TaxBenefitModelVersion,
     Variable,
 )
-from policyengine.utils import parse_safe_date
 
 from .datasets import PolicyEngineUSDataset, USYearData
 
@@ -141,6 +139,7 @@ class PolicyEngineUSLatest(TaxBenefitModelVersion):
                 parameter = Parameter(
                     id=self.id + "-" + param_node.name,
                     name=param_node.name,
+                    label=param_node.metadata.get("label"),
                     tax_benefit_model_version=self,
                     description=param_node.description,
                     data_type=type(param_node(2025)),

{policyengine-3.1.13.dist-info → policyengine-3.1.15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: policyengine
-Version: 3.1.13
+Version: 3.1.15
 Summary: A package to conduct policy analysis using PolicyEngine tax-benefit models.
 Author-email: PolicyEngine <hello@policyengine.org>
 License:                     GNU AFFERO GENERAL PUBLIC LICENSE

{policyengine-3.1.13.dist-info → policyengine-3.1.15.dist-info}/RECORD

@@ -1,5 +1,5 @@
 policyengine/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-policyengine/__pycache__/__init__.cpython-313.pyc,sha256=uVHsGqNxZlQfIUi3c2mJIGYwZoh7v_hBZty19_E2l2g,175
+policyengine/__pycache__/__init__.cpython-313.pyc,sha256=MPybDS-iHQgTbwpR0cZQ_5__Xexio_9dqsdZDdfQBtQ,175
 policyengine/core/__init__.py,sha256=KBVhkqzkvjWLDDwk96vquQKL63ZFuLen5AzBOBnO9pg,912
 policyengine/core/cache.py,sha256=DcVVFaCt7k9PmqwlhXoNDMtJ8sF4neYP1uRqWik5QYg,1812
 policyengine/core/dataset.py,sha256=iJr9-J6w11uMRYy3EEJO9Gveku1m71AA1yzeo-0SiCs,16094
@@ -11,30 +11,30 @@ policyengine/core/parameter_value.py,sha256=ZRBZWFYtaY9TqdgjrCymzOZNmuKOBZsrWBET
 policyengine/core/policy.py,sha256=ExMrUDMvNk_uuOL0cSm0UCzDyGka0t_yk6x4U0Kp6Ww,1635
 policyengine/core/simulation.py,sha256=h6QbFt3uEvyfRXRVbSFBlrOd6Ze03OeZkwX9oElmO2M,1406
 policyengine/core/tax_benefit_model.py,sha256=2Yc1RlQrUG7djDMZbJOQH4Ns86_lOnLeISCGR4-9zMo,176
-policyengine/core/tax_benefit_model_version.py,sha256=csHeZasdvCyyRTlBIr1gtuJstye3pftQAsoI8mpRHa4,3012
+policyengine/core/tax_benefit_model_version.py,sha256=iVzEKWzQxoPVicwxcqo9Fy8PfVX07faBvyL9NhVIjuU,3212
 policyengine/core/variable.py,sha256=AjSImORlRkh05xhYxyeT6GFMOfViRzYg0qRQAIj-mxo,350
 policyengine/outputs/__init__.py,sha256=IJUmLP0Og41VrwiqhJF-a9-3fIb4nlXpS7uFuVCINIs,515
 policyengine/outputs/aggregate.py,sha256=exI-U04OF5kVf2BBYV6sf8VldIWnT_IzxgkBs5wtnCw,4846
 policyengine/outputs/change_aggregate.py,sha256=tK4K87YlByKikqFaB7OHyh1SqAuGtUnLL7cSF_EhrOs,7373
-policyengine/outputs/decile_impact.py,sha256=jclhbj5U-xX8D-myy0SuWeJFVfQTqJDCh7qBXugak5U,4811
+policyengine/outputs/decile_impact.py,sha256=f8nR3pea8_qDuQ-M6kaKnVKxbGnfL0IzpRfFTdi7TqA,5522
 policyengine/tax_benefit_models/uk.py,sha256=HzAG_dORmsj1NJ9pd9WrqwgZPe9DUDrZ1wV5LuVCKAg,950
 policyengine/tax_benefit_models/us.py,sha256=G51dAmHo8NJLb2mnbne6iO5eNaatCGUd_2unvawwF84,946
-policyengine/tax_benefit_models/uk/__init__.py,sha256=AiA74iED5FEryvUCMfVZi6pYDYuTfQcj9B01h8J5xFA,1105
-policyengine/tax_benefit_models/uk/analysis.py,sha256=O4eYJYF7tsgiuLuiWMU0OXq7ss6U8-vzlg6nC2U8sgU,3175
-policyengine/tax_benefit_models/uk/datasets.py,sha256=OtBGQPI-P2jnLfurw1MiFDo3LRi5xye0uI3XM9J-9rY,9021
-policyengine/tax_benefit_models/uk/model.py,sha256=7eqCNW9bjCM-6BN2Dp8soUAEjZBP_0QmMC2OtDPCiXw,8694
+policyengine/tax_benefit_models/uk/__init__.py,sha256=StjVt4mV0n2QxlM_2oCp_OqHJu7eyWNbdPndezC7ve0,1294
+policyengine/tax_benefit_models/uk/analysis.py,sha256=iw34SERGdjCO4GSnimOZwXRnzSV7nutoilkVxHaI5WM,8627
+policyengine/tax_benefit_models/uk/datasets.py,sha256=N8pMrlhQFec_cbgvVf5HE2owU14VF1i8-ZUwZYBSeio,9043
+policyengine/tax_benefit_models/uk/model.py,sha256=woVnq5-HRt3EzRqvHr9TFMhWD06CHxc1H0zlo_LqEJ4,8796
 policyengine/tax_benefit_models/uk/outputs.py,sha256=2mYLwQW4QNvrOHtHfm_ACqE9gbmuLxvcCyldRU46s0o,3543
-policyengine/tax_benefit_models/us/__init__.py,sha256=zP-UUQqOc9g0ymyHkweJdi4RVXQDKSR6SUxavUKvV0s,1101
-policyengine/tax_benefit_models/us/analysis.py,sha256=Xf-DT0QjVySs0QG_koCwgvOeWI_scLtv3S3SP8u8ZWc,3253
-policyengine/tax_benefit_models/us/datasets.py,sha256=Jfw8cYHBTjokiJJ1WBQtNcHEDd7BJuQ4A4wD6dN7Znk,14735
-policyengine/tax_benefit_models/us/model.py,sha256=eNlot8yMZkNwPiYfrWpDJkxRAwTBYLGWL-VC4Pss4JI,15579
+policyengine/tax_benefit_models/us/__init__.py,sha256=0RtqCl01j-Z_T4i9LITBSePegO97gZ4IIYqt-nsv2O0,1290
+policyengine/tax_benefit_models/us/analysis.py,sha256=y-M4QAUyp44-Y9fbkKQ6KMbS9qS9eHju3D5QG3iJHf8,9435
+policyengine/tax_benefit_models/us/datasets.py,sha256=OWqiYK8TWwdYP2qgUNIv6nIpqN5FVtyd8aYkVMUkAno,14757
+policyengine/tax_benefit_models/us/model.py,sha256=p5s8LHyGqkkVoJU1_7CGnwY8-KgXo_-3RSPuG9NO7Ww,15572
 policyengine/tax_benefit_models/us/outputs.py,sha256=GT8Eur8DfB9cPQRbSljEl9RpKSNHW80Fq_CBXCybvIU,3519
 policyengine/utils/__init__.py,sha256=1X-VYAWLyB9A0YRHwsGWrqQHns1WfeZ7ISC6DMU5myM,140
 policyengine/utils/dates.py,sha256=HnAqyl8S8EOYp8ibsnMTmECYoDWCSqwL-7A2_qKgxSc,1510
 policyengine/utils/parametric_reforms.py,sha256=4P3U39-4pYTU4BN6JjgmVLUkCkBhRfZJ6UIWTlsjyQE,1155
 policyengine/utils/plotting.py,sha256=ZAzTWz38vIaW0c3Nt4Un1kfrNoXLyHCDd1pEJIlsRg4,5335
-policyengine-3.1.13.dist-info/licenses/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
-policyengine-3.1.13.dist-info/METADATA,sha256=35l_TCb-BLgwO2Gbdpnl5up_-LMcqSowLieYrjTrjpw,45919
-policyengine-3.1.13.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-policyengine-3.1.13.dist-info/top_level.txt,sha256=_23UPobfkneHQkpJ0e0OmDJfhCUfoXj_F2sTckCGOH4,13
-policyengine-3.1.13.dist-info/RECORD,,
+policyengine-3.1.15.dist-info/licenses/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
+policyengine-3.1.15.dist-info/METADATA,sha256=FkFNAnnQvw5prYSAd-CZeNxAroQ7p1C7vF8Re1q2fwo,45919
+policyengine-3.1.15.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+policyengine-3.1.15.dist-info/top_level.txt,sha256=_23UPobfkneHQkpJ0e0OmDJfhCUfoXj_F2sTckCGOH4,13
+policyengine-3.1.15.dist-info/RECORD,,