policyengine-core 3.34.7__tar.gz → 3.34.9__tar.gz

{policyengine_core-3.34.7 → policyengine_core-3.34.9}/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [3.34.9] - 2026-11-07
+
+### Fixed
+
+- Holders now follow their system's current variable definitions whenever a simulation looks them up, so a reform can set an input for a variable it restores, and `apply_reform` keeps `input_variables` unless it drops a name.
+
+
+## [3.34.8] - 2026-11-06
+
+### Fixed
+
+- Simulation.apply_reform now rebinds existing holders to each branch's system before clearing cached calculations.
+
+
 ## [3.34.7] - 2026-11-05
 
 ### Changed

{policyengine_core-3.34.7 → policyengine_core-3.34.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: policyengine-core
-Version: 3.34.7
+Version: 3.34.9
 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.34.7 → policyengine_core-3.34.9}/policyengine_core/holders/holder.py

@@ -48,6 +48,27 @@ class Holder:
             if self.variable.name in self.simulation.memory_config.variables_to_drop:
                 self._do_not_store = True
 
+    def _follow_definition(self, variable: "Variable") -> None:
+        """Take ``variable`` as this holder's definition when its storage fits.
+
+        A definition for the same entity, with the same ``ETERNITY`` storage,
+        replaces the holder's own, so reads and writes follow it: a
+        neutralized definition reads its default and ignores new inputs, and
+        a restored one stores them again. A change of entity or of
+        ``ETERNITY`` storage needs a new holder, so this leaves the holder as
+        it is; ``Simulation.apply_reform`` drops such holders when it binds
+        them to the reformed system.
+        """
+        if variable is self.variable:
+            return
+        if variable.entity.key != self.variable.entity.key:
+            return
+        if (
+            variable.definition_period == periods.ETERNITY
+        ) != self._memory_storage.is_eternal:
+            return
+        self.variable = variable
+
     def clone(self, population: "Population", share_arrays: bool = False) -> "Holder":
         """
         Copy the holder just enough to be able to run a new simulation without modifying the original simulation.

{policyengine_core-3.34.7 → policyengine_core-3.34.9}/policyengine_core/populations/population.py

@@ -168,10 +168,15 @@ See more information at <https://openfisca.org/doc/coding-the-legislation/35_per
 
     def get_holder(self, variable_name: str) -> Holder:
         self.entity.check_variable_defined_for_entity(variable_name)
+        variable = self.entity.get_variable(variable_name)
         holder = self._holders.get(variable_name)
         if holder:
+            # The system may have replaced the definition since the holder
+            # was made or last bound: a reform's ``apply`` that restores a
+            # neutralized variable and then sets its input, or code that
+            # changes a branch's system directly.
+            holder._follow_definition(variable)
             return holder
-        variable = self.entity.get_variable(variable_name)
         self._holders[variable_name] = holder = Holder(variable, self)
         return holder
 

{policyengine_core-3.34.7 → policyengine_core-3.34.9}/policyengine_core/simulations/simulation.py

@@ -919,6 +919,10 @@ class Simulation:
             # variables, so a variable the reform neutralized read as the
             # default in the baseline too.
             self.baseline._bind_to_tax_benefit_system()
+            # The branch shares this simulation's list of input variables,
+            # and the binding keeps a list it drops nothing from. The
+            # baseline runs under another system, so it keeps its own list.
+            self.baseline.input_variables = list(self.baseline.input_variables)
         else:
             self.baseline = None
 
@@ -932,6 +936,8 @@ class Simulation:
             if isinstance(reform, dict):
                 reform = Reform.from_dict(reform)
             reform.apply(self.tax_benefit_system)
+        # Refresh holders before input replay looks them up in the new system.
+        self._bind_to_tax_benefit_system()
         # Invalidate every cached value so the simulation recomputes under
         # the new tax-benefit system. Previously ``apply_reform`` left
         # ``_fast_cache``, in-memory holder storage, and on-disk holder
@@ -1318,6 +1324,15 @@ class Simulation:
         holder was built for the reform's definition in a way a new variable
         cannot change: in another entity's population, or with storage for
         (or not for) an ``ETERNITY`` variable.
+
+        After an in-place reform, compatible holders keep their storage and
+        recorded inputs. Each existing branch binds to its own system, so
+        shared-system branches follow the reform and a baseline keeps its
+        baseline variables. This replaces ``input_variables`` and the
+        recorded inputs only when it drops an entry, so a list that a clone or
+        branch shares stays shared; the code that builds a baseline branch
+        gives it a list of its own. Between reforms, ``Population.get_holder``
+        keeps compatible holders on the current definitions.
         """
         system = self.tax_benefit_system
         if system is None:
@@ -1346,14 +1361,27 @@ class Simulation:
                     holder.variable = variable
 
         def kept(name):
-            return name in variables and name not in dropped
+            # A reform may supply a new entity's input before we drop the old holder.
+            return name in variables and (
+                name not in dropped
+                or name in self.populations[variables[name].entity.key]._holders
+            )
 
-        if getattr(self, "_user_input_keys", None) is not None:
-            self._user_input_keys = {
-                key for key in self._user_input_keys if kept(key[0])
-            }
-        if getattr(self, "input_variables", None) is not None:
-            self.input_variables = [name for name in self.input_variables if kept(name)]
+        # Replace a record only when it loses a name, and never edit it in
+        # place: a clone or branch may share its parent's, and callers may
+        # hold it.
+        user_input_keys = getattr(self, "_user_input_keys", None)
+        if user_input_keys is not None and not all(
+            kept(key[0]) for key in user_input_keys
+        ):
+            self._user_input_keys = {key for key in user_input_keys if kept(key[0])}
+        input_variables = getattr(self, "input_variables", None)
+        if input_variables is not None and not all(
+            kept(name) for name in input_variables
+        ):
+            self.input_variables = [name for name in input_variables if kept(name)]
+        for branch in self.branches.values():
+            branch._bind_to_tax_benefit_system()
 
     def create_shortcuts(self) -> None:
         for _key, population in self.populations.items():
@@ -3645,6 +3673,8 @@ class Simulation:
             baseline.tracer = self.tracer
             baseline.tax_benefit_system = baseline_tax_benefit_system
             baseline._bind_to_tax_benefit_system()
+            # As in ``__init__``, the baseline keeps its own list.
+            baseline.input_variables = list(baseline.input_variables)
             baseline.baseline = None
             if getattr(self, "baseline", None) is not None:
                 self.baseline = baseline

{policyengine_core-3.34.7 → policyengine_core-3.34.9}/pyproject.toml

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

policyengine_core-3.34.9/tests/core/test_apply_reform_holders.py

@@ -0,0 +1,416 @@
+"""Reforms refresh existing holders without discarding compatible inputs."""
+
+import warnings
+
+import numpy as np
+import pytest
+
+from policyengine_core.errors import VariableNotFoundError
+from policyengine_core.parameters import ParameterNode
+from policyengine_core.periods import ETERNITY, YEAR, period
+from policyengine_core.reforms import Reform
+from policyengine_core.variables import Variable
+from tests.fixtures.reform_holders import (
+    Household,
+    Person,
+    award,
+    build,
+    change_default,
+    store_on_disk,
+)
+
+PERIOD = "2025"
+
+
+def assert_bound(simulation):
+    for population in simulation.populations.values():
+        for name, holder in population._holders.items():
+            assert holder.variable is simulation.tax_benefit_system.variables[name]
+            assert holder.variable.entity.key == population.entity.key
+            assert holder._memory_storage.is_eternal == (
+                holder.variable.definition_period == ETERNITY
+            )
+
+
+def test_defined_for_default_does_not_depend_on_other_people():
+    results = []
+    for mask in ([False], [False, True]):
+        simulation = build(mask)
+        old_holder = simulation.get_holder("award")
+        simulation.apply_reform(change_default(20))
+        results.append(simulation.calculate("award", PERIOD).tolist())
+        assert simulation.get_holder("award") is old_holder
+
+    assert results == [[20], [20, 100]]
+
+
+@pytest.mark.parametrize("on_disk", [False, True])
+def test_replaced_variable_keeps_recorded_inputs(on_disk):
+    simulation = build()
+    if on_disk:
+        store_on_disk(simulation, "award")
+    simulation.set_input("award", PERIOD, [7, 9])
+    holder = simulation.get_holder("award")
+    records = simulation._user_input_keys.copy()
+    simulation.input_variables = ["award", "eligible"]
+
+    simulation.apply_reform(change_default(20))
+
+    assert simulation.get_holder("award") is holder
+    assert_bound(simulation)
+    assert simulation._user_input_keys == records
+    assert simulation.input_variables == ["award", "eligible"]
+    np.testing.assert_array_equal(simulation.calculate("award", PERIOD), [7, 9])
+    np.testing.assert_array_equal(holder._get_array_from_storage(PERIOD), [7, 9])
+
+
+class NeutralizeAward(Reform):
+    def apply(self):
+        self.neutralize_variable("award")
+
+
+@pytest.mark.parametrize("on_disk", [False, True])
+def test_neutralized_variable_keeps_input_storage_but_reads_its_default(on_disk):
+    simulation = build()
+    if on_disk:
+        store_on_disk(simulation, "award")
+    simulation.set_input("award", PERIOD, [7, 9])
+    records = simulation._user_input_keys.copy()
+
+    simulation.apply_reform(NeutralizeAward)
+
+    holder = simulation.get_holder("award")
+    assert_bound(simulation)
+    assert holder.variable.is_neutralized
+    assert simulation._user_input_keys == records
+    np.testing.assert_array_equal(holder._get_array_from_storage(PERIOD), [7, 9])
+    np.testing.assert_array_equal(simulation.calculate("award", PERIOD), [0, 0])
+
+
+class RestoreAward(Reform):
+    def apply(self):
+        self.replace_variable(award)
+
+
+def restore_and_set_award(values):
+    """Return a reform that restores the award, then sets and reads its input."""
+
+    class RestoreAndSetAward(Reform):
+        def apply(self):
+            self.replace_variable(award)
+            self.simulation.set_input("award", PERIOD, values)
+            np.testing.assert_array_equal(
+                self.simulation.calculate("award", PERIOD), values
+            )
+
+    return RestoreAndSetAward
+
+
+def neutralize_and_set_award(values):
+    """Return a reform that neutralizes the award, then sets its input."""
+
+    class NeutralizeAndSetAward(Reform):
+        def apply(self):
+            self.neutralize_variable("award")
+            self.simulation.set_input("award", PERIOD, values)
+
+    return NeutralizeAndSetAward
+
+
+def neutralized_input_warnings(caught):
+    return [warning for warning in caught if "neutralized" in str(warning.message)]
+
+
+@pytest.mark.parametrize("on_disk", [False, True])
+def test_reform_keeps_an_input_it_sets_after_restoring_a_neutralized_variable(
+    on_disk,
+):
+    simulation = build()
+    if on_disk:
+        store_on_disk(simulation, "award")
+    simulation.set_input("award", PERIOD, [7, 9])
+    simulation.apply_reform(NeutralizeAward)
+
+    with warnings.catch_warnings(record=True) as caught:
+        warnings.simplefilter("always")
+        simulation.apply_reform(restore_and_set_award([20, 30]))
+
+    assert not neutralized_input_warnings(caught)
+    assert_bound(simulation)
+    holder = simulation.get_holder("award")
+    np.testing.assert_array_equal(holder._get_array_from_storage(PERIOD), [20, 30])
+    np.testing.assert_array_equal(simulation.calculate("award", PERIOD), [20, 30])
+
+
+@pytest.mark.parametrize("on_disk", [False, True])
+def test_reform_ignores_an_input_it_sets_after_neutralizing_the_variable(on_disk):
+    # A holder made after the neutralization ignores the input, so one made
+    # before it does too.
+    simulation = build()
+    if on_disk:
+        store_on_disk(simulation, "award")
+    simulation.set_input("award", PERIOD, [7, 9])
+
+    with pytest.warns(Warning, match="neutralized"):
+        simulation.apply_reform(neutralize_and_set_award([1, 2]))
+
+    np.testing.assert_array_equal(simulation.calculate("award", PERIOD), [0, 0])
+    simulation.apply_reform(RestoreAward)
+    np.testing.assert_array_equal(simulation.calculate("award", PERIOD), [7, 9])
+
+
+def test_input_set_while_a_variable_is_neutralized_is_ignored():
+    simulation = build()
+    simulation.set_input("award", PERIOD, [7, 9])
+    simulation.apply_reform(NeutralizeAward)
+
+    with pytest.warns(Warning, match="neutralized"):
+        simulation.set_input("award", PERIOD, [55, 55])
+
+    simulation.apply_reform(RestoreAward)
+    np.testing.assert_array_equal(simulation.calculate("award", PERIOD), [7, 9])
+
+
+def test_holders_follow_a_branch_system_changed_outside_a_reform():
+    simulation = build()
+    simulation.set_input("award", PERIOD, [7, 9])
+    branch = simulation.get_branch("measured", clone_system=True)
+
+    branch.tax_benefit_system.neutralize_variable("award")
+
+    assert branch.get_holder("award").variable.is_neutralized
+    assert not simulation.get_holder("award").variable.is_neutralized
+    np.testing.assert_array_equal(branch.calculate("award", PERIOD), [0, 0])
+    with pytest.warns(Warning, match="neutralized"):
+        branch.set_input("award", PERIOD, [1, 1])
+    np.testing.assert_array_equal(simulation.calculate("award", PERIOD), [7, 9])
+
+
+def test_reform_that_drops_no_input_keeps_each_input_list():
+    simulation = build()
+    simulation.set_input("income", PERIOD, [7, 9])
+    names = simulation.input_variables = ["income", "eligible"]
+    branch = simulation.get_branch("other")
+    branch_names = branch.input_variables
+
+    simulation.apply_reform(change_default(20))
+
+    # Callers may hold either list, and a branch may share its parent's.
+    assert simulation.input_variables is names
+    assert branch.input_variables is branch_names
+    assert names == ["income", "eligible"]
+
+
+class added(Variable):
+    value_type = float
+    entity = Person
+    definition_period = YEAR
+    default_value = 13
+    label = "Added amount"
+
+
+class AddAndRemove(Reform):
+    def apply(self):
+        self.add_variable(added)
+        del self.variables["annual_value"]
+
+
+@pytest.mark.parametrize("on_disk", [False, True])
+def test_added_variable_is_lazy_and_removed_variable_drops_holder_and_inputs(on_disk):
+    simulation = build()
+    if on_disk:
+        store_on_disk(simulation, "annual_value")
+    simulation.set_input("annual_value", PERIOD, [7, 9])
+    simulation.input_variables = ["annual_value", "eligible"]
+
+    names = simulation.input_variables
+
+    simulation.apply_reform(AddAndRemove)
+
+    assert_bound(simulation)
+    assert "annual_value" not in simulation.persons._holders
+    assert "annual_value" not in simulation.input_variables
+    # The list may be shared, so the reform replaces it instead of editing it.
+    assert names == ["annual_value", "eligible"]
+    assert all(key[0] != "annual_value" for key in simulation._user_input_keys)
+    with pytest.raises(VariableNotFoundError):
+        simulation.get_holder("annual_value")
+    assert "added" not in simulation.persons._holders
+    np.testing.assert_array_equal(simulation.calculate("added", PERIOD), [13, 13])
+    assert_bound(simulation)
+
+
+def test_tuple_reform_rebinds_after_each_reform():
+    class CheckFirstReform(Reform):
+        def apply(self):
+            assert (
+                self.simulation.get_holder("award").variable is self.variables["award"]
+            )
+            change_default(30).apply(self)
+
+    simulation = build([False])
+    simulation.apply_reform((change_default(20), CheckFirstReform))
+
+    assert_bound(simulation)
+    np.testing.assert_array_equal(simulation.calculate("award", PERIOD), [30])
+
+
+def test_dict_reform_keeps_inputs_and_rebinds_stale_holders():
+    simulation = build([False])
+    simulation.tax_benefit_system.parameters = ParameterNode(
+        "", data={"amount": {"values": {"2025-01-01": {"value": 1}}}}
+    )
+    simulation.set_input("income", PERIOD, [7])
+    change_default(20).apply(simulation.tax_benefit_system)
+
+    simulation.apply_reform({"amount": {"2025": 2}})
+
+    assert_bound(simulation)
+    assert simulation.tax_benefit_system.parameters("2025-01-01").amount == 2
+    np.testing.assert_array_equal(simulation.calculate("income", PERIOD), [7])
+    np.testing.assert_array_equal(simulation.calculate("award", PERIOD), [20])
+
+
+def test_existing_baseline_keeps_its_own_system():
+    simulation = build([False])
+    baseline = simulation.get_branch("baseline", clone_system=True)
+    simulation.baseline = baseline
+    baseline_system = baseline.tax_benefit_system
+    np.testing.assert_array_equal(baseline.calculate("award", PERIOD), [0])
+
+    simulation.apply_reform(change_default(20))
+
+    assert simulation.baseline is baseline
+    assert baseline.tax_benefit_system is baseline_system
+    assert_bound(simulation)
+    assert_bound(baseline)
+    np.testing.assert_array_equal(baseline.calculate("award", PERIOD), [0])
+    np.testing.assert_array_equal(simulation.calculate("award", PERIOD), [20])
+
+
+def test_existing_branches_rebind_to_their_own_systems():
+    simulation = build([False])
+    shared = simulation.get_branch("shared")
+    nested = shared.get_branch("nested")
+    independent = simulation.get_branch("independent", clone_system=True)
+    independent.apply_reform(change_default(40))
+    for branch in (simulation, shared, nested, independent):
+        branch.set_input("income", PERIOD, [7])
+        branch.calculate("award", PERIOD)
+
+    simulation.apply_reform(change_default(20))
+
+    for branch, expected in (
+        (simulation, 20),
+        (shared, 20),
+        (nested, 20),
+        (independent, 40),
+    ):
+        assert_bound(branch)
+        np.testing.assert_array_equal(branch.calculate("award", PERIOD), [expected])
+        np.testing.assert_array_equal(branch.calculate("income", PERIOD), [7])
+
+
+class MoveAnnualToHousehold(Reform):
+    def apply(self):
+        class annual_value(Variable):
+            entity = Household
+            default_value = 17
+
+        self.update_variable(annual_value)
+
+
+def test_entity_change_drops_orphaned_holder_and_input_records():
+    simulation = build()
+    simulation.set_input("annual_value", PERIOD, [7, 9])
+    simulation.input_variables = ["annual_value", "eligible"]
+
+    simulation.apply_reform(MoveAnnualToHousehold)
+
+    assert "annual_value" not in simulation.persons._holders
+    assert "annual_value" not in simulation.input_variables
+    assert all(key[0] != "annual_value" for key in simulation._user_input_keys)
+    np.testing.assert_array_equal(simulation.calculate("annual_value", PERIOD), [17])
+    assert_bound(simulation)
+
+
+@pytest.mark.parametrize("on_disk", [False, True])
+def test_entity_change_keeps_inputs_supplied_to_the_new_holder(on_disk):
+    class MoveAndSupply(Reform):
+        def apply(self):
+            MoveAnnualToHousehold.apply(self)
+            self.simulation.set_input("annual_value", PERIOD, [31])
+
+    simulation = build()
+    if on_disk:
+        store_on_disk(simulation, "annual_value")
+    simulation.set_input("annual_value", PERIOD, [7, 9])
+    simulation.input_variables = ["annual_value", "eligible"]
+
+    simulation.apply_reform(MoveAndSupply)
+
+    assert "annual_value" not in simulation.persons._holders
+    assert "annual_value" in simulation.input_variables
+    assert ("annual_value", "default", period(PERIOD)) in simulation._user_input_keys
+    np.testing.assert_array_equal(simulation.calculate("annual_value", PERIOD), [31])
+    assert_bound(simulation)
+
+
+class MakeAnnual(Reform):
+    def apply(self):
+        class eternal_value(Variable):
+            definition_period = YEAR
+
+            def formula(person, period):
+                return person.filled_array(period.start.year)
+
+        self.update_variable(eternal_value)
+
+
+class MakeEternal(Reform):
+    def apply(self):
+        class annual_value(Variable):
+            definition_period = ETERNITY
+
+        self.update_variable(annual_value)
+
+
+@pytest.mark.parametrize("on_disk", [False, True])
+def test_eternity_to_year_drops_incompatible_storage_and_inputs(on_disk):
+    simulation = build()
+    if on_disk:
+        store_on_disk(simulation, "eternal_value")
+    simulation.set_input("eternal_value", PERIOD, [7, 9])
+    simulation.input_variables = ["eternal_value", "eligible"]
+
+    simulation.apply_reform(MakeAnnual)
+
+    np.testing.assert_array_equal(
+        simulation.calculate("eternal_value", "2025"), [2025, 2025]
+    )
+    np.testing.assert_array_equal(
+        simulation.calculate("eternal_value", "2026"), [2026, 2026]
+    )
+    assert "eternal_value" not in simulation.input_variables
+    assert all(key[0] != "eternal_value" for key in simulation._user_input_keys)
+    assert_bound(simulation)
+
+
+@pytest.mark.parametrize("on_disk", [False, True])
+def test_year_to_eternity_uses_eternal_storage_for_new_inputs(on_disk):
+    simulation = build()
+    if on_disk:
+        store_on_disk(simulation, "annual_value")
+    simulation.set_input("annual_value", PERIOD, [7, 9])
+    simulation.apply_reform(MakeEternal)
+
+    assert all(key[0] != "annual_value" for key in simulation._user_input_keys)
+    simulation.set_input("annual_value", PERIOD, [11, 12])
+
+    assert_bound(simulation)
+    np.testing.assert_array_equal(
+        simulation.calculate("annual_value", "2025"), [11, 12]
+    )
+    np.testing.assert_array_equal(
+        simulation.calculate("annual_value", "2026"), [11, 12]
+    )