policyengine 3.1.15__tar.gz → 3.1.16__tar.gz

{policyengine-3.1.15 → policyengine-3.1.16}/CHANGELOG.md

@@ -5,6 +5,12 @@ 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).
 
+## [3.1.16] - 2026-01-25 14:20:29
+
+### Changed
+
+- Bumped policyengine-core minimum version to 3.23.5 for pandas 3.0 compatibility
+
 ## [3.1.15] - 2025-12-14 23:51:27
 
 ### Added
@@ -287,6 +293,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 
 
+[3.1.16]: https://github.com/PolicyEngine/policyengine.py/compare/3.1.15...3.1.16
 [3.1.15]: https://github.com/PolicyEngine/policyengine.py/compare/3.1.14...3.1.15
 [3.1.14]: https://github.com/PolicyEngine/policyengine.py/compare/3.1.13...3.1.14
 [3.1.13]: https://github.com/PolicyEngine/policyengine.py/compare/3.1.12...3.1.13

{policyengine-3.1.15 → policyengine-3.1.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: policyengine
-Version: 3.1.15
+Version: 3.1.16
 Summary: A package to conduct policy analysis using PolicyEngine tax-benefit models.
 Author-email: PolicyEngine <hello@policyengine.org>
 License:                     GNU AFFERO GENERAL PUBLIC LICENSE
@@ -670,15 +670,15 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: pandas>=2.0.0
-Requires-Dist: microdf_python
+Requires-Dist: microdf_python>=1.2.1
 Requires-Dist: plotly>=5.0.0
 Requires-Dist: requests>=2.31.0
 Requires-Dist: psutil>=5.9.0
 Provides-Extra: uk
-Requires-Dist: policyengine_core>=3.10; extra == "uk"
+Requires-Dist: policyengine_core>=3.23.6; extra == "uk"
 Requires-Dist: policyengine-uk>=2.51.0; extra == "uk"
 Provides-Extra: us
-Requires-Dist: policyengine_core>=3.10; extra == "us"
+Requires-Dist: policyengine_core>=3.23.6; extra == "us"
 Requires-Dist: policyengine-us>=1.213.1; extra == "us"
 Provides-Extra: dev
 Requires-Dist: black; extra == "dev"
@@ -691,7 +691,7 @@ Requires-Dist: itables; extra == "dev"
 Requires-Dist: build; extra == "dev"
 Requires-Dist: pytest-asyncio>=0.26.0; extra == "dev"
 Requires-Dist: ruff>=0.5.0; extra == "dev"
-Requires-Dist: policyengine_core>=3.10; extra == "dev"
+Requires-Dist: policyengine_core>=3.23.6; extra == "dev"
 Requires-Dist: policyengine-uk>=2.51.0; extra == "dev"
 Requires-Dist: policyengine-us>=1.213.1; extra == "dev"
 Dynamic: license-file

{policyengine-3.1.15 → policyengine-3.1.16}/changelog.yaml

@@ -235,3 +235,8 @@
     added:
     - Household impacts
   date: 2025-12-14 23:51:27
+- bump: patch
+  changes:
+    changed:
+    - Bumped policyengine-core minimum version to 3.23.5 for pandas 3.0 compatibility
+  date: 2026-01-25 14:20:29

{policyengine-3.1.15 → policyengine-3.1.16}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "policyengine"
-version = "3.1.15"
+version = "3.1.16"
 description = "A package to conduct policy analysis using PolicyEngine tax-benefit models."
 readme = "README.md"
 authors = [
@@ -15,7 +15,7 @@ requires-python = ">=3.13"
 dependencies = [
     "pydantic>=2.0.0",
     "pandas>=2.0.0",
-    "microdf_python",
+    "microdf_python>=1.2.1",
     "plotly>=5.0.0",
     "requests>=2.31.0",
     "psutil>=5.9.0",
@@ -23,11 +23,11 @@ dependencies = [
 
 [project.optional-dependencies]
 uk = [
-    "policyengine_core>=3.10",
+    "policyengine_core>=3.23.6",
     "policyengine-uk>=2.51.0",
 ]
 us = [
-    "policyengine_core>=3.10",
+    "policyengine_core>=3.23.6",
     "policyengine-us>=1.213.1",
 ]
 dev = [
@@ -41,7 +41,7 @@ dev = [
     "build",
     "pytest-asyncio>=0.26.0",
     "ruff>=0.5.0",
-    "policyengine_core>=3.10",
+    "policyengine_core>=3.23.6",
     "policyengine-uk>=2.51.0",
     "policyengine-us>=1.213.1",
 ]

policyengine-3.1.16/src/policyengine/outputs/__init__.py

@@ -0,0 +1,49 @@
+from policyengine.core import Output, OutputCollection
+from policyengine.outputs.aggregate import Aggregate, AggregateType
+from policyengine.outputs.change_aggregate import (
+    ChangeAggregate,
+    ChangeAggregateType,
+)
+from policyengine.outputs.decile_impact import (
+    DecileImpact,
+    calculate_decile_impacts,
+)
+from policyengine.outputs.inequality import (
+    UK_INEQUALITY_INCOME_VARIABLE,
+    US_INEQUALITY_INCOME_VARIABLE,
+    Inequality,
+    calculate_uk_inequality,
+    calculate_us_inequality,
+)
+from policyengine.outputs.poverty import (
+    UK_POVERTY_VARIABLES,
+    US_POVERTY_VARIABLES,
+    Poverty,
+    UKPovertyType,
+    USPovertyType,
+    calculate_uk_poverty_rates,
+    calculate_us_poverty_rates,
+)
+
+__all__ = [
+    "Output",
+    "OutputCollection",
+    "Aggregate",
+    "AggregateType",
+    "ChangeAggregate",
+    "ChangeAggregateType",
+    "DecileImpact",
+    "calculate_decile_impacts",
+    "Poverty",
+    "UKPovertyType",
+    "USPovertyType",
+    "UK_POVERTY_VARIABLES",
+    "US_POVERTY_VARIABLES",
+    "calculate_uk_poverty_rates",
+    "calculate_us_poverty_rates",
+    "Inequality",
+    "UK_INEQUALITY_INCOME_VARIABLE",
+    "US_INEQUALITY_INCOME_VARIABLE",
+    "calculate_uk_inequality",
+    "calculate_us_inequality",
+]

policyengine-3.1.16/src/policyengine/outputs/inequality.py

@@ -0,0 +1,276 @@
+"""Inequality analysis output types."""
+
+from typing import Any
+
+import numpy as np
+import pandas as pd
+from pydantic import ConfigDict
+
+from policyengine.core import Output, Simulation
+
+
+def _gini(values: np.ndarray, weights: np.ndarray) -> float:
+    """Calculate weighted Gini coefficient.
+
+    Args:
+        values: Array of income values
+        weights: Array of weights
+
+    Returns:
+        Gini coefficient between 0 (perfect equality) and 1 (perfect inequality)
+    """
+    # Handle edge cases
+    if len(values) == 0 or weights.sum() == 0:
+        return 0.0
+
+    # Sort by values
+    sorted_indices = np.argsort(values)
+    sorted_values = values[sorted_indices]
+    sorted_weights = weights[sorted_indices]
+
+    # Cumulative weights and weighted values
+    cumulative_weights = np.cumsum(sorted_weights)
+    total_weight = cumulative_weights[-1]
+    cumulative_weighted_values = np.cumsum(sorted_values * sorted_weights)
+    total_weighted_value = cumulative_weighted_values[-1]
+
+    if total_weighted_value == 0:
+        return 0.0
+
+    # Calculate Gini using the area formula
+    # Gini = 1 - 2 * (area under Lorenz curve)
+    lorenz_curve = cumulative_weighted_values / total_weighted_value
+    weight_fractions = sorted_weights / total_weight
+
+    # Area under Lorenz curve using trapezoidal rule
+    area = np.sum(weight_fractions * (lorenz_curve - weight_fractions / 2))
+
+    return float(1 - 2 * area)
+
+
+class Inequality(Output):
+    """Single inequality measure result - represents one database row.
+
+    This is a single-simulation output type that calculates inequality
+    metrics for a given income variable, optionally filtered by
+    demographic variables.
+    """
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    simulation: Simulation
+    income_variable: str
+    entity: str = "household"
+
+    # Optional demographic filters
+    filter_variable: str | None = None
+    filter_variable_eq: Any | None = None
+    filter_variable_leq: Any | None = None
+    filter_variable_geq: Any | None = None
+
+    # Results populated by run()
+    gini: float | None = None
+    top_10_share: float | None = None
+    top_1_share: float | None = None
+    bottom_50_share: float | None = None
+
+    def run(self):
+        """Calculate inequality metrics."""
+        # Get income variable info
+        income_var_obj = (
+            self.simulation.tax_benefit_model_version.get_variable(
+                self.income_variable
+            )
+        )
+
+        # Get target entity data
+        target_entity = self.entity
+        data = getattr(self.simulation.output_dataset.data, target_entity)
+
+        # Map income variable to target entity if needed
+        if income_var_obj.entity != target_entity:
+            mapped = self.simulation.output_dataset.data.map_to_entity(
+                income_var_obj.entity,
+                target_entity,
+                columns=[self.income_variable],
+            )
+            income_series = mapped[self.income_variable]
+        else:
+            income_series = data[self.income_variable]
+
+        # Get weights
+        weight_col = f"{target_entity}_weight"
+        if weight_col in data.columns:
+            weights = data[weight_col]
+        else:
+            weights = pd.Series(np.ones(len(income_series)))
+
+        # Apply demographic filter if specified
+        if self.filter_variable is not None:
+            filter_var_obj = (
+                self.simulation.tax_benefit_model_version.get_variable(
+                    self.filter_variable
+                )
+            )
+
+            if filter_var_obj.entity != target_entity:
+                filter_mapped = (
+                    self.simulation.output_dataset.data.map_to_entity(
+                        filter_var_obj.entity,
+                        target_entity,
+                        columns=[self.filter_variable],
+                    )
+                )
+                filter_series = filter_mapped[self.filter_variable]
+            else:
+                filter_series = data[self.filter_variable]
+
+            # Build filter mask
+            mask = filter_series.notna()
+            if self.filter_variable_eq is not None:
+                mask &= filter_series == self.filter_variable_eq
+            if self.filter_variable_leq is not None:
+                mask &= filter_series <= self.filter_variable_leq
+            if self.filter_variable_geq is not None:
+                mask &= filter_series >= self.filter_variable_geq
+
+            # Apply mask
+            income_series = income_series[mask]
+            weights = weights[mask]
+
+        # Convert to numpy arrays
+        values = np.array(income_series)
+        weights_arr = np.array(weights)
+
+        # Remove NaN values
+        valid_mask = ~np.isnan(values) & ~np.isnan(weights_arr)
+        values = values[valid_mask]
+        weights_arr = weights_arr[valid_mask]
+
+        # Calculate Gini coefficient
+        self.gini = _gini(values, weights_arr)
+
+        # Calculate income shares
+        if len(values) > 0 and weights_arr.sum() > 0:
+            total_income = np.sum(values * weights_arr)
+
+            if total_income > 0:
+                # Sort by income
+                sorted_indices = np.argsort(values)
+                sorted_values = values[sorted_indices]
+                sorted_weights = weights_arr[sorted_indices]
+
+                # Cumulative weight fractions
+                cumulative_weights = np.cumsum(sorted_weights)
+                total_weight = cumulative_weights[-1]
+                weight_fractions = cumulative_weights / total_weight
+
+                # Top 10% share
+                top_10_mask = weight_fractions > 0.9
+                self.top_10_share = float(
+                    np.sum(
+                        sorted_values[top_10_mask]
+                        * sorted_weights[top_10_mask]
+                    )
+                    / total_income
+                )
+
+                # Top 1% share
+                top_1_mask = weight_fractions > 0.99
+                self.top_1_share = float(
+                    np.sum(
+                        sorted_values[top_1_mask] * sorted_weights[top_1_mask]
+                    )
+                    / total_income
+                )
+
+                # Bottom 50% share
+                bottom_50_mask = weight_fractions <= 0.5
+                self.bottom_50_share = float(
+                    np.sum(
+                        sorted_values[bottom_50_mask]
+                        * sorted_weights[bottom_50_mask]
+                    )
+                    / total_income
+                )
+            else:
+                self.top_10_share = 0.0
+                self.top_1_share = 0.0
+                self.bottom_50_share = 0.0
+        else:
+            self.top_10_share = 0.0
+            self.top_1_share = 0.0
+            self.bottom_50_share = 0.0
+
+
+# Default income variables for each country
+UK_INEQUALITY_INCOME_VARIABLE = "equiv_hbai_household_net_income"
+US_INEQUALITY_INCOME_VARIABLE = "household_net_income"
+
+
+def calculate_uk_inequality(
+    simulation: Simulation,
+    income_variable: str = UK_INEQUALITY_INCOME_VARIABLE,
+    filter_variable: str | None = None,
+    filter_variable_eq: Any | None = None,
+    filter_variable_leq: Any | None = None,
+    filter_variable_geq: Any | None = None,
+) -> Inequality:
+    """Calculate inequality metrics for a UK simulation.
+
+    Args:
+        simulation: The simulation to analyse
+        income_variable: Income variable to use (default: equiv_hbai_household_net_income)
+        filter_variable: Optional variable to filter by
+        filter_variable_eq: Filter for exact match
+        filter_variable_leq: Filter for less than or equal
+        filter_variable_geq: Filter for greater than or equal
+
+    Returns:
+        Inequality object with Gini and income share metrics
+    """
+    inequality = Inequality(
+        simulation=simulation,
+        income_variable=income_variable,
+        entity="household",
+        filter_variable=filter_variable,
+        filter_variable_eq=filter_variable_eq,
+        filter_variable_leq=filter_variable_leq,
+        filter_variable_geq=filter_variable_geq,
+    )
+    inequality.run()
+    return inequality
+
+
+def calculate_us_inequality(
+    simulation: Simulation,
+    income_variable: str = US_INEQUALITY_INCOME_VARIABLE,
+    filter_variable: str | None = None,
+    filter_variable_eq: Any | None = None,
+    filter_variable_leq: Any | None = None,
+    filter_variable_geq: Any | None = None,
+) -> Inequality:
+    """Calculate inequality metrics for a US simulation.
+
+    Args:
+        simulation: The simulation to analyse
+        income_variable: Income variable to use (default: household_net_income)
+        filter_variable: Optional variable to filter by
+        filter_variable_eq: Filter for exact match
+        filter_variable_leq: Filter for less than or equal
+        filter_variable_geq: Filter for greater than or equal
+
+    Returns:
+        Inequality object with Gini and income share metrics
+    """
+    inequality = Inequality(
+        simulation=simulation,
+        income_variable=income_variable,
+        entity="household",
+        filter_variable=filter_variable,
+        filter_variable_eq=filter_variable_eq,
+        filter_variable_leq=filter_variable_leq,
+        filter_variable_geq=filter_variable_geq,
+    )
+    inequality.run()
+    return inequality

policyengine-3.1.16/src/policyengine/outputs/poverty.py

@@ -0,0 +1,238 @@
+"""Poverty analysis output types."""
+
+from enum import Enum
+from typing import Any
+
+import pandas as pd
+from pydantic import ConfigDict
+
+from policyengine.core import Output, OutputCollection, Simulation
+
+
+class UKPovertyType(str, Enum):
+    """UK poverty measure types."""
+
+    ABSOLUTE_BHC = "absolute_bhc"
+    ABSOLUTE_AHC = "absolute_ahc"
+    RELATIVE_BHC = "relative_bhc"
+    RELATIVE_AHC = "relative_ahc"
+
+
+class USPovertyType(str, Enum):
+    """US poverty measure types."""
+
+    SPM = "spm"
+    SPM_DEEP = "spm_deep"
+
+
+# Mapping from poverty type to variable name
+UK_POVERTY_VARIABLES = {
+    UKPovertyType.ABSOLUTE_BHC: "in_poverty_bhc",
+    UKPovertyType.ABSOLUTE_AHC: "in_poverty_ahc",
+    UKPovertyType.RELATIVE_BHC: "in_relative_poverty_bhc",
+    UKPovertyType.RELATIVE_AHC: "in_relative_poverty_ahc",
+}
+
+US_POVERTY_VARIABLES = {
+    USPovertyType.SPM: "spm_unit_is_in_spm_poverty",
+    USPovertyType.SPM_DEEP: "spm_unit_is_in_deep_spm_poverty",
+}
+
+
+class Poverty(Output):
+    """Single poverty measure result - represents one database row.
+
+    This is a single-simulation output type that calculates poverty
+    headcount and rate for a given poverty measure, optionally filtered
+    by demographic variables.
+    """
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    simulation: Simulation
+    poverty_variable: str
+    entity: str = "person"
+
+    # Optional demographic filters
+    filter_variable: str | None = None
+    filter_variable_eq: Any | None = None
+    filter_variable_leq: Any | None = None
+    filter_variable_geq: Any | None = None
+
+    # Results populated by run()
+    headcount: float | None = None
+    total_population: float | None = None
+    rate: float | None = None
+
+    def run(self):
+        """Calculate poverty headcount and rate."""
+        # Get poverty variable info
+        poverty_var_obj = (
+            self.simulation.tax_benefit_model_version.get_variable(
+                self.poverty_variable
+            )
+        )
+
+        # Get target entity data
+        target_entity = self.entity
+        data = getattr(self.simulation.output_dataset.data, target_entity)
+
+        # Map poverty variable to target entity if needed
+        if poverty_var_obj.entity != target_entity:
+            mapped = self.simulation.output_dataset.data.map_to_entity(
+                poverty_var_obj.entity,
+                target_entity,
+                columns=[self.poverty_variable],
+            )
+            poverty_series = mapped[self.poverty_variable]
+        else:
+            poverty_series = data[self.poverty_variable]
+
+        # Apply demographic filter if specified
+        if self.filter_variable is not None:
+            filter_var_obj = (
+                self.simulation.tax_benefit_model_version.get_variable(
+                    self.filter_variable
+                )
+            )
+
+            if filter_var_obj.entity != target_entity:
+                filter_mapped = (
+                    self.simulation.output_dataset.data.map_to_entity(
+                        filter_var_obj.entity,
+                        target_entity,
+                        columns=[self.filter_variable],
+                    )
+                )
+                filter_series = filter_mapped[self.filter_variable]
+            else:
+                filter_series = data[self.filter_variable]
+
+            # Build filter mask
+            mask = filter_series.notna()
+            if self.filter_variable_eq is not None:
+                mask &= filter_series == self.filter_variable_eq
+            if self.filter_variable_leq is not None:
+                mask &= filter_series <= self.filter_variable_leq
+            if self.filter_variable_geq is not None:
+                mask &= filter_series >= self.filter_variable_geq
+
+            # Apply mask
+            poverty_series = poverty_series[mask]
+
+        # Calculate results using weighted counts
+        self.headcount = float((poverty_series == True).sum())  # noqa: E712
+        self.total_population = float(poverty_series.count())
+        self.rate = (
+            self.headcount / self.total_population
+            if self.total_population > 0
+            else 0.0
+        )
+
+
+def calculate_uk_poverty_rates(
+    simulation: Simulation,
+    filter_variable: str | None = None,
+    filter_variable_eq: Any | None = None,
+    filter_variable_leq: Any | None = None,
+    filter_variable_geq: Any | None = None,
+) -> OutputCollection[Poverty]:
+    """Calculate all UK poverty rates for a simulation.
+
+    Args:
+        simulation: The simulation to analyse
+        filter_variable: Optional variable to filter by (e.g., "is_child")
+        filter_variable_eq: Filter for exact match
+        filter_variable_leq: Filter for less than or equal
+        filter_variable_geq: Filter for greater than or equal
+
+    Returns:
+        OutputCollection containing Poverty objects for each UK poverty type
+    """
+    results = []
+
+    for poverty_variable in UK_POVERTY_VARIABLES.values():
+        poverty = Poverty(
+            simulation=simulation,
+            poverty_variable=poverty_variable,
+            entity="person",
+            filter_variable=filter_variable,
+            filter_variable_eq=filter_variable_eq,
+            filter_variable_leq=filter_variable_leq,
+            filter_variable_geq=filter_variable_geq,
+        )
+        poverty.run()
+        results.append(poverty)
+
+    df = pd.DataFrame(
+        [
+            {
+                "simulation_id": r.simulation.id,
+                "poverty_variable": r.poverty_variable,
+                "filter_variable": r.filter_variable,
+                "filter_variable_eq": r.filter_variable_eq,
+                "filter_variable_leq": r.filter_variable_leq,
+                "filter_variable_geq": r.filter_variable_geq,
+                "headcount": r.headcount,
+                "total_population": r.total_population,
+                "rate": r.rate,
+            }
+            for r in results
+        ]
+    )
+
+    return OutputCollection(outputs=results, dataframe=df)
+
+
+def calculate_us_poverty_rates(
+    simulation: Simulation,
+    filter_variable: str | None = None,
+    filter_variable_eq: Any | None = None,
+    filter_variable_leq: Any | None = None,
+    filter_variable_geq: Any | None = None,
+) -> OutputCollection[Poverty]:
+    """Calculate all US poverty rates for a simulation.
+
+    Args:
+        simulation: The simulation to analyse
+        filter_variable: Optional variable to filter by (e.g., "is_child")
+        filter_variable_eq: Filter for exact match
+        filter_variable_leq: Filter for less than or equal
+        filter_variable_geq: Filter for greater than or equal
+
+    Returns:
+        OutputCollection containing Poverty objects for each US poverty type
+    """
+    results = []
+
+    for poverty_variable in US_POVERTY_VARIABLES.values():
+        poverty = Poverty(
+            simulation=simulation,
+            poverty_variable=poverty_variable,
+            entity="person",
+            filter_variable=filter_variable,
+            filter_variable_eq=filter_variable_eq,
+            filter_variable_leq=filter_variable_leq,
+            filter_variable_geq=filter_variable_geq,
+        )
+        poverty.run()
+        results.append(poverty)
+
+    df = pd.DataFrame(
+        [
+            {
+                "simulation_id": r.simulation.id,
+                "poverty_variable": r.poverty_variable,
+                "filter_variable": r.filter_variable,
+                "filter_variable_eq": r.filter_variable_eq,
+                "filter_variable_leq": r.filter_variable_leq,
+                "filter_variable_geq": r.filter_variable_geq,
+                "headcount": r.headcount,
+                "total_population": r.total_population,
+                "rate": r.rate,
+            }
+            for r in results
+        ]
+    )
+
+    return OutputCollection(outputs=results, dataframe=df)