perf(plan): stop deep-copying the export window list on every optimise_export call

optimise_export deep-copied the whole export window list on entry - every window
dict, on every one of its ~1000 calls per plan. On the heaviest benchmark
scenario that was 2.5 million deepcopy calls and the largest single block of
copying left in a plan.

It never needed one. Nothing in optimise_export writes to a window dict; the only
write anywhere on this path is the trial start, and _prepare_export already
applies that copy-on-write, taking its own list and replacing the single window
it changes with dict(window, start=start). The list is still copied, shallowly,
so a caller cannot reorder it underneath a batch that has not flushed yet.

test_optimise_export_copy pins both halves: that no deep copy is taken, and that
the caller's window dicts come back untouched - the guarantee the deepcopy was
providing, now provided by _prepare_export. Verified by making _prepare_export
write the start in place instead, which corrupts the caller's window from 720 to
835 and fails the second test. That is the same defect the copy-on-write was
introduced to fix, so it is now pinned rather than left to the next reader.

Also fixes coverage/run_random_profile, which pointed at random_scenarios.yaml
while run_random uses cases/random_scenarios.yaml. Those were different files, so
every profile was taken against different scenarios from every benchmark - and
since the former was never committed, the script could not run at all on a fresh
clone. The stale local copy is deleted.

Plans are unchanged: 320 fields across all 20 scenarios, zero mismatches, and the
full suite of 215 tests passes.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: springfall2008

apps/predbat/plan.py

@@ -2147,7 +2147,12 @@ def optimise_export(self, window_n, record_charge_windows, try_charge_limit, cha
         best_carbon = 0
         this_export_limit = 100.0
         window = export_window[window_n]
-        try_export_window = copy.deepcopy(export_window)
+        # A shallow copy is enough: nothing here writes to a window dict, and the one write that does
+        # happen downstream - the trial start - is applied copy-on-write by _prepare_export, which
+        # takes its own list and replaces that single window with dict(window, start=start). The list
+        # is still copied so a caller cannot reorder it underneath a batch that has not flushed yet.
+        # Deep-copying every window dict on entry was the largest block of copying in a plan.
+        try_export_window = list(export_window)
         try_export = list(export_limit)
         best_start = window["start"]
         best_size = window["end"] - best_start

apps/predbat/tests/test_optimise_export_copy.py

@@ -0,0 +1,111 @@
+# -----------------------------------------------------------------------------
+# Predbat Home Battery System
+# Copyright Trefor Southwell 2026 - All Rights Reserved
+# This application maybe used for personal use only and not for commercial use
+# -----------------------------------------------------------------------------
+# fmt off
+# pylint: disable=consider-using-f-string
+# pylint: disable=line-too-long
+# pylint: disable=attribute-defined-outside-init
+"""Tests for how optimise_export copies the export window list it is given.
+
+optimise_export took a deepcopy of the whole export window list on entry - every window dict, on
+every call - which on the heaviest benchmark scenario was 2.5 million deepcopy calls and the single
+largest block of copying in a plan.
+
+It does not need one. The trial start is the only thing written, and _prepare_export already applies
+it copy-on-write: it takes its own list and replaces the one window it changes with dict(window,
+start=start). Nothing in optimise_export writes to a window dict at all, so a shallow list copy is
+enough to keep the caller from reordering the list underneath a pending batch.
+
+Both halves are pinned here: that no deep copy is taken, and that the caller's window dicts still
+come back untouched - the guarantee the deepcopy was there to provide.
+"""
+from tests.test_export_commitment import setup_single_export_window
+
+
+class CountingWindow(dict):
+    """An export window that records how many times it has been deep-copied"""
+
+    deepcopy_count = 0
+
+    def __deepcopy__(self, memo):
+        """Record the copy and return an independent duplicate"""
+        CountingWindow.deepcopy_count += 1
+        duplicate = CountingWindow(self)
+        memo[id(self)] = duplicate
+        return duplicate
+
+
+def run_optimise_export_copy_tests(my_predbat):
+    """Run the optimise_export window copying tests"""
+    failed = False
+    failed |= test_optimise_export_does_not_deepcopy_the_windows(my_predbat)
+    failed |= test_optimise_export_leaves_the_callers_windows_untouched(my_predbat)
+    return failed
+
+
+def build_windows(my_predbat):
+    """Set up a single-export-window scenario whose windows count their own deep copies"""
+    export_window_best, record_export_windows, end_record = setup_single_export_window(my_predbat)
+    windows = [CountingWindow(window) for window in export_window_best]
+    return windows, record_export_windows, end_record
+
+
+def test_optimise_export_does_not_deepcopy_the_windows(my_predbat):
+    """The export window list is copied shallowly, so the window dicts are not duplicated"""
+    print("**** test_optimise_export_does_not_deepcopy_the_windows ****")
+    failed = False
+
+    windows, record_export_windows, end_record = build_windows(my_predbat)
+    my_predbat.export_window_best = windows
+    my_predbat.charge_window_best = []
+    my_predbat.charge_limit_best = []
+
+    CountingWindow.deepcopy_count = 0
+    my_predbat.optimise_export(0, record_export_windows, [], [], windows, [0.0], end_record=end_record)
+
+    if CountingWindow.deepcopy_count != 0:
+        print("ERROR: optimise_export deep-copied the export windows {} times".format(CountingWindow.deepcopy_count))
+        failed = True
+
+    my_predbat.export_window_best = []
+    if not failed:
+        print("PASS")
+    return failed
+
+
+def test_optimise_export_leaves_the_callers_windows_untouched(my_predbat):
+    """The caller's window dicts must come back exactly as they went in.
+
+    This is what the deepcopy was defending. _prepare_export now applies the trial start to its own
+    copy instead, so if that ever reverts to an in-place write this fails rather than silently
+    corrupting every other trial sharing the list.
+    """
+    print("**** test_optimise_export_leaves_the_callers_windows_untouched ****")
+    failed = False
+
+    windows, record_export_windows, end_record = build_windows(my_predbat)
+    my_predbat.export_window_best = windows
+    my_predbat.charge_window_best = []
+    my_predbat.charge_limit_best = []
+
+    before = [dict(window) for window in windows]
+    identities = [id(window) for window in windows]
+
+    my_predbat.optimise_export(0, record_export_windows, [], [], windows, [0.0], end_record=end_record)
+
+    after = [dict(window) for window in windows]
+    if after != before:
+        print("ERROR: optimise_export modified the caller's windows")
+        print("  before {}".format(before))
+        print("  after  {}".format(after))
+        failed = True
+    if [id(window) for window in windows] != identities:
+        print("ERROR: optimise_export replaced entries in the caller's window list")
+        failed = True
+
+    my_predbat.export_window_best = []
+    if not failed:
+        print("PASS")
+    return failed

apps/predbat/unit_test.py

@@ -56,6 +56,7 @@
 from tests.test_plan_tiebreak import run_plan_tiebreak_tests
 from tests.test_plan_preclip import run_plan_preclip_tests
 from tests.test_export_commitment import run_export_commitment_tests
+from tests.test_optimise_export_copy import run_optimise_export_copy_tests
 from tests.test_energydataservice import run_energydataservice_tests
 from tests.test_iboost import run_iboost_smart_tests
 from tests.test_alert_feed import test_alert_feed
@@ -435,6 +436,7 @@ def main():
         ("hit_charge_cache", run_hit_charge_cache_tests, "Hit charge window cache tests", False),
         ("window_selection", run_window_selection_tests, "Window selection picker tests", False),
         ("kernel_static_cache", run_kernel_static_cache_tests, "Kernel static context cache tests", False),
+        ("optimise_export_copy", run_optimise_export_copy_tests, "Optimise export window copying tests", False),
         ("inverter_multi", run_inverter_multi_tests, "Inverter multi tests", False),
         ("octopus_free", test_octopus_free, "Octopus free electricity tests", False),
         ("battery_curve_keys", run_battery_curve_keys_tests, "Battery curve keys tests", False),

coverage/run_random_profile

@@ -1,2 +1,2 @@
 source setup.csh
-python3 ../apps/predbat/unit_test.py --random-profile --random-template cases/predbat_debug_agile1.yaml --random-scenarios random_scenarios.yaml --random-scenario 0 --random-profile-sort tottime --random-profile-lines 500 2>&1 | tee profile_cprofile.log
+python3 ../apps/predbat/unit_test.py --random-profile --random-template cases/predbat_debug_agile1.yaml --random-scenarios cases/random_scenarios.yaml --random-scenario 0 --random-profile-sort tottime --random-profile-lines 500 2>&1 | tee profile_cprofile.log