policyengine-core 3.30.2__tar.gz → 3.30.4__tar.gz

{policyengine_core-3.30.2 → policyengine_core-3.30.4}/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [3.30.4] - 2026-08-04
+
+### Fixed
+
+- Fix `Microsimulation.calculate_add` and `calculate_divide` to honor `map_to` for both values and weights.
+
+
+## [3.30.3] - 2026-07-21
+
+### Fixed
+
+- Fix InMemoryStorage period-key parsing so anchored year periods (e.g. a year-defined input set at a non-January month), whose string form contains colons, no longer crash get_known_periods and get_known_branch_periods; reject colon branch names and mid-month-anchored periods loudly at put time (their keys cannot round-trip; see #526).
+
+
 ## [3.30.2] - 2026-07-20
 
 ### Fixed

{policyengine_core-3.30.2 → policyengine_core-3.30.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: policyengine-core
-Version: 3.30.2
+Version: 3.30.4
 Summary: Core microsimulation engine enabling country-specific policy models.
 Project-URL: Homepage, https://github.com/policyengine/policyengine-core
 Author-email: PolicyEngine <hello@policyengine.org>

{policyengine_core-3.30.2 → policyengine_core-3.30.4}/policyengine_core/data_storage/in_memory_storage.py

@@ -40,6 +40,21 @@ class InMemoryStorage:
             period = periods.period(periods.ETERNITY)
         period = periods.period(period)
 
+        # Keys embed f"{branch_name}:{period}", so reject inputs whose key
+        # would be ambiguous to parse back: branch names containing the
+        # separator, and month/year periods anchored mid-month (their string
+        # form drops the day). See policyengine-core#526 for the structured-
+        # key refactor that will lift these restrictions.
+        if ":" in branch_name:
+            raise ValueError(
+                f"Branch name {branch_name!r} may not contain ':' "
+                "(see policyengine-core#526)."
+            )
+        if period.unit in (periods.YEAR, periods.MONTH) and period.start.day != 1:
+            raise ValueError(
+                f"Cannot cache period {period} anchored mid-month: its "
+                "string form is lossy (see policyengine-core#526)."
+            )
         self._arrays[f"{branch_name}:{period}"] = value
 
     def delete(self, period: Period = None, branch_name: str = "default") -> None:
@@ -71,12 +86,21 @@ class InMemoryStorage:
         }
 
     def get_known_periods(self) -> list:
-        return list(map(lambda x: periods.period(x.split(":")[1]), self._arrays.keys()))
+        # Split on the first colon only: an anchored period's string form
+        # itself contains colons (e.g. "default:year:2027-11").
+        return list(
+            map(
+                lambda x: periods.period(x.split(":", 1)[1]),
+                self._arrays.keys(),
+            )
+        )
 
     def get_known_branch_periods(self) -> list:
         return [
             (branch_name, periods.period(period))
-            for branch_name, period in map(lambda x: x.split(":"), self._arrays.keys())
+            for branch_name, period in map(
+                lambda x: x.split(":", 1), self._arrays.keys()
+            )
         ]
 
     def get_memory_usage(self) -> dict:

{policyengine_core-3.30.2 → policyengine_core-3.30.4}/policyengine_core/simulations/microsimulation.py

@@ -88,10 +88,15 @@ class Microsimulation(Simulation):
         map_to: str = None,
         use_weights: bool = True,
     ) -> MicroSeries:
-        values = super().calculate_add(variable_name, period, map_to)
+        values = super().calculate_add(variable_name, period)
+        if map_to is not None:
+            source_entity = self.tax_benefit_system.get_variable(
+                variable_name, check_existence=True
+            ).entity.key
+            values = self.map_result(np.array(values), source_entity, map_to)
         if not use_weights:
             return values
-        weights = self.get_weights(variable_name, period)
+        weights = self.get_weights(variable_name, period, map_to)
         return MicroSeries(np.array(values), weights=weights)
 
     def calculate_divide(
@@ -101,10 +106,15 @@ class Microsimulation(Simulation):
         map_to: str = None,
         use_weights: bool = True,
     ) -> MicroSeries:
-        values = super().calculate_divide(variable_name, period, map_to)
+        values = super().calculate_divide(variable_name, period)
+        if map_to is not None:
+            source_entity = self.tax_benefit_system.get_variable(
+                variable_name, check_existence=True
+            ).entity.key
+            values = self.map_result(np.array(values), source_entity, map_to)
         if not use_weights:
             return values
-        weights = self.get_weights(variable_name, period)
+        weights = self.get_weights(variable_name, period, map_to)
         return MicroSeries(np.array(values), weights=weights)
 
     def calculate_dataframe(

{policyengine_core-3.30.2 → policyengine_core-3.30.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "policyengine-core"
-version = "3.30.2"
+version = "3.30.4"
 description = "Core microsimulation engine enabling country-specific policy models."
 readme = "README.md"
 authors = [

{policyengine_core-3.30.2 → policyengine_core-3.30.4}/tests/core/test_holders.py

@@ -184,7 +184,7 @@ def test_known_periods(couple):
     holder.put_in_cache(data, month)
     holder._memory_storage.put(data, month_2)
 
-    assert sorted(holder.get_known_periods()), [month == month_2]
+    assert sorted(holder.get_known_periods()) == [month, month_2]
 
 
 def test_cache_enum_on_disk(single):

{policyengine_core-3.30.2 → policyengine_core-3.30.4}/tests/core/test_microsimulation_weights.py

@@ -16,6 +16,7 @@ def _weighted_dataset(include_person_weight: bool = True) -> Dataset:
         "person_household_role__2022": ["parent", "child", "parent"],
         "household_weight__2022": [10.0, 10.0, 20.0],
         "salary__2022-01": [100.0, 200.0, 300.0],
+        "housing_tax__2022": [120.0, 120.0, 240.0],
     }
     if include_person_weight:
         data["person_weight__2022"] = [1.0, 2.0, 3.0]
@@ -65,6 +66,38 @@ def test__given_dataframe_mapped_to_household__then_weights_are_household_weight
     np.testing.assert_array_equal(dataframe.weights, np.array([10.0, 20.0]))
 
 
+def test__given_calculate_add_mapped_to_household__then_values_and_weights_match_households():
+    # Given
+    simulation = Microsimulation(dataset=_weighted_dataset())
+
+    # When
+    result = simulation.calculate_add(
+        "salary",
+        "2022-01",
+        map_to="household",
+    )
+
+    # Then
+    np.testing.assert_array_equal(result, np.array([300.0, 300.0]))
+    np.testing.assert_array_equal(result.weights, np.array([10.0, 20.0]))
+
+
+def test__given_calculate_divide_mapped_to_person__then_values_and_weights_match_persons():
+    # Given
+    simulation = Microsimulation(dataset=_weighted_dataset())
+
+    # When
+    result = simulation.calculate_divide(
+        "housing_tax",
+        "2022-01",
+        map_to="person",
+    )
+
+    # Then
+    np.testing.assert_array_equal(result, np.array([10.0, 10.0, 20.0]))
+    np.testing.assert_array_equal(result.weights, np.array([10.0, 10.0, 20.0]))
+
+
 Family = build_entity(
     key="family",
     plural="families",

policyengine_core-3.30.4/tests/core/test_storage_anchored_periods.py

@@ -0,0 +1,61 @@
+"""Regression tests for storage key parsing with anchored periods (#523).
+
+A year period anchored at a non-January month stringifies with colons
+(e.g. ``"year:2027-11"``), so storage keys look like
+``"default:year:2027-11"``. ``get_known_periods`` and
+``get_known_branch_periods`` previously split those keys on every colon,
+crashing on the literal ``"year"`` (or mis-unpacking the tuple). This is
+hit in practice whenever a year-defined input variable is set at a
+non-January month test period.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+from policyengine_core import periods
+from policyengine_core.data_storage.in_memory_storage import InMemoryStorage
+
+
+def test_get_known_periods_with_anchored_year_period():
+    storage = InMemoryStorage(is_eternal=False)
+    anchored = periods.period("year:2027-11")
+    storage.put(np.asarray([1.0]), anchored, branch_name="default")
+    storage.put(np.asarray([2.0]), "2024-01", branch_name="default")
+    known = storage.get_known_periods()
+    assert anchored in known
+    assert periods.period("2024-01") in known
+
+
+def test_get_known_branch_periods_with_anchored_year_period():
+    storage = InMemoryStorage(is_eternal=False)
+    anchored = periods.period("year:2027-11")
+    storage.put(np.asarray([1.0]), anchored, branch_name="reform")
+    assert storage.get_known_branch_periods() == [("reform", anchored)]
+
+
+def test_put_rejects_colon_branch_names():
+    import pytest
+
+    storage = InMemoryStorage(is_eternal=False)
+    with pytest.raises(ValueError, match="526"):
+        storage.put(np.asarray([1.0]), "2024-01", branch_name="my:reform")
+
+
+def test_put_rejects_mid_month_anchored_periods():
+    import pytest
+
+    from policyengine_core.periods import Instant, Period, YEAR
+
+    storage = InMemoryStorage(is_eternal=False)
+    day_anchored = Period((YEAR, Instant((2027, 11, 15)), 2))
+    with pytest.raises(ValueError, match="lossy"):
+        storage.put(np.asarray([1.0]), day_anchored, branch_name="default")
+
+
+def test_eternal_storage_round_trips():
+    storage = InMemoryStorage(is_eternal=True)
+    storage.put(np.asarray([1.0]), "2024-01", branch_name="default")
+    from policyengine_core import periods as p
+
+    assert storage.get_known_periods() == [p.period(p.ETERNITY)]