policyengine 3.1.7__tar.gz → 3.1.9__tar.gz

{policyengine-3.1.7 → policyengine-3.1.9}/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).
 
+## [3.1.9] - 2025-12-02 12:48:37
+
+### Fixed
+
+- Added caching of saved simulations
+
+## [3.1.8] - 2025-12-02 00:20:11
+
+### Fixed
+
+- Dataset speedup with better handling of string cols.
+
 ## [3.1.7] - 2025-11-24 16:34:53
 
 ### Fixed
@@ -239,6 +251,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 
 
+[3.1.9]: https://github.com/PolicyEngine/policyengine.py/compare/3.1.8...3.1.9
+[3.1.8]: https://github.com/PolicyEngine/policyengine.py/compare/3.1.7...3.1.8
 [3.1.7]: https://github.com/PolicyEngine/policyengine.py/compare/3.1.6...3.1.7
 [3.1.6]: https://github.com/PolicyEngine/policyengine.py/compare/3.1.5...3.1.6
 [3.1.5]: https://github.com/PolicyEngine/policyengine.py/compare/3.1.4...3.1.5

{policyengine-3.1.7 → policyengine-3.1.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: policyengine
-Version: 3.1.7
+Version: 3.1.9
 Summary: A package to conduct policy analysis using PolicyEngine tax-benefit models.
 Author-email: PolicyEngine <hello@policyengine.org>
 License:                     GNU AFFERO GENERAL PUBLIC LICENSE
@@ -673,6 +673,7 @@ Requires-Dist: pandas>=2.0.0
 Requires-Dist: microdf_python
 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-uk>=2.51.0; extra == "uk"

{policyengine-3.1.7 → policyengine-3.1.9}/changelog.yaml

@@ -195,3 +195,13 @@
     fixed:
     - Build error
   date: 2025-11-24 16:34:53
+- bump: patch
+  changes:
+    fixed:
+    - Dataset speedup with better handling of string cols.
+  date: 2025-12-02 00:20:11
+- bump: patch
+  changes:
+    fixed:
+    - Added caching of saved simulations
+  date: 2025-12-02 12:48:37

{policyengine-3.1.7 → policyengine-3.1.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "policyengine"
-version = "3.1.7"
+version = "3.1.9"
 description = "A package to conduct policy analysis using PolicyEngine tax-benefit models."
 readme = "README.md"
 authors = [
@@ -18,6 +18,7 @@ dependencies = [
     "microdf_python",
     "plotly>=5.0.0",
     "requests>=2.31.0",
+    "psutil>=5.9.0",
 ]
 
 [project.optional-dependencies]

policyengine-3.1.9/src/policyengine/core/cache.py

@@ -0,0 +1,56 @@
+import logging
+from collections import OrderedDict
+
+import psutil
+
+logger = logging.getLogger(__name__)
+
+_MEMORY_THRESHOLDS_GB = [8, 16, 32]
+_warned_thresholds: set[int] = set()
+
+
+class LRUCache[T]:
+    """Least-recently-used cache with configurable size limit and memory monitoring."""
+
+    def __init__(self, max_size: int = 100):
+        self._max_size = max_size
+        self._cache: OrderedDict[str, T] = OrderedDict()
+
+    def get(self, key: str) -> T | None:
+        """Get item from cache, marking it as recently used."""
+        if key not in self._cache:
+            return None
+        self._cache.move_to_end(key)
+        return self._cache[key]
+
+    def add(self, key: str, value: T) -> None:
+        """Add item to cache with LRU eviction when full."""
+        if key in self._cache:
+            self._cache.move_to_end(key)
+        else:
+            self._cache[key] = value
+            if len(self._cache) > self._max_size:
+                self._cache.popitem(last=False)
+
+        self._check_memory_usage()
+
+    def clear(self) -> None:
+        """Clear all items from cache."""
+        self._cache.clear()
+        _warned_thresholds.clear()
+
+    def __len__(self) -> int:
+        return len(self._cache)
+
+    def _check_memory_usage(self) -> None:
+        """Check memory usage and warn at threshold crossings."""
+        process = psutil.Process()
+        memory_gb = process.memory_info().rss / (1024**3)
+
+        for threshold in _MEMORY_THRESHOLDS_GB:
+            if memory_gb >= threshold and threshold not in _warned_thresholds:
+                logger.warning(
+                    f"Memory usage has reached {memory_gb:.2f}GB (threshold: {threshold}GB). "
+                    f"Cache contains {len(self._cache)} items."
+                )
+                _warned_thresholds.add(threshold)

{policyengine-3.1.7 → policyengine-3.1.9}/src/policyengine/core/simulation.py

@@ -3,11 +3,14 @@ from uuid import uuid4
 
 from pydantic import BaseModel, Field
 
+from .cache import LRUCache
 from .dataset import Dataset
 from .dynamic import Dynamic
 from .policy import Policy
 from .tax_benefit_model_version import TaxBenefitModelVersion
 
+_cache: LRUCache["Simulation"] = LRUCache(max_size=100)
+
 
 class Simulation(BaseModel):
     id: str = Field(default_factory=lambda: str(uuid4()))
@@ -25,12 +28,17 @@ class Simulation(BaseModel):
         self.tax_benefit_model_version.run(self)
 
     def ensure(self):
+        cached_result = _cache.get(self.id)
+        if cached_result:
+            return cached_result
         try:
             self.tax_benefit_model_version.load(self)
         except Exception:
             self.run()
             self.save()
 
+        _cache.add(self.id, self)
+
     def save(self):
         """Save the simulation's output dataset."""
         self.tax_benefit_model_version.save(self)

{policyengine-3.1.7 → policyengine-3.1.9}/src/policyengine/tax_benefit_models/uk/datasets.py

@@ -40,14 +40,37 @@ class PolicyEngineUKDataset(Dataset):
             self.load()
 
     def save(self) -> None:
-        """Save dataset to HDF5 file."""
+        """Save dataset to HDF5 file.
+
+        Converts object columns to categorical dtype to avoid slow pickle serialization.
+        """
         filepath = Path(self.filepath)
         if not filepath.parent.exists():
             filepath.parent.mkdir(parents=True, exist_ok=True)
+
+        # Convert DataFrames and optimize object columns to categorical
+        person_df = pd.DataFrame(self.data.person)
+        benunit_df = pd.DataFrame(self.data.benunit)
+        household_df = pd.DataFrame(self.data.household)
+
+        # Convert object columns to categorical to avoid pickle serialization
+        for col in person_df.columns:
+            if person_df[col].dtype == "object":
+                person_df[col] = person_df[col].astype("category")
+
+        for col in benunit_df.columns:
+            if benunit_df[col].dtype == "object":
+                benunit_df[col] = benunit_df[col].astype("category")
+
+        for col in household_df.columns:
+            if household_df[col].dtype == "object":
+                household_df[col] = household_df[col].astype("category")
+
         with pd.HDFStore(filepath, mode="w") as store:
-            store["person"] = pd.DataFrame(self.data.person)
-            store["benunit"] = pd.DataFrame(self.data.benunit)
-            store["household"] = pd.DataFrame(self.data.household)
+            # Use format='table' to support categorical dtypes
+            store.put("person", person_df, format="table")
+            store.put("benunit", benunit_df, format="table")
+            store.put("household", household_df, format="table")
 
     def load(self) -> None:
         """Load dataset from HDF5 file into this instance."""

{policyengine-3.1.7 → policyengine-3.1.9}/src/policyengine.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: policyengine
-Version: 3.1.7
+Version: 3.1.9
 Summary: A package to conduct policy analysis using PolicyEngine tax-benefit models.
 Author-email: PolicyEngine <hello@policyengine.org>
 License:                     GNU AFFERO GENERAL PUBLIC LICENSE
@@ -673,6 +673,7 @@ Requires-Dist: pandas>=2.0.0
 Requires-Dist: microdf_python
 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-uk>=2.51.0; extra == "uk"

{policyengine-3.1.7 → policyengine-3.1.9}/src/policyengine.egg-info/SOURCES.txt

@@ -44,6 +44,7 @@ src/policyengine.egg-info/requires.txt
 src/policyengine.egg-info/top_level.txt
 src/policyengine/__pycache__/__init__.cpython-313.pyc
 src/policyengine/core/__init__.py
+src/policyengine/core/cache.py
 src/policyengine/core/dataset.py
 src/policyengine/core/dataset_version.py
 src/policyengine/core/dynamic.py
@@ -76,10 +77,6 @@ src/policyengine/utils/dates.py
 src/policyengine/utils/parametric_reforms.py
 src/policyengine/utils/plotting.py
 tests/test_aggregate.py
+tests/test_cache.py
 tests/test_change_aggregate.py
-tests/test_entity_mapping.py
-tests/test_get_parameter_variable.py
-tests/test_uk_dataset.py
-tests/test_us_datasets.py
-tests/test_us_entity_mapping.py
-tests/test_us_simulation.py
+tests/test_entity_mapping.py

{policyengine-3.1.7 → policyengine-3.1.9}/src/policyengine.egg-info/requires.txt

@@ -3,6 +3,7 @@ pandas>=2.0.0
 microdf_python
 plotly>=5.0.0
 requests>=2.31.0
+psutil>=5.9.0
 
 [dev]
 black

policyengine-3.1.9/tests/test_cache.py

@@ -0,0 +1,145 @@
+import os
+import tempfile
+
+import pandas as pd
+from microdf import MicroDataFrame
+
+from policyengine.core import Simulation
+from policyengine.core.cache import LRUCache
+from policyengine.tax_benefit_models.uk import (
+    PolicyEngineUKDataset,
+    UKYearData,
+    uk_latest,
+)
+
+
+def test_simulation_cache_hit():
+    """Test that simulation caching works with UK simulations."""
+    person_df = MicroDataFrame(
+        pd.DataFrame(
+            {
+                "person_id": [1, 2, 3],
+                "benunit_id": [1, 1, 2],
+                "household_id": [1, 1, 2],
+                "age": [30, 25, 40],
+                "employment_income": [50000, 30000, 60000],
+                "person_weight": [1.0, 1.0, 1.0],
+            }
+        ),
+        weights="person_weight",
+    )
+
+    benunit_df = MicroDataFrame(
+        pd.DataFrame(
+            {
+                "benunit_id": [1, 2],
+                "benunit_weight": [1.0, 1.0],
+            }
+        ),
+        weights="benunit_weight",
+    )
+
+    household_df = MicroDataFrame(
+        pd.DataFrame(
+            {
+                "household_id": [1, 2],
+                "household_weight": [1.0, 1.0],
+            }
+        ),
+        weights="household_weight",
+    )
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        filepath = os.path.join(tmpdir, "test.h5")
+
+        dataset = PolicyEngineUKDataset(
+            name="Test",
+            description="Test dataset",
+            filepath=filepath,
+            year=2024,
+            data=UKYearData(
+                person=person_df, benunit=benunit_df, household=household_df
+            ),
+        )
+
+        simulation = Simulation(
+            dataset=dataset,
+            tax_benefit_model_version=uk_latest,
+            output_dataset=dataset,
+        )
+
+        # Import the cache
+        from policyengine.core.simulation import _cache
+
+        # Manually add to cache (simulating what ensure() does)
+        _cache.add(simulation.id, simulation)
+
+        # Verify simulation is in cache
+        assert simulation.id in _cache._cache
+        assert len(_cache) >= 1
+
+        # Verify cache returns same object
+        cached_sim = _cache.get(simulation.id)
+        assert cached_sim is simulation
+
+        # Clear cache for other tests
+        _cache.clear()
+
+
+def test_lru_cache_eviction():
+    """Test that LRU cache properly evicts old items."""
+    cache = LRUCache[str](max_size=3)
+
+    cache.add("a", "value_a")
+    cache.add("b", "value_b")
+    cache.add("c", "value_c")
+
+    assert len(cache) == 3
+    assert cache.get("a") == "value_a"
+
+    # Add fourth item, should evict 'b' (least recently used)
+    cache.add("d", "value_d")
+
+    assert len(cache) == 3
+    assert cache.get("b") is None
+    assert cache.get("a") == "value_a"
+    assert cache.get("c") == "value_c"
+    assert cache.get("d") == "value_d"
+
+
+def test_lru_cache_access_updates_order():
+    """Test that accessing items updates their position in LRU order."""
+    cache = LRUCache[str](max_size=3)
+
+    cache.add("a", "value_a")
+    cache.add("b", "value_b")
+    cache.add("c", "value_c")
+
+    # Access 'a' to move it to most recently used
+    cache.get("a")
+
+    # Add fourth item, should evict 'b' (now least recently used)
+    cache.add("d", "value_d")
+
+    assert cache.get("a") == "value_a"
+    assert cache.get("b") is None
+    assert cache.get("c") == "value_c"
+    assert cache.get("d") == "value_d"
+
+
+def test_lru_cache_clear():
+    """Test that clearing cache works properly."""
+    cache = LRUCache[str](max_size=10)
+
+    cache.add("a", "value_a")
+    cache.add("b", "value_b")
+    cache.add("c", "value_c")
+
+    assert len(cache) == 3
+
+    cache.clear()
+
+    assert len(cache) == 0
+    assert cache.get("a") is None
+    assert cache.get("b") is None
+    assert cache.get("c") is None

{policyengine-3.1.7 → policyengine-3.1.9}/uv.lock

@@ -1080,7 +1080,7 @@ wheels = [
 
 [[package]]
 name = "policyengine"
-version = "3.0.0"
+version = "3.1.7"
 source = { editable = "." }
 dependencies = [
     { name = "microdf-python" },

policyengine-3.1.7/tests/test_get_parameter_variable.py

@@ -1,141 +0,0 @@
-"""Tests for get_parameter and get_variable methods on TaxBenefitModelVersion."""
-
-import pytest
-
-from policyengine.tax_benefit_models.uk import uk_latest
-from policyengine.tax_benefit_models.us import us_latest
-
-
-def test_uk_get_variable():
-    """Test getting a variable by name from UK model."""
-    # Get a known variable
-    var = uk_latest.get_variable("income_tax")
-
-    assert var is not None
-    assert var.name == "income_tax"
-    assert var.entity == "person"
-    assert var.tax_benefit_model_version == uk_latest
-
-
-def test_uk_get_variable_not_found():
-    """Test error handling when variable doesn't exist."""
-    with pytest.raises(
-        ValueError, match="Variable 'nonexistent_variable' not found"
-    ):
-        uk_latest.get_variable("nonexistent_variable")
-
-
-def test_uk_get_parameter():
-    """Test getting a parameter by name from UK model."""
-    # Get a known parameter
-    param = uk_latest.get_parameter(
-        "gov.hmrc.income_tax.allowances.personal_allowance.amount"
-    )
-
-    assert param is not None
-    assert (
-        param.name
-        == "gov.hmrc.income_tax.allowances.personal_allowance.amount"
-    )
-    assert param.tax_benefit_model_version == uk_latest
-
-
-def test_uk_get_parameter_not_found():
-    """Test error handling when parameter doesn't exist."""
-    with pytest.raises(
-        ValueError, match="Parameter 'nonexistent.parameter' not found"
-    ):
-        uk_latest.get_parameter("nonexistent.parameter")
-
-
-def test_us_get_variable():
-    """Test getting a variable by name from US model."""
-    # Get a known variable
-    var = us_latest.get_variable("income_tax")
-
-    assert var is not None
-    assert var.name == "income_tax"
-    assert var.entity == "tax_unit"
-    assert var.tax_benefit_model_version == us_latest
-
-
-def test_us_get_variable_not_found():
-    """Test error handling when variable doesn't exist."""
-    with pytest.raises(
-        ValueError, match="Variable 'nonexistent_variable' not found"
-    ):
-        us_latest.get_variable("nonexistent_variable")
-
-
-def test_us_get_parameter():
-    """Test getting a parameter by name from US model."""
-    # Get a known parameter
-    param = us_latest.get_parameter(
-        "gov.irs.investment.net_investment_income_tax.rate"
-    )
-
-    assert param is not None
-    assert param.name == "gov.irs.investment.net_investment_income_tax.rate"
-    assert param.tax_benefit_model_version == us_latest
-
-
-def test_us_get_parameter_not_found():
-    """Test error handling when parameter doesn't exist."""
-    with pytest.raises(
-        ValueError, match="Parameter 'nonexistent.parameter' not found"
-    ):
-        us_latest.get_parameter("nonexistent.parameter")
-
-
-def test_uk_multiple_variables():
-    """Test getting multiple different variables."""
-    vars_to_test = [
-        "income_tax",
-        "national_insurance",
-        "universal_credit",
-        "household_net_income",
-    ]
-
-    for var_name in vars_to_test:
-        var = uk_latest.get_variable(var_name)
-        assert var.name == var_name
-
-
-def test_us_multiple_variables():
-    """Test getting multiple different variables."""
-    vars_to_test = [
-        "income_tax",
-        "employee_payroll_tax",
-        "eitc",
-        "household_net_income",
-    ]
-
-    for var_name in vars_to_test:
-        var = us_latest.get_variable(var_name)
-        assert var.name == var_name
-
-
-def test_uk_multiple_parameters():
-    """Test getting multiple different parameters."""
-    params_to_test = [
-        "gov.hmrc.income_tax.allowances.personal_allowance.amount",
-        "gov.hmrc.income_tax.rates.uk[0].rate",
-        "gov.dwp.universal_credit.means_test.reduction_rate",
-    ]
-
-    for param_name in params_to_test:
-        param = uk_latest.get_parameter(param_name)
-        assert param.name == param_name
-
-
-def test_us_multiple_parameters():
-    """Test getting multiple different parameters."""
-    params_to_test = [
-        "gov.irs.investment.net_investment_income_tax.rate",
-        "gov.irs.self_employment.rate.social_security",
-        "gov.irs.vita.eligibility.income_limit",
-    ]
-
-    for param_name in params_to_test:
-        param = us_latest.get_parameter(param_name)
-        assert param.name == param_name

policyengine-3.1.7/tests/test_uk_dataset.py

@@ -1,112 +0,0 @@
-import os
-import tempfile
-
-import pandas as pd
-from microdf import MicroDataFrame
-
-from policyengine.core import Dataset, TaxBenefitModel
-from policyengine.tax_benefit_models.uk import (
-    PolicyEngineUKDataset,
-    UKYearData,
-)
-
-
-def test_imports():
-    """Test that basic imports work."""
-    # Verify classes are importable
-    assert PolicyEngineUKDataset is not None
-    assert UKYearData is not None
-    assert Dataset is not None
-    assert TaxBenefitModel is not None
-
-
-def test_uk_latest_instantiation():
-    """Test that uk_latest can be instantiated without errors."""
-    from policyengine.tax_benefit_models.uk import uk_latest
-
-    assert uk_latest is not None
-    assert uk_latest.version is not None
-    assert uk_latest.model is not None
-    assert uk_latest.created_at is not None
-    assert (
-        len(uk_latest.variables) > 0
-    )  # Should have variables from policyengine-uk
-
-
-def test_save_and_load_single_year():
-    """Test saving and loading a dataset with a single year."""
-    # Create sample data
-    person_df = MicroDataFrame(
-        pd.DataFrame(
-            {
-                "person_id": [1, 2, 3],
-                "age": [25, 30, 35],
-                "income": [30000, 45000, 60000],
-                "person_weight": [1.0, 1.0, 1.0],
-            }
-        ),
-        weights="person_weight",
-    )
-
-    benunit_df = MicroDataFrame(
-        pd.DataFrame(
-            {
-                "benunit_id": [1, 2],
-                "size": [2, 1],
-                "total_income": [75000, 60000],
-                "benunit_weight": [1.0, 1.0],
-            }
-        ),
-        weights="benunit_weight",
-    )
-
-    household_df = MicroDataFrame(
-        pd.DataFrame(
-            {
-                "household_id": [1],
-                "num_people": [3],
-                "rent": [1200],
-                "household_weight": [1.0],
-            }
-        ),
-        weights="household_weight",
-    )
-
-    # Create dataset
-    with tempfile.TemporaryDirectory() as tmpdir:
-        filepath = os.path.join(tmpdir, "test_dataset.h5")
-
-        dataset = PolicyEngineUKDataset(
-            name="Test Dataset",
-            description="A test dataset",
-            filepath=filepath,
-            year=2025,
-            data=UKYearData(
-                person=person_df, benunit=benunit_df, household=household_df
-            ),
-        )
-
-        # Save to file
-        dataset.save()
-
-        # Load it back
-        loaded = PolicyEngineUKDataset(
-            name="Loaded Dataset",
-            description="Loaded from file",
-            filepath=filepath,
-            year=2025,
-        )
-        loaded.load()
-
-        # Verify data
-        assert loaded.year == 2025
-        # Convert to DataFrame for comparison (MicroDataFrame inherits from DataFrame)
-        pd.testing.assert_frame_equal(
-            pd.DataFrame(loaded.data.person), pd.DataFrame(person_df)
-        )
-        pd.testing.assert_frame_equal(
-            pd.DataFrame(loaded.data.benunit), pd.DataFrame(benunit_df)
-        )
-        pd.testing.assert_frame_equal(
-            pd.DataFrame(loaded.data.household), pd.DataFrame(household_df)
-        )