policyengine-core 3.32.26__tar.gz → 3.32.28__tar.gz

{policyengine_core-3.32.26 → policyengine_core-3.32.28}/CHANGELOG.md

@@ -1,3 +1,18 @@
+## [3.32.28] - 2026-10-09
+
+### Fixed
+
+- Cache `calculate_add` and `calculate_divide` results as derived only where a plain read returns them without changing dtype, preserving visible inputs and allowing explicit aggregate refresh after an input changes or is deleted.
+
+
+## [3.32.27] - 2026-10-09
+
+### Fixed
+
+- Fix compound period disk storage on Windows while preserving legacy filename restores and clone isolation.
+- Keep input records aligned with memory/disk storage across deletion, copies, handlers, subsampling, period aliases, and early years; custom handlers must use `holder._set` or `holder.set_input` for inputs, since `put_in_cache` values are excluded from input export and reform replay and no longer redirected to the input's branch.
+
+
 ## [3.32.26] - 2026-10-09
 
 ### Fixed

{policyengine_core-3.32.26 → policyengine_core-3.32.28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: policyengine-core
-Version: 3.32.26
+Version: 3.32.28
 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.32.26 → policyengine_core-3.32.28}/policyengine_core/data_storage/on_disk_storage.py

@@ -51,6 +51,11 @@ def _epoch() -> tuple:
 class OnDiskStorage:
     """
     Low-level class responsible for storing and retrieving calculated vectors on disk
+
+    Compound periods contain colons, which Windows forbids in filenames.
+    Their physical filenames use semicolons in the period suffix instead;
+    logical storage keys keep the original period strings. ``restore`` reads
+    both these portable filenames and legacy filenames containing colons.
     """
 
     # Defaults for ``__del__``, which also runs on an instance whose
@@ -315,13 +320,19 @@ class OnDiskStorage:
         own = self._own_paths.get(filename)
         if own is not None:
             return own
-        path = os.path.join(self.storage_dir, filename) + ".npy"
+        # A period string can contain colons, which Windows forbids in
+        # filenames. Period strings never contain semicolons or underscores,
+        # so translating only the final suffix is reversible and leaves
+        # branch names untouched.
+        branch, separator, period_string = filename.rpartition("_")
+        portable_filename = f"{branch}{separator}{period_string.replace(':', ';')}"
+        path = os.path.join(self.storage_dir, portable_filename) + ".npy"
         if path not in self._family_files and not self._writes_only_new_files():
             return path
         directory = os.path.join(self.storage_dir, REPLACEMENTS_DIR)
         os.makedirs(directory, exist_ok=True)
         descriptor, path = tempfile.mkstemp(
-            prefix=f"{filename}.", suffix=".npy", dir=directory
+            prefix=f"{portable_filename}.", suffix=".npy", dir=directory
         )
         os.close(descriptor)
         return path
@@ -365,13 +376,21 @@ class OnDiskStorage:
         """Read back the values stored in this storage's directory: for each
         key, the file named for it (not those in ``REPLACEMENTS_DIR``).
 
-        This storage writes over those files, as over those it wrote, until
+        This storage writes over portable files, as over those it wrote, until
         it is cloned or copied, or this process forks: from then on it writes
         a new file instead, since the clone, copy or forked process reads
         them. A storage made separately for the directory, the one that wrote
         them say, still writes over them, as before. So may another storage
         in this one's family, when ``restore`` runs after it was cloned and
         this process has not forked since.
+
+        The period suffix of new filenames uses semicolons for the colons
+        in compound period strings. Legacy filenames containing colons are
+        still accepted. If both versions of a key exist after updating a
+        legacy value, the portable filename holds the current value and wins
+        regardless of directory listing order. Readers still indexed to the
+        legacy file keep its old value until they restore again. Branch names
+        are unchanged.
         """
         self._files = files = {}
         # Files read back from a directory carry no derived marks.
@@ -382,7 +401,15 @@ class OnDiskStorage:
                 continue
             path = os.path.join(self.storage_dir, filename)
             filename_core = filename.rsplit(".", 1)[0]
-            files[filename_core] = path
+            branch, separator, period_string = filename_core.rpartition("_")
+            key = filename_core
+            if separator:
+                key = f"{branch}{separator}{period_string.replace(';', ':')}"
+            # Updating a legacy value may leave its old colon filename
+            # beside the portable file. Prefer the latter, independent of
+            # directory listing order, without parsing arbitrary basenames.
+            if key not in files or key != filename_core:
+                files[key] = path
         self._restored_paths.update(files.values())
 
     def __del__(self, _rmtree=shutil.rmtree, _getpid=os.getpid) -> None:

{policyengine_core-3.32.26 → policyengine_core-3.32.28}/policyengine_core/holders/holder.py

@@ -1,7 +1,7 @@
 import os
 import tempfile
 import warnings
-from typing import TYPE_CHECKING, Any, List, Tuple
+from typing import TYPE_CHECKING, Any, List, Optional, Tuple
 
 import numpy
 import psutil
@@ -23,6 +23,8 @@ class Holder:
     A holder keeps tracks of a variable values after they have been calculated, or set as an input.
     """
 
+    _user_input_storage: dict[tuple[str, str], tuple[Period, frozenset[str]]]
+
     def __init__(self, variable: "Variable", population: "Population"):
         self.population = population
         self.variable = variable
@@ -63,6 +65,7 @@ class Holder:
                 "simulation",
                 "_memory_storage",
                 "_disk_storage",
+                "_user_input_storage",
             ):
                 new_dict[key] = value
 
@@ -74,6 +77,9 @@ class Holder:
         new._disk_storage = (
             self._disk_storage.clone() if self._disk_storage is not None else None
         )
+        if hasattr(self, "_user_input_storage"):
+            # Locations are immutable; only the holder's index needs copying.
+            new._user_input_storage = self._user_input_storage.copy()
 
         new_dict["population"] = population
         new_dict["simulation"] = population.simulation
@@ -116,13 +122,186 @@ class Holder:
         If ``period`` is ``None``, remove all known values of the variable.
 
         If ``period`` is not ``None``, only remove all values for any period included in period (e.g. if period is "2017", values for "2017-01", "2017-07", etc. would be removed)
+
+        A deleted value set with ``set_input`` stops counting as an input, so
+        a value calculated later for the same period is not taken for one.
         """
+        simulation = getattr(self, "simulation", None)
+        user_input_keys = getattr(simulation, "_user_input_keys", None)
+        stored_before = self._stored_keys() if user_input_keys else None
 
         self._memory_storage.delete(period, branch_name)
         if self._disk_storage:
             self._disk_storage.delete(period, branch_name)
         self._evict_fast_cache(period, branch_name, contained=True)
 
+        if user_input_keys:
+            self._forget_deleted_inputs(user_input_keys, stored_before)
+
+    def _stored_keys(self) -> Tuple[set, set]:
+        """The keys memory and disk storage hold values under."""
+        return (
+            set(self._memory_storage._arrays),
+            set(self._disk_storage._files) if self._disk_storage is not None else set(),
+        )
+
+    def _forget_deleted_inputs(
+        self, user_input_keys: set, stored_before: Tuple[set, set]
+    ) -> None:
+        """Drop the simulation's record of the inputs ``delete_arrays`` deleted.
+
+        ``_user_input_keys`` records each (variable, branch, period) stored
+        through ``set_input``, with the period as storage keys it (see
+        ``_set``). ``_invalidate_all_caches`` keeps the values it names and
+        ``to_input_dataframe`` exports them, so an entry left behind for a
+        deleted value would make a formula result stored later for that
+        period count as an input.
+
+        The keys the deletion removed are found by comparing the keys each
+        storage holds before and after, so the cost depends on what this
+        holder stores, not on the size of the record, and no stored file is
+        read. An entry for a removed key stays only while a storage still
+        holds an input for it. A computed disk value does not become an input
+        when the memory input for the same key is deleted.
+        """
+        name = self.variable.name
+        memory_before, disk_before = stored_before
+        arrays = self._memory_storage._arrays
+        files = self._disk_storage._files if self._disk_storage is not None else {}
+        # Memory keys are "{branch}:{period}"; branch names cannot contain ":".
+        removed = [key.split(":", 1) for key in memory_before if key not in arrays]
+        # Disk keys are "{branch}_{period}"; branch names can contain "_" but
+        # period strings cannot, so the period follows the last "_".
+        removed += [key.rsplit("_", 1) for key in disk_before if key not in files]
+        forgotten = []
+        recorded = getattr(self, "_user_input_storage", {})
+        for branch, period_string in removed:
+            slot = (branch, period_string)
+            input_storage = recorded.get(slot)
+            if input_storage is not None:
+                input_period, locations = input_storage
+                locations = frozenset(
+                    location
+                    for location in locations
+                    if (
+                        f"{branch}:{period_string}" in arrays
+                        if location == "memory"
+                        else f"{branch}_{period_string}" in files
+                    )
+                )
+                recorded[slot] = (input_period, locations)
+            else:
+                try:
+                    # Storage strings omit early years' leading zeros;
+                    # the period parser requires a four-digit year.
+                    components = period_string.split(":")
+                    date_index = 1 if len(components) > 1 else 0
+                    date_components = components[date_index].split("-")
+                    date_components[0] = date_components[0].zfill(4)
+                    components[date_index] = "-".join(date_components)
+                    input_period = periods.period(":".join(components))
+                except ValueError:
+                    # Not a key ``put`` wrote (say, a file ``restore`` found).
+                    continue
+            key = (name, branch, input_period)
+            if key in user_input_keys and not self._stores_user_input(
+                input_period, branch
+            ):
+                forgotten.append(key)
+                recorded.pop(slot, None)
+        user_input_keys.difference_update(forgotten)
+
+    def _seed_input_storage(self, period: Period, branch_name: str) -> None:
+        """Capture registered input locations before their first new write.
+
+        Restoration can register inputs without this holder's tier metadata.
+        Only an already-recorded slot can inherit storage's input marks: an
+        unrecorded cache value must never become a replayable input.
+        """
+        recorded = getattr(self, "_user_input_storage", None)
+        slot = (branch_name, str(period))
+        if recorded is not None and slot in recorded:
+            return
+        keys = getattr(self.simulation, "_user_input_keys", ())
+        if (self.variable.name, branch_name, period) not in keys:
+            return
+        locations = frozenset(
+            location
+            for location, storage in (
+                ("memory", self._memory_storage),
+                ("disk", self._disk_storage),
+            )
+            if storage is not None
+            and storage.has(period, branch_name)
+            and not storage.is_derived(period, branch_name)
+        )
+        if recorded is None:
+            recorded = self._user_input_storage = {}
+        recorded[slot] = (period, locations)
+
+    def _record_input_storage(
+        self, period: Period, branch_name: str, storage: str, is_input: bool = True
+    ) -> None:
+        """Remember which tier received the actual ``set_input`` value.
+
+        Storage's carry-over marks are broader: ``put_in_cache`` defaults to
+        ``derived=False`` without making its value a replay/export input.
+        Keep this metadata only for slots that have received an input, with
+        immutable locations so clones can copy the index independently.
+        """
+        recorded = getattr(self, "_user_input_storage", None)
+        slot = (branch_name, str(period))
+        if not is_input and (recorded is None or slot not in recorded):
+            return
+        if recorded is None:
+            recorded = self._user_input_storage = {}
+        _, locations = recorded.get(slot, (period, frozenset()))
+        locations = locations | {storage} if is_input else locations - {storage}
+        recorded[slot] = (period, locations)
+
+    def _stores_user_input(self, period: Period, branch_name: str) -> bool:
+        """Whether an actual input survives in either tier, without reading it.
+
+        Called only for a slot already in the simulation's replay record.
+        Register-only inputs (including restored inputs) may have no location
+        metadata yet; their existing storage marks identify the surviving
+        tier. Marks never add an unrecorded slot to the replay record.
+        """
+        recorded = getattr(self, "_user_input_storage", {}).get(
+            (branch_name, str(period))
+        )
+        locations = recorded[1] if recorded is not None else {"memory", "disk"}
+        for location, storage in (
+            ("memory", self._memory_storage),
+            ("disk", self._disk_storage),
+        ):
+            if (
+                location in locations
+                and storage is not None
+                and storage.has(period, branch_name)
+                and not storage.is_derived(period, branch_name)
+            ):
+                return True
+        return False
+
+    def _storage_period(self, period: Period) -> Period:
+        """The period storage keys a value for ``period`` under.
+
+        Match the string key's aliases using the period fields: eternity for
+        an eternal variable, and a year for twelve months. Do not reparse the
+        string: valid early-year periods stringify without leading zeros.
+        """
+        if self._memory_storage.is_eternal:
+            return periods.period(periods.ETERNITY)
+        period = periods.period(period)
+        if period.unit in (periods.MONTH, periods.YEAR):
+            unit, size = period.unit, period.size
+            if unit == periods.MONTH and size == 12:
+                unit, size = periods.YEAR, 1
+            start = periods.instant((period.start.year, period.start.month, 1))
+            return Period((unit, start, size))
+        return period
+
     def _get_array_from_storage(
         self, period: Period, branch_name: str = "default"
     ) -> ArrayLike:
@@ -257,6 +436,10 @@ class Holder:
 
 
         If a ``set_input`` property has been set for the variable, this method may accept inputs for periods not matching the ``definition_period`` of the variable. To read more about this, check the `documentation <https://openfisca.org/doc/coding-the-legislation/35_periods.html#set-input-automatically-process-variable-inputs-defined-for-periods-not-matching-the-definition-period>`_.
+
+        Custom handlers store replayable inputs with ``holder._set`` or
+        ``holder.set_input``. Values written through ``put_in_cache`` are
+        excluded from input export and reform replay.
         """
 
         period = periods.period(period)
@@ -365,15 +548,18 @@ class Holder:
         branch_name: str = "default",
         validate_nan: bool = False,
         derived: bool = False,
+        is_input: Optional[bool] = None,
     ) -> None:
         simulation = getattr(self, "simulation", None)
-        # A value calculated while an input is being set (say, by a
-        # ``set_input`` helper that calculates) is not part of that input: it
-        # belongs to the branch it was calculated on.
         user_input_contexts = (
             None if derived else getattr(simulation, "_user_input_contexts", None)
         )
-        if user_input_contexts and branch_name == "default":
+        # A value is an input when stored while ``set_input`` runs, unless the
+        # caller says otherwise: ``put_in_cache`` stores calculated values,
+        # including those a custom ``set_input`` handler calculates.
+        if is_input is None:
+            is_input = bool(user_input_contexts)
+        if is_input and user_input_contexts and branch_name == "default":
             branch_name = user_input_contexts[-1]
         value = self._to_array(value, validate_nan=validate_nan)
         if self.variable.definition_period != periods.ETERNITY:
@@ -389,15 +575,38 @@ class Holder:
             >= self.simulation.memory_config.max_memory_occupation_pc
         )
 
+        stored_period = (
+            self._storage_period(period)
+            if is_input
+            or hasattr(self, "_user_input_storage")
+            or (not derived and getattr(simulation, "_user_input_keys", None))
+            else None
+        )
+        if stored_period is not None:
+            self._seed_input_storage(stored_period, branch_name)
+
         if should_store_on_disk:
             self._disk_storage.put(value, period, branch_name, derived=derived)
         else:
             self._memory_storage.put(value, period, branch_name, derived=derived)
         self._evict_fast_cache(period, branch_name)
-        if user_input_contexts:
+        if stored_period is not None:
+            self._record_input_storage(
+                stored_period,
+                branch_name,
+                "disk" if should_store_on_disk else "memory",
+                is_input=is_input,
+            )
+        if is_input and simulation is not None:
             if not hasattr(simulation, "_user_input_keys"):
                 simulation._user_input_keys = set()
-            simulation._user_input_keys.add((self.variable.name, branch_name, period))
+            # Record the period as storage keys the value (eternity for an
+            # eternal variable, whatever period it was set for; the year for
+            # twelve months starting on the first of a month), so each entry
+            # names one stored value.
+            simulation._user_input_keys.add(
+                (self.variable.name, branch_name, stored_period)
+            )
 
     def put_in_cache(
         self,
@@ -436,7 +645,7 @@ class Holder:
         ):
             return
 
-        self._set(period, value, branch_name, derived=derived)
+        self._set(period, value, branch_name, is_input=False, derived=derived)
 
     def default_array(self) -> ArrayLike:
         """

{policyengine_core-3.32.26 → policyengine_core-3.32.28}/policyengine_core/simulations/simulation.py

@@ -301,7 +301,11 @@ class Simulation:
         # populates so ``_invalidate_all_caches`` can tell user-provided
         # source data apart from formula-computed caches. Without this the
         # post-``apply_reform`` cache wipe would also wipe the dataset the
-        # simulation was loaded from.
+        # simulation was loaded from. The record follows this simulation's
+        # storage: each entry names one stored value (the period is the one
+        # storage keys it under), ``delete_arrays`` drops the entries for the
+        # values it deletes, and ``clone`` (so also ``get_branch``) gives the
+        # copy its own record.
         self._user_input_keys: set[tuple[str, str, Period]] = set()
         self.debug: bool = False
         self.trace: bool = trace
@@ -433,11 +437,11 @@ class Simulation:
         Called after ``apply_reform`` and any other operation that changes
         the tax-benefit system underneath an already-calculated simulation.
 
-        Every (variable, branch, period) that was populated via
-        ``set_input`` is preserved — those are source data, not stale
-        formula output — so a structural reform applied after dataset
-        load doesn't silently discard the dataset. Everything else
-        (formula outputs, cached short-path results, on-disk caches) is
+        Still-present supplied inputs are preserved from the tiers that
+        hold them, so a structural reform applied after dataset load
+        doesn't silently discard the dataset. A cache write replacing an
+        input does not make that cached value a supplied input. Everything
+        else (formula outputs, cached short-path results, on-disk caches) is
         wiped so the next ``calculate`` recomputes under the new
         tax-benefit system.
         """
@@ -451,7 +455,16 @@ class Simulation:
         user_input_keys = getattr(self, "_user_input_keys", None) or set()
         for variable_name, branch_name, period in user_input_keys:
             holder = self.get_holder(variable_name)
-            stored_value = holder._memory_storage.get(period, branch_name)
+            holder._seed_input_storage(period, branch_name)
+            locations = holder._user_input_storage[(branch_name, str(period))][1]
+            # Carry-over marks also include external cache writes. Replay
+            # only tiers that still hold the recorded, supplied input.
+            stored_value = (
+                holder._memory_storage.get(period, branch_name)
+                if "memory" in locations
+                and not holder._memory_storage.is_derived(period, branch_name)
+                else None
+            )
             if stored_value is not None:
                 preserved.append(
                     PreservedUserInput(
@@ -463,7 +476,11 @@ class Simulation:
                     )
                 )
                 continue
-            if holder._disk_storage is not None:
+            if (
+                "disk" in locations
+                and holder._disk_storage is not None
+                and not holder._disk_storage.is_derived(period, branch_name)
+            ):
                 disk_period = (
                     periods.period(periods.ETERNITY)
                     if holder._disk_storage.is_eternal
@@ -484,6 +501,10 @@ class Simulation:
                             disk_enum=holder._disk_storage._enums.get(disk_file),
                         )
                     )
+        self._user_input_keys = {
+            (user_input.variable_name, user_input.branch_name, user_input.period)
+            for user_input in preserved
+        }
         # Iterate only over holders that already exist on each population —
         # lazy-creating a holder for every variable in the tax-benefit
         # system (thousands in policyengine-us) inflated the cost of
@@ -497,6 +518,8 @@ class Simulation:
                 if holder._disk_storage is not None:
                     holder._disk_storage._files = {}
                     holder._disk_storage._derived = set()
+                if hasattr(holder, "_user_input_storage"):
+                    holder._user_input_storage = {}
         # Replay preserved user inputs so ``calculate`` still sees them.
         for user_input in preserved:
             holder = self.get_holder(user_input.variable_name)
@@ -512,6 +535,9 @@ class Simulation:
                     user_input.period,
                     user_input.branch_name,
                 )
+            holder._record_input_storage(
+                user_input.period, user_input.branch_name, user_input.storage
+            )
         for branch in self.branches.values():
             branch._invalidate_all_caches()
 
@@ -1316,12 +1342,7 @@ class Simulation:
         result = sum(
             self.calculate(variable_name, sub_period) for sub_period in sub_periods
         )
-        # Cache only a sum over several sub-periods, as derived from them. A
-        # single sub-period's value is already stored, as an input or
-        # derived, by ``calculate``.
-        if len(sub_periods) > 1:
-            holder = self.get_holder(variable.name)
-            holder.put_in_cache(result, period, self.branch_name, derived=True)
+        self._cache_option_result(variable, period, result)
         return result
 
     def calculate_divide(
@@ -1353,8 +1374,7 @@ class Simulation:
         if period.unit == periods.MONTH:
             computation_period = period.this_year
             result = self.calculate(variable_name, period=computation_period) / 12.0
-            holder = self.get_holder(variable.name)
-            holder.put_in_cache(result, period, self.branch_name, derived=True)
+            self._cache_option_result(variable, period, result)
             return result
         elif period.unit == periods.YEAR:
             return self.calculate(variable_name, period)
@@ -1365,6 +1385,55 @@ class Simulation:
             )
         )
 
+    def _cache_option_result(
+        self, variable: Variable, period: Period, result: ArrayLike
+    ) -> None:
+        """Cache an ADD or DIVIDE result at ``period`` if a plain read would return it.
+
+        A value cached at ``period`` is what every later ``calculate`` of the
+        variable at ``period`` returns. ``_calculate`` computes a FLOW
+        variable over a period of another unit with these same options (a
+        monthly variable over a year with ``calculate_add``, a yearly one over
+        a month with ``calculate_divide``), so their result is the plain value
+        there and is cached. Anywhere else it is not:
+
+        - A STOCK variable's plain value over a year is its last month's, and
+          over a month the year's, not the sum or the twelfth.
+        - Over several periods of the variable's own unit, a plain read
+          raises instead.
+        - A day variable's plain read over a month or a year does not sum.
+        - Over a single period of its own unit, the sum is the value
+          ``calculate`` has already stored.
+
+        Caching there would make a later plain read depend on whether the
+        option ran first. Nor is an option result cached when storing it would
+        change it (the twelfth of an integer or a count of true months is
+        stored as the variable's own type, so a later read would return the
+        truncated value where the first returned the exact one).
+
+        The result is cached as derived, so auto-carry-over and uprating
+        never take it for an input, and ``put_in_cache`` keeps an input a
+        plain read finds at ``period`` (in this branch, an ancestor or
+        ``default``) instead of storing it. It does replace a value
+        calculated there before, which may predate a change to the inputs.
+        Whether the value read is an input comes from the storage's mark for
+        the first visible value, which every write sets. The simulation's
+        supplied-input record follows inputs across storage tiers for replay
+        and export; it can name a disk input hidden by a derived memory value,
+        and raw holder inputs need not be registered there. Accepted cache
+        writes never register the aggregate as a supplied input.
+        """
+        if variable.quantity_type == QuantityType.STOCK:
+            return
+        routed = (variable.definition_period == MONTH and period.unit == YEAR) or (
+            variable.definition_period == YEAR and period.unit == MONTH
+        )
+        if not routed or np.asarray(result).dtype != variable.dtype:
+            return
+        self.get_holder(variable.name).put_in_cache(
+            result, period, self.branch_name, derived=True
+        )
+
     def calculate_output(self, variable_name: str, period: Period = None) -> ArrayLike:
         """
         Calculate the value of a variable using the ``calculate_output`` attribute of the variable.
@@ -1628,6 +1697,9 @@ class Simulation:
         The calling branch, each ancestor branch, and the default branch are
         purged from this simulation's private holder storage. Other branch
         names and the parent simulation's holder storage remain unchanged.
+        Deleted inputs stop counting as inputs: a value calculated later for
+        the same period is a formula result, which ``apply_reform`` discards
+        and ``to_input_dataframe`` does not export.
 
         :param variable: the variable whose cached values should be deleted
         :param period: the period to delete, or all periods when omitted
@@ -1884,6 +1956,8 @@ class Simulation:
             new.tax_benefit_system = self.tax_benefit_system
         new.debug = debug
         new.trace = trace
+        # A ``set_input`` running on this simulation is not running on the copy.
+        new._user_input_contexts = []
 
         # A branch shares its parent's baseline: formulas that run in a
         # branch read the parent's baseline values through it. That holds for
@@ -2371,8 +2445,11 @@ class Simulation:
 
         df = subset_df
 
-        # Update the dataset and rebuild the simulation
+        # Update the dataset and rebuild the simulation. Rebuilding replaces
+        # every stored value, so the record of inputs starts again with the
+        # ones the rebuild sets.
         self.dataset = Dataset.from_dataframe(df, self.dataset.time_period)
+        self._user_input_keys = set()
         self.build_from_dataset()
 
         # Purge ``_fast_cache`` entries populated by ``to_input_dataframe``

{policyengine_core-3.32.26 → policyengine_core-3.32.28}/pyproject.toml

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