PolicyEngine-UK 2.141.2__tar.gz → 2.141.4__tar.gz

{policyengine_uk-2.141.2 → policyengine_uk-2.141.4}/CHANGELOG.md

@@ -1,3 +1,22 @@
+## [2.141.4] - 2026-10-20
+
+### Fixed
+
+- A before-load `Scenario` change to DfE, DHSC or DfT spending now constructs: `adjust_budgets` skips a year with no allocation instead of writing NaN, and scales each year's allocation by that year's own budget change without carrying an earlier year's change forward.
+
+
+## [2.141.3] - 2026-10-20
+
+### Fixed
+
+- - The Aggregate impact report now compares a pull request's merge commit with that commit's first parent, the tip of the branch it merges into. It used the event's `pull_request.base.sha`, which lags that branch once it moves on, so newer merges to `main` were counted as the pull request's impact.
+- - Fixed Universal Credit deductions and benefit cap reductions to report what the award actually loses under a protected minimum floor, so the components sum to the reduction applied instead of over-reporting it. Where the floor binds, deductions are met first and the cap reduction absorbs the rest, however heavily the award is capped.
+  - Added `uc_benefit_cap_reduction_after_floor`, the benefit cap reduction applied to a Universal Credit award after the protected floor and bounded by the award, leaving the regulation 81 amount `uc_benefit_cap_reduction` gross.
+  - Fixed a protected floor above 1 adding money to Universal Credit awards, by clamping the permitted reduction at zero.
+  - Fixed Universal Credit deductions applying to benefit units that do not claim Universal Credit. Deductions and the applied cap reduction use the same claim test as the award (`claims_universal_credit`), so a claim made when legacy benefits close keeps both.
+  - Corrected the effective date of the 25% deductions cap to 12 April 2021, and the one-penny minimum payable citation to Schedule 6, paragraph 3(1)(a) of SI 2013/380.
+
+
 ## [2.141.2] - 2026-10-20
 
 ### Fixed

{policyengine_uk-2.141.2 → policyengine_uk-2.141.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: policyengine-uk
-Version: 2.141.2
+Version: 2.141.4
 Summary: PolicyEngine tax and benefit system for the UK.
 Project-URL: Homepage, https://github.com/PolicyEngine/policyengine-uk
 Project-URL: Repository, https://github.com/PolicyEngine/policyengine-uk

{policyengine_uk-2.141.2 → policyengine_uk-2.141.4}/policyengine_uk/parameters/gov/dwp/universal_credit/deductions/cap.yaml

@@ -1,8 +1,8 @@
-description: Maximum total deductions from a Universal Credit award, as a fraction of the standard allowance. Schedule 6 paragraph 4(1) of SI 2013/380 sets a statutory ceiling of 40%; within it, DWP sets the operational cap administratively - 30% from October 2019 (Budget 2018), 25% from April 2021 (announced for October 2021 at Budget 2020, brought forward at Budget 2021), and 15% (the Fair Repayment Rate) from 30 April 2025, which required no legislative change. Last resort deductions (housing and fuel arrears hardship deductions) and child maintenance deductions - separate categories in DWP guidance - may each exceed the cap (Explanatory Memorandum to SI 2025/387, paragraphs 5.10 to 5.15).
+description: Maximum total deductions from a Universal Credit award, as a fraction of the standard allowance. Schedule 6 paragraph 4(1) of SI 2013/380 sets a statutory ceiling of 40%; within it, DWP sets the operational cap administratively - 30% from October 2019 (Budget 2018), 25% from 12 April 2021 (announced for October 2021 at Budget 2020, brought forward at Budget 2021; DWP Annual Report and Accounts 2020-21), and 15% (the Fair Repayment Rate) from 30 April 2025, which required no legislative change. Last resort deductions (housing and fuel arrears hardship deductions) and child maintenance deductions - separate categories in DWP guidance - may each exceed the cap (Explanatory Memorandum to SI 2025/387, paragraphs 5.10 to 5.15).
 values:
   2015-04-01: 0.4
   2019-10-01: 0.3
-  2021-04-01: 0.25
+  2021-04-12: 0.25
   2025-04-30: 0.15
 metadata:
   label: UC deductions cap
@@ -23,5 +23,7 @@ metadata:
       href: https://assets.publishing.service.gov.uk/media/5e68d0dce90e070ac74f08ea/Budget_2020_Web_Accessible_Complete.pdf#page=73
     - title: HM Treasury, Budget 2021 (25% cap brought forward to April 2021)
       href: https://www.gov.uk/government/publications/budget-2021-documents/budget-2021-html
+    - title: DWP Annual Report and Accounts 2020-21, p.57 (cap reduced from 30% to 25% from 12 April 2021)
+      href: https://assets.publishing.service.gov.uk/media/60fa97498fa8f5043411d83d/dwp-annual-report-and-accounts-2020-2021-web-ready.pdf#page=58
     - title: Universal Credit change brings £420 boost to over a million households (Fair Repayment Rate, 30 April 2025)
       href: https://www.gov.uk/government/news/universal-credit-change-brings-420-boost-to-over-a-million-households

policyengine_uk-2.141.4/policyengine_uk/parameters/gov/dwp/universal_credit/deductions/minimum_payable.yaml

@@ -0,0 +1,10 @@
+description: Minimum Universal Credit payable after deductions, per assessment period. Schedule 6, paragraph 3(1)(a) of SI 2013/380 provides that deductions must not reduce the amount payable to the claimant below one penny.
+values:
+  2015-04-01: 0.01
+metadata:
+  label: UC minimum payable after deductions
+  unit: currency-GBP
+  period: month
+  reference:
+    - title: SI 2013/380, Schedule 6, paragraph 3(1)(a) (deductions must leave at least one penny payable)
+      href: https://www.legislation.gov.uk/uksi/2013/380/schedule/6/paragraph/3

policyengine_uk-2.141.4/policyengine_uk/parameters/gov/dwp/universal_credit/deductions/protected_floor.yaml

@@ -0,0 +1,10 @@
+description: Protected minimum floor in Universal Credit, as a fraction of the standard allowance. When above zero, combined deductions and benefit cap reductions are limited to (1 - floor) times the standard allowance, following JRF's proposal design (their worked example limits the reduction itself to 15% of the standard allowance). Zero - the value under current law, which has no such floor - leaves reductions unlimited. Setting 0.85 models JRF's proposal; this reform-lever parameter encodes no current-law value other than zero. Where the current-law split already fits inside the allowance nothing changes; where it does not, deductions are met first, up to the allowance, and the benefit cap reduction absorbs the rest (uc_benefit_cap_reduction_after_floor). JRF fixes the combined limit, not the priority between the two, so this ordering is a modeling choice; it reproduces JRF's September 2026 example, where a 15% deduction survives and the cap reduction goes. Where deductions do exceed it, the modeled floor binds on all of them, including the above-cap excess that current law exempts from the deductions cap (last resort and child maintenance deductions) - JRF's briefing does not state whether their floor exempts those categories, and its example involves only cappable deductions and the benefit cap, so treating the floor as binding on everything is a modeling choice rather than a stated feature of the proposal.
+values:
+  2015-04-01: 0
+metadata:
+  label: UC protected minimum floor
+  unit: /1
+  period: year
+  reference:
+    - title: JRF, A protected minimum floor in Universal Credit to cut deep child poverty (11 September 2026, replacing the 9 October 2025 briefing; proposal design source, not current law)
+      href: https://www.jrf.org.uk/social-security/a-protected-minimum-floor-in-universal-credit-to-cut-deep-child-poverty

{policyengine_uk-2.141.2 → policyengine_uk-2.141.4}/policyengine_uk/reforms/policyengine/adjust_budgets.py

@@ -59,9 +59,24 @@ def adjust_budget(baseline_parameter, parameter, budget_variable):
         def apply(self):
             simulation = self.simulation
 
+            # Read every year's allocation before writing any. Each write is
+            # an input that carries over to later years without their own
+            # input, so reading a later year after writing an earlier one
+            # would stack the earlier year's change on top of its own.
+            spending_by_year = {
+                time_period: simulation.calculate(budget_variable, time_period)
+                for time_period in change_by_year
+            }
+
             for time_period, budget_change in change_by_year.items():
-                spending = simulation.calculate(budget_variable, time_period)
-                relative_increase = budget_change / (spending.sum() / 1e9)
+                spending = spending_by_year[time_period]
+                total_spending = spending.sum() / 1e9
+                if total_spending == 0:
+                    # Nothing is allocated in this year, so there is no
+                    # allocation to scale. Dividing by zero would write NaN
+                    # (rejected by set_input) or infinite spending.
+                    continue
+                relative_increase = budget_change / total_spending
 
                 simulation.set_input(
                     budget_variable,

policyengine_uk-2.141.4/policyengine_uk/tests/code_health/test_aggregate_impact_workflow.py

@@ -0,0 +1,361 @@
+"""What the aggregate-impact job compares, and what may leave it.
+
+Comparison base. For a pull request the head is GitHub's merge commit and
+the base is that commit's first parent, so the report is exactly what
+merging would change. The event's ``pull_request.base.sha`` lags the base
+branch once the branch moves on, and a report against it counted main's
+newer merges as the pull request's impact (#2516's took in 26 commits from
+main). These tests run the workflow's own step scripts on real histories,
+with the head fetched as actions/checkout fetches it at the workflow's
+fetch depth, and hold the job to:
+
+1. The base is the merge commit's first parent for every shape of history,
+   so no commit of the base branch is counted as the pull request's.
+2. A head that is not a merge of two commits fails the job with an error
+   and sets no base.
+3. No step reads ``pull_request.base.sha``, and the base checkout uses the
+   base the job chose.
+4. A manual dispatch compares the commits it names, as before.
+
+Data protection. Only aggregates may leave the job. The certified dataset
+is licensed survey microdata. The measurement keeps household-level detail
+for the decile comparison under ``private/``; these tests fail if the
+workflow could publish it, or could put the dataset where other workflows
+can read it.
+"""
+
+import json
+import os
+import re
+import subprocess
+import tempfile
+from pathlib import Path
+
+import numpy as np
+import pytest
+import yaml
+from hypothesis import HealthCheck, given, settings
+from hypothesis import strategies as st
+
+from policyengine_uk.utils.aggregate_impact.measure import (
+    HOUSEHOLDS_FILE,
+    PRIVATE_DIRECTORY,
+    read_result,
+    write_result,
+)
+
+REPO = Path(__file__).resolve().parents[3]
+WORKFLOW = REPO / ".github" / "workflows" / "aggregate-impact.yaml"
+
+if not WORKFLOW.exists():
+    pytest.skip(
+        "the .github folder is not part of an installed package",
+        allow_module_level=True,
+    )
+ALLOWED_UPLOAD_PATHS = {"report"}
+
+
+def steps():
+    workflow = yaml.safe_load(WORKFLOW.read_text())
+    return [step for job in workflow["jobs"].values() for step in job["steps"]]
+
+
+def test_only_the_aggregate_report_is_uploaded():
+    uploads = [s for s in steps() if "upload-artifact" in str(s.get("uses", ""))]
+    assert uploads, "the report should be uploaded"
+    for step in uploads:
+        paths = {p.strip() for p in str(step["with"]["path"]).splitlines() if p.strip()}
+        assert paths <= ALLOWED_UPLOAD_PATHS, paths
+
+
+def test_the_dataset_is_never_cached():
+    for step in steps():
+        assert "actions/cache" not in str(step.get("uses", "")), step.get("name")
+
+
+def test_nothing_private_is_copied_into_the_report():
+    text = WORKFLOW.read_text()
+    copies = [
+        line.strip() for line in text.splitlines() if line.strip().startswith("cp ")
+    ]
+    for line in copies:
+        if "report/" in line:
+            assert line.split()[1].endswith("result.json"), line
+    assert f"{PRIVATE_DIRECTORY}/" not in "\n".join(copies)
+    assert HOUSEHOLDS_FILE not in "\n".join(copies)
+
+
+def test_the_job_runs_both_sides_itself():
+    workflow = yaml.safe_load(WORKFLOW.read_text())
+    assert list(workflow["jobs"]) == ["report"], (
+        "base and head must be measured in one job, so that household detail "
+        "never has to travel between jobs as an artifact"
+    )
+    assert not [s for s in steps() if "download-artifact" in str(s.get("uses", ""))]
+
+
+def test_household_detail_is_written_only_under_private(tmp_path):
+    households = {
+        "2026": {
+            "household_id": np.arange(5),
+            "household_weight": np.ones(5),
+            "household_count_people": np.ones(5),
+            "decile": np.arange(5),
+            "income": np.linspace(1, 2, 5),
+        }
+    }
+    write_result(tmp_path, {"status": "ok", "metrics": []}, households)
+    top_level = sorted(p.name for p in tmp_path.iterdir())
+    assert top_level == [PRIVATE_DIRECTORY, "result.json"]
+    assert (tmp_path / PRIVATE_DIRECTORY / HOUSEHOLDS_FILE).exists()
+    result, loaded = read_result(tmp_path)
+    assert json.loads((tmp_path / "result.json").read_text()) == result
+    assert np.array_equal(loaded["2026"]["income"], households["2026"]["income"])
+
+
+def test_a_failed_run_always_replaces_an_earlier_comment():
+    """Even a run that failed before the comparison posts a failing comment."""
+    post = next(s for s in steps() if s.get("name", "").startswith("Post or update"))
+    assert post["if"] == "always() && github.event_name == 'pull_request'"
+    assert "if [ ! -s report/comment.md ]" in post["run"]
+    assert "FAIL" in post["run"]
+
+
+# The comparison base.
+
+GIT_ENV = {
+    **os.environ,
+    "GIT_CONFIG_GLOBAL": os.devnull,
+    "GIT_CONFIG_NOSYSTEM": "1",
+    "GIT_AUTHOR_NAME": "t",
+    "GIT_AUTHOR_EMAIL": "t@example.com",
+    "GIT_COMMITTER_NAME": "t",
+    "GIT_COMMITTER_EMAIL": "t@example.com",
+}
+SHA = "0123456789abcdef0123456789abcdef01234567"
+
+
+def step_named(name):
+    return next(s for s in steps() if s.get("name") == name)
+
+
+def git(repo, *args):
+    return subprocess.run(
+        ["git", "-C", str(repo), *args],
+        check=True,
+        capture_output=True,
+        text=True,
+        env=GIT_ENV,
+    ).stdout.strip()
+
+
+def run_step(name, workspace, **env):
+    """Run a step's script in ``workspace`` as Actions runs it.
+
+    Each variable in the step's ``env`` is set, empty unless given, as an
+    expression with no value is. Returns the process and the outputs the
+    step wrote to ``GITHUB_OUTPUT``.
+    """
+    step = step_named(name)
+    outputs = Path(workspace) / "github_output"
+    outputs.write_text("")
+    variables = {key: "" for key in step.get("env", {})}
+    variables.update(env)
+    process = subprocess.run(
+        ["bash", "--noprofile", "--norc", "-eo", "pipefail", "-c", step["run"]],
+        cwd=workspace,
+        env={**GIT_ENV, **variables, "GITHUB_OUTPUT": str(outputs)},
+        capture_output=True,
+        text=True,
+    )
+    written = dict(line.split("=", 1) for line in outputs.read_text().splitlines())
+    return process, written
+
+
+class Origin:
+    """A repository on GitHub's side, holding commits made directly."""
+
+    def __init__(self, path):
+        path.mkdir(parents=True)
+        git(path, "init", "-q")
+        # actions/checkout fetches the head by its SHA.
+        git(path, "config", "uploadpack.allowAnySHA1InWant", "true")
+        self.path = path
+        self.tree = git(path, "write-tree")
+        self.made = 0
+
+    def commit(self, *parents):
+        self.made += 1
+        flags = [flag for parent in parents for flag in ("-p", parent)]
+        return git(
+            self.path, "commit-tree", self.tree, *flags, "-m", f"commit {self.made}"
+        )
+
+    def attributed(self, base, head):
+        """The commits a comparison of ``base`` with ``head`` counts."""
+        return set(git(self.path, "rev-list", f"{base}..{head}").split())
+
+
+def check_out_the_head(workspace, origin, sha):
+    """Fetch ``sha`` into ``workspace/head`` as the workflow's checkout does."""
+    depth = step_named("Check out the head")["with"].get("fetch-depth", 1)
+    head = Path(workspace) / "head"
+    head.mkdir(parents=True)
+    git(head, "init", "-q")
+    git(head, "fetch", "-q", "--no-tags", f"--depth={depth}", origin.path.as_uri(), sha)
+    git(head, "checkout", "-q", "--detach", sha)
+
+
+def choose_the_base(workspace, origin, merge):
+    check_out_the_head(workspace, origin, merge)
+    return run_step("Choose the base", workspace, EVENT="pull_request")
+
+
+def test_a_pull_request_is_compared_with_its_merge_commits_first_parent(tmp_path):
+    origin = Origin(tmp_path / "origin")
+    # The pull request branches from main at `forked`. The event's
+    # pull_request.base.sha can still name it after main has moved on.
+    forked = origin.commit(origin.commit())
+    change = origin.commit(forked)
+    # Main moves on: two later merges.
+    tip = origin.commit(origin.commit(forked))
+    # GitHub's merge commit for the run: main's tip, then the pull request.
+    merge = origin.commit(tip, change)
+
+    process, outputs = choose_the_base(tmp_path / "runner", origin, merge)
+
+    assert process.returncode == 0, process.stdout + process.stderr
+    assert outputs == {"sha": tip}
+    assert origin.attributed(outputs["sha"], merge) == {merge, change}
+    # Against `forked`, main's two later merges counted as the pull request's.
+    assert len(origin.attributed(forked, merge) - {merge, change}) == 2
+
+
+@pytest.mark.parametrize("parents", [0, 1, 3])
+def test_a_head_that_does_not_merge_two_commits_has_no_base(tmp_path, parents):
+    origin = Origin(tmp_path / "origin")
+    head = origin.commit(*[origin.commit() for _ in range(parents)])
+
+    process, outputs = choose_the_base(tmp_path / "runner", origin, head)
+
+    assert process.returncode != 0
+    assert f"::error::The head {head} has {parents} parents, not 2" in process.stdout
+    assert outputs == {}
+
+
+def test_the_events_base_sha_is_not_the_comparison_base():
+    expressions = re.findall(r"\$\{\{(.*?)\}\}", WORKFLOW.read_text(), re.DOTALL)
+    assert expressions
+    assert not [e for e in expressions if "pull_request.base.sha" in e]
+    names = [s.get("name") for s in steps()]
+    order = [
+        names.index("Choose the commits"),
+        names.index("Check out the head"),
+        names.index("Choose the base"),
+        names.index("Check out the base"),
+    ]
+    assert order == sorted(order)
+    head = step_named("Check out the head")["with"]
+    assert head["ref"] == "${{ steps.commits.outputs.head }}"
+    choose = step_named("Choose the base")
+    assert choose["id"] == "base"
+    assert choose["env"]["BASE"] == "${{ steps.commits.outputs.base }}"
+    assert step_named("Check out the base")["with"]["ref"] == (
+        "${{ steps.base.outputs.sha }}"
+    )
+
+
+def test_a_pull_request_head_is_its_merge_commit(tmp_path):
+    process, outputs = run_step(
+        "Choose the commits",
+        tmp_path,
+        EVENT="pull_request",
+        GITHUB_SHA=SHA,
+        PR_BASE_REF="main",
+        PR_NUMBER="2516",
+    )
+    assert process.returncode == 0, process.stdout + process.stderr
+    assert outputs == {
+        "base": "",
+        "head": SHA,
+        "base_name": "main",
+        "head_name": "#2516 merged into main",
+    }
+
+
+@pytest.mark.parametrize(
+    "inputs, expected",
+    [
+        (
+            {},
+            {"base": "main", "head": SHA, "base_name": "main", "head_name": "dev"},
+        ),
+        (
+            {"INPUT_BASE": "2.139.0", "INPUT_HEAD": "fix"},
+            {
+                "base": "2.139.0",
+                "head": "fix",
+                "base_name": "2.139.0",
+                "head_name": "fix",
+            },
+        ),
+    ],
+)
+def test_a_dispatch_compares_the_commits_it_names(tmp_path, inputs, expected):
+    process, outputs = run_step(
+        "Choose the commits",
+        tmp_path,
+        EVENT="workflow_dispatch",
+        GITHUB_SHA=SHA,
+        GITHUB_REF_NAME="dev",
+        **inputs,
+    )
+    assert process.returncode == 0, process.stdout + process.stderr
+    assert outputs == expected
+    # The base passes through, with no head to read it from.
+    process, outputs = run_step(
+        "Choose the base", tmp_path, EVENT="workflow_dispatch", BASE=expected["base"]
+    )
+    assert process.returncode == 0, process.stdout + process.stderr
+    assert outputs == {"sha": expected["base"]}
+
+
+@settings(
+    max_examples=25,
+    deadline=None,
+    derandomize=True,
+    suppress_health_check=[HealthCheck.too_slow],
+)
+@given(
+    before=st.integers(0, 2),
+    events=st.lists(st.sampled_from(["main", "pull request", "update"]), max_size=8),
+)
+def test_no_commit_of_the_base_branch_counts_as_the_pull_requests(before, events):
+    """Invariant 1, for any history: main's commits before and after the
+    fork, the pull request's commits, and merges of main into the pull
+    request ("Update branch")."""
+    with tempfile.TemporaryDirectory() as directory:
+        origin = Origin(Path(directory) / "origin")
+        main = origin.commit()
+        for _ in range(before):
+            main = origin.commit(main)
+        pull_request = origin.commit(main)
+        own = {pull_request}
+        merged = main
+        for event in events:
+            if event == "main":
+                main = origin.commit(main)
+            elif event == "pull request":
+                pull_request = origin.commit(pull_request)
+                own.add(pull_request)
+            elif main != merged:
+                pull_request = origin.commit(pull_request, main)
+                own.add(pull_request)
+                merged = main
+        merge = origin.commit(main, pull_request)
+
+        process, outputs = choose_the_base(Path(directory) / "runner", origin, merge)
+
+        assert process.returncode == 0, process.stdout + process.stderr
+        assert outputs == {"sha": main}
+        assert origin.attributed(outputs["sha"], merge) == own | {merge}

{policyengine_uk-2.141.2 → policyengine_uk-2.141.4}/policyengine_uk/tests/policy/baseline/finance/benefit/family/universal_credit/uc_deductions.yaml

@@ -107,7 +107,8 @@
       household:
         members: person
   output:
-    # Schedule 6 of SI 2013/380: the award cannot be deducted below one
+    # Schedule 6, paragraph 3(1)(a) of SI 2013/380: the award cannot be
+    # deducted below one
     # penny per assessment period (12p per year).
     uc_deductions: 499.88
     universal_credit: 0.12
@@ -132,3 +133,49 @@
   output:
     uc_deductions: 0
     universal_credit: 6_000
+
+- name: A claim made at legacy closure keeps the benefit cap and deductions
+  # A couple on Child Tax Credit moved off legacy benefits that would not
+  # otherwise claim Universal Credit, but claims on its migration notice
+  # (SI 2014/1230 reg 44). The award is still capped (SI 2013/376 reg 81)
+  # and deductions still apply, so both components use the award's
+  # claims_universal_credit test rather than would_claim_uc.
+  period: 2025
+  absolute_error_margin: 0.01
+  input:
+    people:
+      adult_1:
+        age: 35
+        is_claimant_or_partner: true
+        child_tax_credit_reported: 3_000
+      adult_2:
+        age: 33
+        is_claimant_or_partner: true
+      child_1:
+        age: 13
+      child_2:
+        age: 11
+      child_3:
+        age: 9
+      child_4:
+        age: 7
+    benunits:
+      benunit:
+        members: [adult_1, adult_2, child_1, child_2, child_3, child_4]
+        would_claim_uc: false
+        would_claim_uc_at_legacy_closure: true
+        uc_latent_deduction_rate: 0.25
+        uc_deduction_combination: ADVANCE_ONLY
+    households:
+      household:
+        members: [adult_1, adult_2, child_1, child_2, child_3, child_4]
+        rent: 30_000
+        tenure_type: RENT_FROM_COUNCIL
+        region: LONDON
+  output:
+    claims_universal_credit: true
+    universal_credit_pre_benefit_cap: 48_632.64
+    uc_benefit_cap_reduction: 27_355.24
+    uc_benefit_cap_reduction_after_floor: 27_355.24
+    uc_deductions: 1_130.58
+    universal_credit: 20_146.82