policyengine 6.2.6__tar.gz → 6.2.7__tar.gz

{policyengine-6.2.6 → policyengine-6.2.7}/CHANGELOG.md

@@ -1,3 +1,10 @@
+## [6.2.7] - 2026-10-12
+
+### Fixed
+
+- Align UK household and population reform routes with policy effective dates and inclusive date intervals, reject ambiguous bare-year keys, and pass parameter reforms at country-model construction so dated changes are reprocessed when supported by policyengine-uk. A UK policy or dynamic carrying both parameter values and a simulation modifier (as a `Policy` or `Dynamic` sum does) now applies its values and then its modifier, where the modifier used to replace the values.
+
+
 ## [6.2.6] - 2026-10-10
 
 ### Changed

{policyengine-6.2.6/src/policyengine.egg-info → policyengine-6.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: policyengine
-Version: 6.2.6
+Version: 6.2.7
 Summary: A package to conduct policy analysis using PolicyEngine tax-benefit models.
 Author-email: PolicyEngine <hello@policyengine.org>
 License:                     GNU AFFERO GENERAL PUBLIC LICENSE

{policyengine-6.2.6 → policyengine-6.2.7}/docs/households.md

@@ -150,7 +150,7 @@ Scale parameters use bracket indexing:
 reform = {"gov.irs.credits.ctc.amount.base[0].amount": 3_000}
 ```
 
-Time-varying reforms use a nested dict of `YYYY-MM-DD → value`:
+Time-varying reforms use a nested dict of date keys to values:
 
 ```python
 reform = {
@@ -161,6 +161,10 @@ reform = {
 }
 ```
 
+For UK households, a `YYYY-MM-DD` key is effective from that date until the next value for the same parameter, or December 31, 2100 if no later value follows. A `YYYY-MM-DD.YYYY-MM-DD` key applies over that inclusive interval. Scalar values default to January 1 of `year`.
+
+UK households reject bare years such as `"2027"` or `2027`, because the underlying packages assign different meanings to them. Use `"2027-04-06.2028-04-05"` for one UK fiscal year or `"2027-01-01"` for an effective date. See [Reforms](reforms.md) for the shared `Simulation(policy=...)` and `Simulation(dynamic=...)` date contract. The US household route retains its country package's period-key handling.
+
 Structural reforms (new variables, formula swaps) require the `Simulation` path — see [Reforms](reforms.md).
 
 ## Year

{policyengine-6.2.6 → policyengine-6.2.7}/docs/reforms.md

@@ -29,7 +29,19 @@ reform = {
 }
 ```
 
-Dates that haven't passed become "from this date onward." Earlier dates replace the baseline schedule.
+A `YYYY-MM-DD` key is an effective date: its value applies from that date until the next date in the same parameter's reform schedule. If no later value follows, the wrapper emits an interval ending on December 31, 2100.
+
+Use `YYYY-MM-DD.YYYY-MM-DD` for an inclusive interval. For example, this UK reform applies for fiscal year 2027 only:
+
+```python
+reform = {
+    "gov.hmrc.income_tax.rates.uk[0].rate": {
+        "2027-04-06.2028-04-05": 0.21,
+    },
+}
+```
+
+`Simulation(policy=...)`, `Simulation(dynamic=...)`, and UK `calculate_household(reform=...)` accept these two date formats and reject an interval whose end precedes its start. They reject bare years such as `"2027"` or `2027`, because policyengine-uk reads them as fiscal year 2027 only, while policyengine-core's `Reform.from_dict` reads them as from 2027 onward. Use `"2027-04-06.2028-04-05"` for one UK fiscal year or `"2027-01-01"` for an effective date. The US household route retains its country package's period-key handling.
 
 ### Multiple changes
 

{policyengine-6.2.6 → policyengine-6.2.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "policyengine"
-version = "6.2.6"
+version = "6.2.7"
 description = "A package to conduct policy analysis using PolicyEngine tax-benefit models."
 readme = "README.md"
 authors = [

{policyengine-6.2.6 → policyengine-6.2.7}/src/policyengine/data/bundle/manifest.json

@@ -1,10 +1,10 @@
 {
-  "bundle_version": "6.2.6",
+  "bundle_version": "6.2.7",
   "citation": {
     "publisher": "PolicyEngine",
-    "title": "PolicyEngine bundle 6.2.6",
+    "title": "PolicyEngine bundle 6.2.7",
     "type": "software-bundle",
-    "version": "6.2.6"
+    "version": "6.2.7"
   },
   "countries": {
     "uk": {
@@ -17,7 +17,7 @@
   "data_releases": {
     "uk": {
       "build_id": "policyengine-uk-data-1.58.0",
-      "bundle_id": "uk-6.2.6",
+      "bundle_id": "uk-6.2.7",
       "certification": {
         "built_with_model_git_sha": "4cbedbecca352f52dffe47e849553c2759a00711",
         "built_with_model_version": "2.122.2",
@@ -99,7 +99,7 @@
         "version": "2.125.1",
         "wheel_url": "https://files.pythonhosted.org/packages/ec/3a/1d90bad4346d1a8c2715be211ed3d3d7f48917da0d90405b8257b7304091/policyengine_uk-2.125.1-py3-none-any.whl"
       },
-      "policyengine_version": "6.2.6",
+      "policyengine_version": "6.2.7",
       "region_datasets": {
         "national": {
           "path_template": "enhanced_frs_2024_25.h5"
@@ -112,7 +112,7 @@
     },
     "us": {
       "build_id": "populace-us-2024-spm-20260915",
-      "bundle_id": "us-6.2.6",
+      "bundle_id": "us-6.2.7",
       "certification": {
         "built_with_model_version": "2.2.1",
         "certified_by": "policyengine.py bundle certification",
@@ -217,7 +217,7 @@
         "version": "2.2.1",
         "wheel_url": "https://files.pythonhosted.org/packages/5e/09/86ac3968d2a18e28fce3ba1186fc21728e9f299b96a806d6f204f1e0aaed/policyengine_us-2.2.1-py3-none-any.whl"
       },
-      "policyengine_version": "6.2.6",
+      "policyengine_version": "6.2.7",
       "region_datasets": {
         "congressional_district": {
           "path_template": "populace_us_2024_acs_local.h5"
@@ -295,10 +295,10 @@
   "packages": {
     "policyengine": {
       "import_name": "policyengine",
-      "install_requirement": "policyengine==6.2.6",
+      "install_requirement": "policyengine==6.2.7",
       "name": "policyengine",
       "role": "bundle_carrier",
-      "version": "6.2.6"
+      "version": "6.2.7"
     },
     "policyengine-core": {
       "import_name": "policyengine_core",
@@ -334,6 +334,6 @@
       "wheel_url": "https://files.pythonhosted.org/packages/19/a0/c484f69a0ebf88a9b9fd0ac28176f8df66550f46714f1b0c5ec0b360824e/spm_calculator-1.0.0-py3-none-any.whl"
     }
   },
-  "policyengine_version": "6.2.6",
+  "policyengine_version": "6.2.7",
   "schema_version": 2
 }

{policyengine-6.2.6 → policyengine-6.2.7}/src/policyengine/data/bundle/uk.trace.tro.jsonld

@@ -18,18 +18,18 @@
         "schema:url": "https://policyengine.org"
       },
       "schema:dateCreated": "2026-10-07T17:31:53.189867Z",
-      "schema:description": "TRACE TRO for certified runtime bundle uk-6.2.6 covering the bundle manifest, the certified dataset artifact, the country model wheel, and the country data release manifest when it is available.",
+      "schema:description": "TRACE TRO for certified runtime bundle uk-6.2.7 covering the bundle manifest, the certified dataset artifact, the country model wheel, and the country data release manifest when it is available.",
       "schema:name": "policyengine uk certified bundle TRO",
       "trov:createdWith": {
         "@type": "schema:SoftwareApplication",
         "schema:name": "policyengine",
-        "schema:softwareVersion": "6.2.6"
+        "schema:softwareVersion": "6.2.7"
       },
       "trov:hasArrangement": [
         {
           "@id": "arrangement/1",
           "@type": "trov:ArtifactArrangement",
-          "rdfs:comment": "Certified arrangement for bundle uk-6.2.6.",
+          "rdfs:comment": "Certified arrangement for bundle uk-6.2.7.",
           "trov:hasArtifactLocation": [
             {
               "@id": "arrangement/1/location/bundle_manifest",
@@ -75,7 +75,7 @@
             "@type": "trov:ResearchArtifact",
             "schema:name": "policyengine.py bundle manifest for uk",
             "trov:mimeType": "application/json",
-            "trov:sha256": "8633ad814c9c85e53c7c513f69c4c7b1500a03cd2f6ef133d6e2ea8346b2db54"
+            "trov:sha256": "5dadfb8081cee1419de51bfae094fc856444c154505c13bf86ceb40e0838d20c"
           },
           {
             "@id": "composition/1/artifact/data_release_manifest",
@@ -102,7 +102,7 @@
         "trov:hasFingerprint": {
           "@id": "composition/1/fingerprint",
           "@type": "trov:CompositionFingerprint",
-          "trov:sha256": "e6c6d39c2dfcf28a1047e783f4a927673d0dfbcd84b5b305675e1de10e6c4050"
+          "trov:sha256": "b0f0f60ca2071d9cc27fdd46fa07d19e518a209929ccc7df64c9017ab3a57114"
         }
       },
       "trov:hasPerformance": {

{policyengine-6.2.6 → policyengine-6.2.7}/src/policyengine/data/bundle/us.trace.tro.jsonld

@@ -17,18 +17,18 @@
         "schema:name": "PolicyEngine",
         "schema:url": "https://policyengine.org"
       },
-      "schema:description": "TRACE TRO for certified runtime bundle us-6.2.6 covering the bundle manifest, the certified dataset artifact, the country model wheel, and the country data release manifest when it is available.",
+      "schema:description": "TRACE TRO for certified runtime bundle us-6.2.7 covering the bundle manifest, the certified dataset artifact, the country model wheel, and the country data release manifest when it is available.",
       "schema:name": "policyengine us certified bundle TRO",
       "trov:createdWith": {
         "@type": "schema:SoftwareApplication",
         "schema:name": "policyengine",
-        "schema:softwareVersion": "6.2.6"
+        "schema:softwareVersion": "6.2.7"
       },
       "trov:hasArrangement": [
         {
           "@id": "arrangement/1",
           "@type": "trov:ArtifactArrangement",
-          "rdfs:comment": "Certified arrangement for bundle us-6.2.6.",
+          "rdfs:comment": "Certified arrangement for bundle us-6.2.7.",
           "trov:hasArtifactLocation": [
             {
               "@id": "arrangement/1/location/bundle_manifest",
@@ -74,7 +74,7 @@
             "@type": "trov:ResearchArtifact",
             "schema:name": "policyengine.py bundle manifest for us",
             "trov:mimeType": "application/json",
-            "trov:sha256": "8633ad814c9c85e53c7c513f69c4c7b1500a03cd2f6ef133d6e2ea8346b2db54"
+            "trov:sha256": "5dadfb8081cee1419de51bfae094fc856444c154505c13bf86ceb40e0838d20c"
           },
           {
             "@id": "composition/1/artifact/data_release_manifest",
@@ -101,7 +101,7 @@
         "trov:hasFingerprint": {
           "@id": "composition/1/fingerprint",
           "@type": "trov:CompositionFingerprint",
-          "trov:sha256": "4c980b674225037116186b6a8af9a22ff68f534b52dc05dc4519b2dbe2e9055c"
+          "trov:sha256": "e9c575e1126a1c4b688ad1a0cbd9231f0ee0b0b08ad05347c6930c264461e8e0"
         }
       },
       "trov:hasPerformance": {

{policyengine-6.2.6 → policyengine-6.2.7}/src/policyengine/tax_benefit_models/common/reform.py

@@ -1,4 +1,4 @@
-"""Compile a simple reform dict into the format policyengine_core expects.
+"""Compile a simple reform dict into country-model inputs or parameter values.
 
 Accepted shapes for the agent-facing API:
 
@@ -10,6 +10,13 @@ Accepted shapes for the agent-facing API:
     # With explicit effective date(s).
     reform = {"gov.irs.deductions.salt.cap": {"2026-01-01": 0}}
 
+    # With an inclusive start and end date.
+    reform = {
+        "gov.hmrc.income_tax.rates.uk[0].rate": {
+            "2027-04-06.2028-04-05": 0.21,
+        },
+    }
+
     # Multiple parameters.
     reform = {
         "gov.irs.deductions.salt.cap": 0,
@@ -25,9 +32,17 @@ the top-bracket SS wage base is ``gov.ssa.payroll.cap``. If a reform
 dict uses the bracket-head path instead of ``[0].amount`` the
 ``ValueError`` will list the close match.
 
-The compiled form is ``{param_path: {period: value}}`` — exactly what
-``policyengine_us.Simulation(reform=...)`` /
-``policyengine_uk.Simulation(reform=...)`` accept at construction.
+The parameter-value compiler accepts ``YYYY-MM-DD`` as an effective date
+with no end date, or ``YYYY-MM-DD.YYYY-MM-DD`` as an inclusive interval.
+Months and days may be unpadded (``2027-4-6``), as ``strptime`` reads them.
+Other keys, including bare years, are rejected: policyengine-uk interprets
+a bare year as one fiscal year, while policyengine-core interprets it as
+an effective year continuing onward. Use ``2027-04-06.2028-04-05`` for one
+UK fiscal year, or ``2027-01-01`` for an effective date.
+
+The low-level :func:`compile_reform` returns ``{param_path: {period: value}}``
+without interpreting period keys. Parameter-value routes convert values
+to explicit intervals before passing them to the country model.
 
 Scalar reforms default to ``{year}-01-01`` so a caller running
 mid-year does not accidentally get a blended partial-year result.
@@ -103,8 +118,8 @@ def _reform_dict_to_parameter_values(
     """Compile a flat reform dict into a list of ``ParameterValue`` objects.
 
     Uses :func:`compile_reform` for path validation and effective-date
-    defaulting, then materialises each ``{path: {date: value}}`` pair
-    as an open-ended ``ParameterValue`` bound to a
+    defaulting, then materialises each effective date or inclusive interval
+    as a ``ParameterValue`` bound to a
     ``Parameter(name=path, tax_benefit_model_version=model_version)``.
     """
     from policyengine.core.parameter import Parameter
@@ -117,6 +132,32 @@ def _reform_dict_to_parameter_values(
     parameter_values: list[ParameterValue] = []
     for path, date_to_value in compiled.items():
         for effective_date, value in date_to_value.items():
+            try:
+                parts = str(effective_date).split(".")
+                if len(parts) > 2:
+                    raise ValueError("Too many dates")
+                start_date = datetime.datetime.strptime(parts[0], "%Y-%m-%d")
+                end_date = (
+                    datetime.datetime.strptime(parts[1], "%Y-%m-%d")
+                    if len(parts) == 2
+                    else None
+                )
+            except ValueError as exc:
+                raise ValueError(
+                    f"Invalid reform date key {effective_date!r}. Accepted formats are "
+                    "'YYYY-MM-DD' (effective date) and "
+                    "'YYYY-MM-DD.YYYY-MM-DD' (inclusive interval); months and "
+                    "days may be unpadded. Bare years are "
+                    "ambiguous: policyengine-uk's reform dict reads '2027' as fiscal "
+                    "year 2027 only, while policyengine-core's Reform.from_dict "
+                    "reads it as from 2027 on. Use '2027-04-06.2028-04-05' for one "
+                    "UK fiscal year, or '2027-01-01' for an effective date."
+                ) from exc
+            if end_date is not None and end_date < start_date:
+                raise ValueError(
+                    f"Reform interval {effective_date!r} has an end date before "
+                    "its start date."
+                )
             data_type = type(value) if isinstance(value, (int, float, bool)) else float
             parameter_values.append(
                 ParameterValue(
@@ -125,8 +166,8 @@ def _reform_dict_to_parameter_values(
                         tax_benefit_model_version=model_version,
                         data_type=data_type,
                     ),
-                    start_date=datetime.datetime.strptime(effective_date, "%Y-%m-%d"),
-                    end_date=None,
+                    start_date=start_date,
+                    end_date=end_date,
                     value=value,
                 )
             )
@@ -160,7 +201,7 @@ def compile_reform_to_policy(
     """Compile a flat reform dict into a fully-assembled ``Policy``.
 
     Accepts the same ``{param.path: value}`` /
-    ``{param.path: {date: value}}`` shape as :func:`compile_reform`,
+    ``{param.path: {date_or_interval: value}}`` shape as :func:`compile_reform`,
     but returns a ready-to-use ``Policy`` with ``ParameterValue``
     objects so ``Simulation(policy={...})`` works without hand-building
     ``Parameter`` / ``ParameterValue``.

{policyengine-6.2.6 → policyengine-6.2.7}/src/policyengine/tax_benefit_models/uk/household.py

@@ -26,13 +26,16 @@ from typing import Any, Optional
 from policyengine.tax_benefit_models.common import (
     EntityResult,
     HouseholdResult,
-    compile_reform,
     dispatch_extra_variables,
     normalize_axes,
     validate_annual_household_inputs,
     values_for_entity,
 )
+from policyengine.tax_benefit_models.common.reform import (
+    _reform_dict_to_parameter_values,
+)
 from policyengine.utils.household_validation import validate_household_input
+from policyengine.utils.parametric_reforms import reform_dict_from_parameter_values
 
 from .model import uk_latest
 
@@ -129,9 +132,11 @@ def calculate_household(
             Must be non-empty.
         benunit, household: Optional per-entity overrides.
         year: Calendar year. Defaults to 2026.
-        reform: Optional reform dict. Scalar values default to
-            ``{year}-01-01``; invalid parameter paths raise with a
-            close-match suggestion.
+        reform: Optional reform dict. Scalars start at ``{year}-01-01``.
+            ``YYYY-MM-DD`` keys are effective dates; a value lasts until
+            the next effective date or the end of the model horizon.
+            ``YYYY-MM-DD.YYYY-MM-DD`` keys specify inclusive intervals.
+            Invalid parameter paths raise with a close-match suggestion.
         extra_variables: Flat list of extra UK variables to compute;
             the library dispatches each to its entity.
         axes: Optional household-calculator axes. Pass either the lower-level
@@ -181,7 +186,11 @@ def calculate_household(
         names=extra_variables or [],
     )
     output_columns = _default_output_columns(extra_by_entity)
-    reform_dict = compile_reform(reform, year=year, model_version=uk_latest)
+    reform_dict = reform_dict_from_parameter_values(
+        _reform_dict_to_parameter_values(
+            reform or {}, year=year, model_version=uk_latest
+        )
+    )
     normalized_axes = normalize_axes(axes=axes, year=year, model_version=uk_latest)
     axes_active = normalized_axes is not None
 

{policyengine-6.2.6 → policyengine-6.2.7}/src/policyengine/tax_benefit_models/uk/model.py

@@ -167,6 +167,8 @@ class PolicyEngineUKLatest(MicrosimulationModelVersion):
         from policyengine_uk import Microsimulation
 
         from policyengine.utils.parametric_reforms import (
+            build_reform_dict,
+            merge_reform_dicts,
             simulation_modifier_from_parameter_values,
         )
 
@@ -208,23 +210,42 @@ class PolicyEngineUKLatest(MicrosimulationModelVersion):
                 data_year_data=dataset.data_year_data,
             )
 
-        microsim = Microsimulation(dataset=_policyengine_uk_input(dataset))
+        policy = simulation.policy
+        dynamic = simulation.dynamic
+        policy_modifier = policy.simulation_modifier if policy else None
+        dynamic_modifier = dynamic.simulation_modifier if dynamic else None
+        # Each object's parameter values come before its modifier, and the
+        # policy before the dynamic: policy values, policy modifier, dynamic
+        # values, dynamic modifier. A modifier never replaces its object's
+        # parameter values (a Policy or Dynamic sum can carry both).
+        # Parameter values reach policyengine-uk as a reform dict at
+        # construction, which writes them onto the statutory timeline and
+        # reprocesses the parameters. The dynamic's values join that reform
+        # (merge_reform_dicts puts them last, so they win) unless a policy
+        # modifier must run before them; then they are applied after that
+        # modifier, to the annualised parameters, as before.
+        reform_dict = build_reform_dict(policy)
+        late_dynamic_values = None
+        if policy_modifier is None:
+            reform_dict = merge_reform_dicts(reform_dict, build_reform_dict(dynamic))
+        elif dynamic is not None and dynamic.parameter_values:
+            late_dynamic_values = dynamic.parameter_values
+        # policyengine-uk also builds an internal baseline from the same
+        # input, which its formulas read through simulation.baseline.
+        # _policyengine_uk_input gives this run fresh tables, so enum
+        # encoding cannot mutate the caller's dataset.
+        microsim = Microsimulation(
+            dataset=_policyengine_uk_input(dataset), reform=reform_dict
+        )
 
-        if simulation.policy and simulation.policy.simulation_modifier is not None:
-            simulation.policy.simulation_modifier(microsim)
-        elif simulation.policy:
-            modifier = simulation_modifier_from_parameter_values(
-                simulation.policy.parameter_values
-            )
-            modifier(microsim)
+        if policy_modifier is not None:
+            policy_modifier(microsim)
 
-        if simulation.dynamic and simulation.dynamic.simulation_modifier is not None:
-            simulation.dynamic.simulation_modifier(microsim)
-        elif simulation.dynamic:
-            modifier = simulation_modifier_from_parameter_values(
-                simulation.dynamic.parameter_values
-            )
-            modifier(microsim)
+        if late_dynamic_values is not None:
+            simulation_modifier_from_parameter_values(late_dynamic_values)(microsim)
+
+        if dynamic_modifier is not None:
+            dynamic_modifier(microsim)
 
         data = {
             "person": pd.DataFrame(),

{policyengine-6.2.6 → policyengine-6.2.7}/src/policyengine/utils/parametric_reforms.py

@@ -131,7 +131,15 @@ def merge_reform_dicts(
     """Merge two reform dicts, with override values taking precedence.
 
     Either or both dicts can be None. When both have entries for the same
-    parameter, period-level values from override replace those in base.
+    parameter, an override value replaces the base value with the same
+    period key, and every override period comes after the base's periods.
+
+    Where an override period overlaps a base period with a different key,
+    the result depends on the country model. policyengine-uk applies a
+    parameter's periods in the order given, so the override wins.
+    policyengine-core's ``Reform.from_dict``, which the US route uses,
+    applies them in order of start date, so the later-starting period wins
+    whichever dict it came from.
 
     Args:
         base: The base reform dict (e.g., from policy).
@@ -147,7 +155,13 @@ def merge_reform_dicts(
 
     merged = {k: dict(v) for k, v in base.items()}
     for param_name, period_values in override.items():
-        if param_name not in merged:
-            merged[param_name] = {}
-        merged[param_name].update(period_values)
+        # Override values go after the base's, so a country model that
+        # applies a parameter's periods in order lets them win where they
+        # overlap a base period with a different key.
+        kept = {
+            period: value
+            for period, value in merged.get(param_name, {}).items()
+            if period not in period_values
+        }
+        merged[param_name] = {**kept, **period_values}
     return merged

{policyengine-6.2.6 → policyengine-6.2.7/src/policyengine.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: policyengine
-Version: 6.2.6
+Version: 6.2.7
 Summary: A package to conduct policy analysis using PolicyEngine tax-benefit models.
 Author-email: PolicyEngine <hello@policyengine.org>
 License:                     GNU AFFERO GENERAL PUBLIC LICENSE

{policyengine-6.2.6 → policyengine-6.2.7}/src/policyengine.egg-info/SOURCES.txt

@@ -272,6 +272,7 @@ tests/test_spm_selection_schema.py
 tests/test_trace_tro.py
 tests/test_trace_tro_verify.py
 tests/test_uk_analysis.py
+tests/test_uk_dated_reforms.py
 tests/test_uk_geography_assets.py
 tests/test_uk_program_statistics.py
 tests/test_uk_regions.py

{policyengine-6.2.6 → policyengine-6.2.7}/tests/test_dict_reforms_on_simulation.py

@@ -10,12 +10,19 @@ the tests are fast and don't need HF credentials.
 
 from __future__ import annotations
 
+import datetime
+
 import pytest
 
 pytest.importorskip("policyengine_us")
 
 import policyengine as pe
 from policyengine.core import Dynamic, Policy, Simulation
+from policyengine.tax_benefit_models.common.reform import (
+    _reform_dict_to_parameter_values,
+    compile_reform_to_dynamic,
+    compile_reform_to_policy,
+)
 
 # ``us_test_dataset`` is registered globally via ``tests/conftest.py``.
 
@@ -45,6 +52,7 @@ class TestDictPolicyCoercion:
         # Scalar reforms default the effective date to {year}-01-01.
         assert pv.start_date.year == 2026
         assert pv.start_date.month == 1
+        assert pv.end_date is None
 
     def test__dict_policy_with_effective_date__then_start_date_matches(
         self, tiny_dataset
@@ -66,6 +74,7 @@ class TestDictPolicyCoercion:
             "2026-07-01",
             "2027-01-01",
         ]
+        assert all(pv.end_date is None for pv in sim.policy.parameter_values)
 
     def test__unknown_parameter_path__raises_with_suggestion(self, tiny_dataset):
         with pytest.raises(ValueError) as exc:
@@ -81,8 +90,6 @@ class TestDictPolicyCoercion:
         assert "did you mean" in str(exc.value)
 
     def test__existing_policy_object_passes_through_unchanged(self, tiny_dataset):
-        import datetime
-
         from policyengine.core import Parameter, ParameterValue
 
         existing = Policy(
@@ -126,3 +133,92 @@ class TestDictDynamicCoercion:
         assert isinstance(sim.dynamic, Dynamic)
         assert len(sim.dynamic.parameter_values) == 1
         assert sim.dynamic.parameter_values[0].value == 2_800
+
+
+class TestReformDictDates:
+    path = "gov.irs.credits.ctc.amount.base[0].amount"
+
+    @pytest.mark.parametrize(
+        "compiler", [compile_reform_to_policy, compile_reform_to_dynamic]
+    )
+    @pytest.mark.parametrize("stop", ["2027-04-06", "2028-04-05"])
+    def test__interval__then_dates_are_preserved(self, compiler, stop):
+        reform = compiler(
+            {self.path: {f"2027-04-06.{stop}": 3_000}},
+            year=2027,
+            model_version=pe.us.model,
+        )
+        assert len(reform.parameter_values) == 1
+        pv = reform.parameter_values[0]
+        assert pv.start_date == datetime.datetime(2027, 4, 6)
+        assert pv.end_date == datetime.datetime.strptime(stop, "%Y-%m-%d")
+        assert pv.value == 3_000
+
+    def test__interval_end_before_start__raises(self):
+        with pytest.raises(ValueError, match="end date before its start date"):
+            _reform_dict_to_parameter_values(
+                {self.path: {"2028-04-06.2027-04-05": 3_000}},
+                year=2027,
+                model_version=pe.us.model,
+            )
+
+    @pytest.mark.parametrize("key", ["2027", 2027])
+    def test__bare_year__raises_with_country_semantics(self, key):
+        with pytest.raises(ValueError) as exc:
+            _reform_dict_to_parameter_values(
+                {self.path: {key: 3_000}}, year=2027, model_version=pe.us.model
+            )
+        message = str(exc.value)
+        assert "'YYYY-MM-DD'" in message
+        assert "'YYYY-MM-DD.YYYY-MM-DD'" in message
+        assert "Bare years are ambiguous" in message
+        assert "policyengine-uk's reform dict" in message
+        assert "fiscal year 2027 only" in message
+        assert "policyengine-core's Reform.from_dict" in message
+        assert "from 2027 on" in message
+        assert "'2027-04-06.2028-04-05'" in message
+        assert "'2027-01-01'" in message
+
+    @pytest.mark.parametrize(
+        "key",
+        [
+            "2027-02-29",
+            "2027-04-06.2028-02-30",
+            "2027-04-06.2028-04-05.2029-04-05",
+            "2027-04",
+            "not-a-date",
+        ],
+    )
+    def test__other_date_keys__raise_with_accepted_formats(self, key):
+        with pytest.raises(ValueError, match="Accepted formats"):
+            _reform_dict_to_parameter_values(
+                {self.path: {key: 3_000}}, year=2027, model_version=pe.us.model
+            )
+
+    @pytest.mark.parametrize("spec", [3_000, {"2027-01-01": 3_000}])
+    def test__scalar_or_effective_date__then_value_is_open_ended(self, spec):
+        values = _reform_dict_to_parameter_values(
+            {self.path: spec}, year=2027, model_version=pe.us.model
+        )
+        assert len(values) == 1
+        assert values[0].start_date == datetime.datetime(2027, 1, 1)
+        assert values[0].end_date is None
+        assert values[0].value == 3_000
+
+    @pytest.mark.parametrize(
+        "key, start, end",
+        [
+            ("2027-4-6", datetime.datetime(2027, 4, 6), None),
+            (
+                "2027-4-6.2028-4-5",
+                datetime.datetime(2027, 4, 6),
+                datetime.datetime(2028, 4, 5),
+            ),
+        ],
+    )
+    def test__unpadded_dates__then_accepted_as_before(self, key, start, end):
+        # The compiler has always accepted what strptime("%Y-%m-%d") does.
+        (value,) = _reform_dict_to_parameter_values(
+            {self.path: {key: 3_000}}, year=2027, model_version=pe.us.model
+        )
+        assert (value.start_date, value.end_date) == (start, end)

{policyengine-6.2.6 → policyengine-6.2.7}/tests/test_household_impact.py

@@ -67,10 +67,9 @@ class TestUKCalculateHousehold:
             year=2026,
             reform={"gov.hmrc.child_benefit.amount.eldest": 50.0},
         )
-        # If the param path is valid the calc runs; if results differ the reform took.
-        # Accept either: the key thing is the reform dict was accepted without error.
         assert isinstance(reformed.benunit.child_benefit, float)
         assert isinstance(baseline.benunit.child_benefit, float)
+        assert reformed.benunit.child_benefit > baseline.benunit.child_benefit
 
     def test__monthly_year_period__then_raises_before_calculation(self):
         with pytest.raises(ValueError, match="Monthly periods are not supported"):