From f8ee7f2309296b27109ab3bf5415556d01c4358d Mon Sep 17 00:00:00 2001
From: Rob Aldred <rob@residently.com>
Date: Mon, 2 Feb 2026 23:28:22 +0000
Subject: [PATCH 01/12] Add PersistentStore base class for JSON file
 persistence

---
 apps/predbat/persistent_store.py | 189 +++++++++++++++++++++++++++++++
 1 file changed, 189 insertions(+)
 create mode 100644 apps/predbat/persistent_store.py

diff --git a/apps/predbat/persistent_store.py b/apps/predbat/persistent_store.py
new file mode 100644
index 000000000..567011904
--- /dev/null
+++ b/apps/predbat/persistent_store.py
@@ -0,0 +1,189 @@
+# -----------------------------------------------------------------------------
+# 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
+
+"""
+Base class for persistent JSON file storage with backup and cleanup.
+Provides common functionality for components needing to store state across restarts.
+"""
+
+import json
+import os
+from datetime import datetime, timedelta
+from pathlib import Path
+
+
+class PersistentStore:
+    """
+    Abstract base class for persistent JSON file storage.
+    Handles load/save with backup, cleanup of old files, and automatic timestamping.
+    """
+
+    def __init__(self, base):
+        """Initialize with reference to base PredBat instance"""
+        self.base = base
+        self.log = base.log
+
+    def load(self, filepath):
+        """
+        Load data from JSON file with automatic backup restoration on corruption.
+        
+        Args:
+            filepath: Path to JSON file to load
+            
+        Returns:
+            Loaded data dict or None if file doesn't exist or is corrupted
+        """
+        try:
+            if not os.path.exists(filepath):
+                return None
+                
+            with open(filepath, 'r') as f:
+                data = json.load(f)
+                return data
+                
+        except (json.JSONDecodeError, IOError) as e:
+            self.log(f"Warn: Failed to load {filepath}: {e}")
+            
+            # Try to restore from backup
+            backup_path = filepath + '.bak'
+            if os.path.exists(backup_path):
+                try:
+                    self.log(f"Warn: Attempting to restore from backup: {backup_path}")
+                    with open(backup_path, 'r') as f:
+                        data = json.load(f)
+                    self.log(f"Warn: Successfully restored from backup")
+                    return data
+                except (json.JSONDecodeError, IOError) as e2:
+                    self.log(f"Error: Backup restoration failed: {e2}")
+            
+            return None
+
+    def save(self, filepath, data, backup=True):
+        """
+        Save data to JSON file with automatic backup and timestamp.
+        
+        Args:
+            filepath: Path to JSON file to save
+            data: Dict to save (will add last_updated timestamp)
+            backup: Whether to backup existing file before overwrite
+            
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            # Add timestamp
+            data['last_updated'] = datetime.now().astimezone().isoformat()
+            
+            # Create directory if needed
+            os.makedirs(os.path.dirname(filepath), exist_ok=True)
+            
+            # Backup existing file if requested
+            if backup and os.path.exists(filepath):
+                self.backup_file(filepath)
+                
+            # Write new file
+            with open(filepath, 'w') as f:
+                json.dump(data, f, indent=2)
+                
+            # Cleanup old backups
+            self.cleanup_backups(filepath)
+            
+            return True
+            
+        except (IOError, OSError) as e:
+            self.log(f"Error: Failed to save {filepath}: {e}")
+            return False
+
+    def backup_file(self, filepath):
+        """
+        Create backup copy of file.
+        
+        Args:
+            filepath: Path to file to backup
+        """
+        try:
+            backup_path = filepath + '.bak'
+            if os.path.exists(filepath):
+                import shutil
+                shutil.copy2(filepath, backup_path)
+        except (IOError, OSError) as e:
+            self.log(f"Warn: Failed to backup {filepath}: {e}")
+
+    def cleanup_backups(self, filepath):
+        """
+        Remove backup files older than 1 day.
+        
+        Args:
+            filepath: Path to main file (will check for .bak file)
+        """
+        try:
+            backup_path = filepath + '.bak'
+            if os.path.exists(backup_path):
+                # Check file age
+                file_time = datetime.fromtimestamp(os.path.getmtime(backup_path))
+                age = datetime.now() - file_time
+                
+                if age > timedelta(days=1):
+                    os.remove(backup_path)
+                    self.log(f"Info: Cleaned up old backup: {backup_path}")
+                    
+        except (IOError, OSError) as e:
+            self.log(f"Warn: Failed to cleanup backup for {filepath}: {e}")
+
+    def cleanup(self, directory, pattern, retention_days):
+        """
+        Remove files matching pattern older than retention period.
+        
+        Args:
+            directory: Directory to search
+            pattern: Glob pattern for files to cleanup
+            retention_days: Number of days to retain files
+            
+        Returns:
+            Number of files removed
+        """
+        try:
+            if not os.path.exists(directory):
+                return 0
+                
+            path = Path(directory)
+            cutoff_time = datetime.now() - timedelta(days=retention_days)
+            removed_count = 0
+            
+            for file_path in path.glob(pattern):
+                try:
+                    file_time = datetime.fromtimestamp(file_path.stat().st_mtime)
+                    if file_time < cutoff_time:
+                        file_path.unlink()
+                        removed_count += 1
+                        self.log(f"Info: Cleaned up old file: {file_path}")
+                except (IOError, OSError) as e:
+                    self.log(f"Warn: Failed to remove {file_path}: {e}")
+                    
+            return removed_count
+            
+        except Exception as e:
+            self.log(f"Error: Cleanup failed for {directory}/{pattern}: {e}")
+            return 0
+
+    def get_last_updated(self, filepath):
+        """
+        Get last_updated timestamp from JSON file.
+        
+        Args:
+            filepath: Path to JSON file
+            
+        Returns:
+            ISO 8601 timestamp string or None
+        """
+        data = self.load(filepath)
+        if data and 'last_updated' in data:
+            return data['last_updated']
+        return None

From 3fafb8ce0371181c2067d272ba05dcc0321875a2 Mon Sep 17 00:00:00 2001
From: Rob Aldred <rob@residently.com>
Date: Mon, 2 Feb 2026 23:30:28 +0000
Subject: [PATCH 02/12] Add RateStore for persistent rate tracking with
 finalization

---
 apps/predbat/rate_store.py | 457 +++++++++++++++++++++++++++++++++++++
 1 file changed, 457 insertions(+)
 create mode 100644 apps/predbat/rate_store.py

diff --git a/apps/predbat/rate_store.py b/apps/predbat/rate_store.py
new file mode 100644
index 000000000..eff671272
--- /dev/null
+++ b/apps/predbat/rate_store.py
@@ -0,0 +1,457 @@
+# -----------------------------------------------------------------------------
+# 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
+
+"""
+Persistent storage for import and export rates with finalization logic.
+Stores rates at the time they are first retrieved and applies overrides separately,
+preventing retrospective changes to historical cost calculations.
+"""
+
+import os
+from datetime import datetime, timedelta
+from persistent_store import PersistentStore
+
+
+class RateStore(PersistentStore):
+    """
+    Manages persistent storage of energy rates with slot-based structure.
+    
+    Stores rates in 30-minute slots (configurable via plan_interval_minutes) with:
+    - initial: Base rate from API at first retrieval
+    - automatic: Override from external services (IOG, Axle, saving sessions) 
+    - manual: User override from manual selectors
+    - finalized: Lock flag set 5 minutes past slot start time
+    
+    File structure: predbat_save/rates_YYYY_MM_DD.json
+    """
+    
+    def __init__(self, base, save_dir="predbat_save"):
+        """
+        Initialize rate store.
+        
+        Args:
+            base: PredBat instance
+            save_dir: Directory for rate files (relative to workspace root)
+        """
+        super().__init__(base)
+        self.save_dir = save_dir
+        self.plan_interval_minutes = base.plan_interval_minutes
+        
+        # In-memory cache of loaded rate files
+        # Key: date string "YYYY-MM-DD", Value: rate data dict
+        self.rate_cache = {}
+        
+    def _get_filepath(self, date):
+        """
+        Get filepath for rate file for given date.
+        
+        Args:
+            date: datetime object
+            
+        Returns:
+            Full path string to rate JSON file
+        """
+        date_str = date.strftime("%Y_%m_%d")
+        filename = f"rates_{date_str}.json"
+        return os.path.join(self.save_dir, filename)
+        
+    def _get_date_key(self, date):
+        """Get cache key for date"""
+        return date.strftime("%Y-%m-%d")
+        
+    def _minutes_to_time(self, minutes):
+        """
+        Convert minute offset from midnight to HH:MM string.
+        
+        Args:
+            minutes: Minutes since midnight
+            
+        Returns:
+            Time string in format "HH:MM"
+        """
+        hours = int(minutes // 60)
+        mins = int(minutes % 60)
+        return f"{hours:02d}:{mins:02d}"
+        
+    def _time_to_minutes(self, time_str):
+        """
+        Convert HH:MM string to minute offset from midnight.
+        
+        Args:
+            time_str: Time in format "HH:MM"
+            
+        Returns:
+            Minutes since midnight as int
+        """
+        parts = time_str.split(':')
+        return int(parts[0]) * 60 + int(parts[1])
+        
+    def _get_slot_start(self, minutes):
+        """
+        Get slot start time for given minute offset.
+        Uses same calculation as output.py line 997.
+        
+        Args:
+            minutes: Minute offset from midnight
+            
+        Returns:
+            Slot start minute offset
+        """
+        return int(minutes / self.plan_interval_minutes) * self.plan_interval_minutes
+        
+    def _init_empty_structure(self):
+        """
+        Create empty rate data structure.
+        
+        Returns:
+            Dict with plan_interval_minutes and empty import/export rate dicts
+        """
+        return {
+            'plan_interval_minutes': self.plan_interval_minutes,
+            'rates_import': {},
+            'rates_export': {}
+        }
+        
+    def _init_empty_slot(self):
+        """
+        Create empty slot structure.
+        
+        Returns:
+            Dict with initial/automatic/manual/finalized fields
+        """
+        return {
+            'initial': None,
+            'automatic': None,
+            'manual': None,
+            'finalized': False
+        }
+        
+    def load_rates(self, date):
+        """
+        Load rate data for given date into cache.
+        
+        Args:
+            date: datetime object for date to load
+            
+        Returns:
+            Rate data dict or None if file doesn't exist
+        """
+        date_key = self._get_date_key(date)
+        
+        # Check if already cached
+        if date_key in self.rate_cache:
+            return self.rate_cache[date_key]
+            
+        # Load from file
+        filepath = self._get_filepath(date)
+        data = self.load(filepath)
+        
+        if data is None:
+            # Initialize empty structure
+            data = self._init_empty_structure()
+            
+        # Validate plan_interval_minutes matches
+        if 'plan_interval_minutes' in data:
+            if data['plan_interval_minutes'] != self.plan_interval_minutes:
+                self.log(f"Error: Rate file {filepath} has plan_interval_minutes={data['plan_interval_minutes']} but current config is {self.plan_interval_minutes}. Creating backup and starting fresh.")
+                # Backup old file
+                self.backup_file(filepath)
+                # Start with empty structure
+                data = self._init_empty_structure()
+        else:
+            # Old file format, add field
+            data['plan_interval_minutes'] = self.plan_interval_minutes
+            
+        # Ensure structure exists
+        if 'rates_import' not in data:
+            data['rates_import'] = {}
+        if 'rates_export' not in data:
+            data['rates_export'] = {}
+            
+        # Cache it
+        self.rate_cache[date_key] = data
+        
+        return data
+        
+    def save_rates(self, date):
+        """
+        Save rate data for given date from cache to file.
+        
+        Args:
+            date: datetime object for date to save
+            
+        Returns:
+            True if successful
+        """
+        date_key = self._get_date_key(date)
+        
+        if date_key not in self.rate_cache:
+            self.log(f"Warn: No rate data in cache for {date_key}")
+            return False
+            
+        data = self.rate_cache[date_key]
+        filepath = self._get_filepath(date)
+        
+        return self.save(filepath, data, backup=True)
+        
+    def write_base_rate(self, date, minute, rate_import, rate_export):
+        """
+        Write initial base rate for a slot (only if not already set).
+        This captures the rate at first retrieval from API.
+        
+        Args:
+            date: datetime object for the date
+            minute: Minute offset from midnight
+            rate_import: Import rate value
+            rate_export: Export rate value
+        """
+        # Load rate data
+        data = self.load_rates(date)
+        
+        # Get slot start
+        slot_start = self._get_slot_start(minute)
+        slot_time = self._minutes_to_time(slot_start)
+        
+        # Initialize slots if needed
+        if slot_time not in data['rates_import']:
+            data['rates_import'][slot_time] = self._init_empty_slot()
+        if slot_time not in data['rates_export']:
+            data['rates_export'][slot_time] = self._init_empty_slot()
+            
+        # Only write initial rate if not already set
+        if data['rates_import'][slot_time]['initial'] is None:
+            data['rates_import'][slot_time]['initial'] = rate_import
+            
+        if data['rates_export'][slot_time]['initial'] is None:
+            data['rates_export'][slot_time]['initial'] = rate_export
+            
+        # Save immediately
+        self.save_rates(date)
+        
+    def update_auto_override(self, date, minute, rate_import, rate_export, source):
+        """
+        Update automatic override rate for a slot (IOG, Axle, saving sessions).
+        Only updates non-finalized slots.
+        
+        Args:
+            date: datetime object for the date
+            minute: Minute offset from midnight
+            rate_import: Import rate value or None to clear
+            rate_export: Export rate value or None to clear
+            source: String identifying override source (e.g., "IOG", "Axle")
+        """
+        # Load rate data
+        data = self.load_rates(date)
+        
+        # Get slot start
+        slot_start = self._get_slot_start(minute)
+        slot_time = self._minutes_to_time(slot_start)
+        
+        # Initialize slots if needed
+        if slot_time not in data['rates_import']:
+            data['rates_import'][slot_time] = self._init_empty_slot()
+        if slot_time not in data['rates_export']:
+            data['rates_export'][slot_time] = self._init_empty_slot()
+            
+        # Check if slot is finalized
+        if data['rates_import'][slot_time]['finalized']:
+            # Don't modify finalized slots
+            return
+            
+        # Store override with source tracking
+        import_slot = data['rates_import'][slot_time]
+        export_slot = data['rates_export'][slot_time]
+        
+        if rate_import is not None:
+            import_slot['automatic'] = {
+                'rate': rate_import,
+                'source': source
+            }
+        else:
+            # Clear override
+            import_slot['automatic'] = None
+            
+        if rate_export is not None:
+            export_slot['automatic'] = {
+                'rate': rate_export,
+                'source': source
+            }
+        else:
+            # Clear override
+            export_slot['automatic'] = None
+            
+        # Save immediately
+        self.save_rates(date)
+        
+    def update_manual_override(self, date, minute, rate_import, rate_export):
+        """
+        Update manual override rate for a slot (from user selectors).
+        Only updates non-finalized slots.
+        
+        Args:
+            date: datetime object for the date
+            minute: Minute offset from midnight
+            rate_import: Import rate value or None to clear
+            rate_export: Export rate value or None to clear
+        """
+        # Load rate data
+        data = self.load_rates(date)
+        
+        # Get slot start
+        slot_start = self._get_slot_start(minute)
+        slot_time = self._minutes_to_time(slot_start)
+        
+        # Initialize slots if needed
+        if slot_time not in data['rates_import']:
+            data['rates_import'][slot_time] = self._init_empty_slot()
+        if slot_time not in data['rates_export']:
+            data['rates_export'][slot_time] = self._init_empty_slot()
+            
+        # Check if slot is finalized
+        if data['rates_import'][slot_time]['finalized']:
+            # Don't modify finalized slots
+            return
+            
+        # Store manual override
+        data['rates_import'][slot_time]['manual'] = rate_import
+        data['rates_export'][slot_time]['manual'] = rate_export
+        
+        # Save immediately
+        self.save_rates(date)
+        
+    def finalize_slots(self, date, current_minute):
+        """
+        Finalize all slots that have passed their start time by 5+ minutes.
+        Finalized slots cannot be modified by overrides.
+        
+        Args:
+            date: datetime object for the date
+            current_minute: Current minute offset from midnight
+            
+        Returns:
+            Number of slots finalized
+        """
+        # Load rate data
+        data = self.load_rates(date)
+        
+        finalized_count = 0
+        
+        # Process all slots
+        for slot_time in data['rates_import'].keys():
+            slot_minute = self._time_to_minutes(slot_time)
+            
+            # Check if slot should be finalized
+            # Finalize if current time is 5+ minutes past slot start
+            if current_minute >= slot_minute + 5:
+                if not data['rates_import'][slot_time]['finalized']:
+                    data['rates_import'][slot_time]['finalized'] = True
+                    data['rates_export'][slot_time]['finalized'] = True
+                    finalized_count += 1
+                    
+        if finalized_count > 0:
+            self.save_rates(date)
+            
+        return finalized_count
+        
+    def get_rate(self, date, minute, is_import=True):
+        """
+        Get effective rate for a given time.
+        Returns manual override > automatic override > initial rate > 0.
+        
+        Args:
+            date: datetime object for the date
+            minute: Minute offset from midnight
+            is_import: True for import rate, False for export rate
+            
+        Returns:
+            Rate value (float) or 0 if not found
+        """
+        # Load rate data
+        data = self.load_rates(date)
+        
+        # Get slot start
+        slot_start = self._get_slot_start(minute)
+        slot_time = self._minutes_to_time(slot_start)
+        
+        # Select import or export rates
+        rates = data['rates_import'] if is_import else data['rates_export']
+        
+        if slot_time not in rates:
+            return 0
+            
+        slot = rates[slot_time]
+        
+        # Priority: manual > automatic > initial > 0
+        if slot['manual'] is not None:
+            return slot['manual']
+            
+        if slot['automatic'] is not None:
+            # Handle dict format with source tracking
+            if isinstance(slot['automatic'], dict):
+                return slot['automatic']['rate']
+            return slot['automatic']
+            
+        if slot['initial'] is not None:
+            return slot['initial']
+            
+        return 0
+        
+    def get_automatic_rate(self, date, minute, is_import=True):
+        """
+        Get the automatic override rate (ignoring manual overrides).
+        Used for displaying what automatic systems are doing.
+        
+        Args:
+            date: datetime object for the date
+            minute: Minute offset from midnight
+            is_import: True for import rate, False for export rate
+            
+        Returns:
+            Rate value (float) or None if no automatic override
+        """
+        # Load rate data
+        data = self.load_rates(date)
+        
+        # Get slot start
+        slot_start = self._get_slot_start(minute)
+        slot_time = self._minutes_to_time(slot_start)
+        
+        # Select import or export rates
+        rates = data['rates_import'] if is_import else data['rates_export']
+        
+        if slot_time not in rates:
+            return None
+            
+        slot = rates[slot_time]
+        
+        # Return automatic override if set
+        if slot['automatic'] is not None:
+            # Handle dict format with source tracking
+            if isinstance(slot['automatic'], dict):
+                return slot['automatic']['rate']
+            return slot['automatic']
+            
+        # Fall back to initial rate
+        if slot['initial'] is not None:
+            return slot['initial']
+            
+        return None
+        
+    def cleanup_old_files(self, retention_days):
+        """
+        Remove rate files older than retention period.
+        
+        Args:
+            retention_days: Number of days to retain files
+            
+        Returns:
+            Number of files removed
+        """
+        return self.cleanup(self.save_dir, "rates_*.json", retention_days)

From c11c08b87486a3e2983a3d37c755d8b6f52f1b8d Mon Sep 17 00:00:00 2001
From: Rob Aldred <rob@residently.com>
Date: Mon, 2 Feb 2026 23:43:10 +0000
Subject: [PATCH 03/12] Add rate_retention_days config option

---
 apps/predbat/config.py | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/apps/predbat/config.py b/apps/predbat/config.py
index d1bf4c121..98eeb4d41 100644
--- a/apps/predbat/config.py
+++ b/apps/predbat/config.py
@@ -826,6 +826,18 @@
         "type": "switch",
         "default": True,
     },
+    {
+        "name": "rate_retention_days",
+        "friendly_name": "Rate Retention Days",
+        "type": "input_number",
+        "min": 1,
+        "max": 365,
+        "step": 1,
+        "unit": "days",
+        "icon": "mdi:database-clock",
+        "enable": "expert_mode",
+        "default": 7,
+    },
     {
         "name": "set_charge_freeze",
         "friendly_name": "Set Charge Freeze",
@@ -1437,6 +1449,7 @@
     "days_previous": True,
     "days_previous_weight": True,
     "battery_scaling": True,
+    "rate_retention_days": True,
     "forecast_hours": True,
     "import_export_scaling": True,
     "inverter_limit_charge": True,
@@ -2073,6 +2086,7 @@
     "rates_export_override": {"type": "dict_list"},
     "days_previous": {"type": "integer_list"},
     "days_previous_weight": {"type": "float_list"},
+    "rate_retention_days": {"type": "integer"},
     "forecast_hours": {"type": "integer"},
     "notify_devices": {"type": "string_list"},
     "battery_scaling": {"type": "sensor_list", "sensor_type": "float", "entries": "num_inverters", "modify": False},

From 913f247eec37631133b8bf10c85bafa95e9388a0 Mon Sep 17 00:00:00 2001
From: Rob Aldred <rob@residently.com>
Date: Mon, 2 Feb 2026 23:52:34 +0000
Subject: [PATCH 04/12] Initialize and rehydrate rate store on startup

---
 apps/predbat/predbat.py    |  6 +++++-
 apps/predbat/rate_store.py | 18 ++++++++++++++++++
 2 files changed, 23 insertions(+), 1 deletion(-)

diff --git a/apps/predbat/predbat.py b/apps/predbat/predbat.py
index 68c906d10..bfb5b00e8 100644
--- a/apps/predbat/predbat.py
+++ b/apps/predbat/predbat.py
@@ -30,7 +30,7 @@
 THIS_VERSION = "v8.32.14"
 
 # fmt: off
-PREDBAT_FILES = ["predbat.py", "const.py", "hass.py", "config.py", "prediction.py", "gecloud.py", "utils.py", "inverter.py", "ha.py", "download.py", "web.py", "web_helper.py", "predheat.py", "futurerate.py", "octopus.py", "solcast.py", "execute.py", "plan.py", "fetch.py", "output.py", "userinterface.py", "energydataservice.py", "alertfeed.py", "compare.py", "db_manager.py", "db_engine.py", "plugin_system.py", "ohme.py", "components.py", "fox.py", "carbon.py", "web_mcp.py", "component_base.py", "axle.py", "solax.py", "solis.py", "unit_test.py"]
+PREDBAT_FILES = ["predbat.py", "const.py", "hass.py", "config.py", "prediction.py", "gecloud.py", "utils.py", "inverter.py", "ha.py", "download.py", "web.py", "web_helper.py", "predheat.py", "futurerate.py", "octopus.py", "solcast.py", "execute.py", "plan.py", "fetch.py", "output.py", "userinterface.py", "energydataservice.py", "alertfeed.py", "compare.py", "db_manager.py", "db_engine.py", "plugin_system.py", "ohme.py", "components.py", "fox.py", "carbon.py", "web_mcp.py", "component_base.py", "axle.py", "solax.py", "solis.py", "unit_test.py", "persistent_store.py", "rate_store.py"]
 # fmt: on
 
 from download import predbat_update_move, predbat_update_download, check_install
@@ -76,6 +76,7 @@
 from userinterface import UserInterface
 from compare import Compare
 from plugin_system import PluginSystem
+from rate_store import RateStore
 
 
 class PredBat(hass.Hass, Octopus, Energidataservice, Fetch, Plan, Execute, Output, UserInterface):
@@ -474,6 +475,7 @@ def reset(self):
         self.rate_import_no_io = {}
         self.rate_export = {}
         self.rate_gas = {}
+        self.rate_store = None
         self.rate_slots = []
         self.low_rates = []
         self.high_export_rates = []
@@ -1492,6 +1494,8 @@ def initialize(self):
             self.load_user_config(quiet=False, register=False)
             self.validate_config()
             self.comparison = Compare(self)
+            
+            self.rate_store = RateStore(self)
 
             self.components.initialize(phase=1)
             if not self.components.start(phase=1):
diff --git a/apps/predbat/rate_store.py b/apps/predbat/rate_store.py
index eff671272..b55239341 100644
--- a/apps/predbat/rate_store.py
+++ b/apps/predbat/rate_store.py
@@ -48,6 +48,24 @@ def __init__(self, base, save_dir="predbat_save"):
         # Key: date string "YYYY-MM-DD", Value: rate data dict
         self.rate_cache = {}
         
+        # Load and finalize rates for today and yesterday
+        today = datetime.now()
+        yesterday = today - timedelta(days=1)
+        self.load_rates(today)
+        self.load_rates(yesterday)
+        
+        # Finalize past slots
+        finalized_today = self.finalize_slots(today, base.minutes_now)
+        finalized_yesterday = self.finalize_slots(yesterday, 24 * 60)  # Finalize all yesterday slots
+        if finalized_today > 0 or finalized_yesterday > 0:
+            self.log("Finalized {} slots for today and {} slots for yesterday".format(finalized_today, finalized_yesterday))
+        
+        # Cleanup old rate files
+        retention_days = base.get_arg("rate_retention_days", 7)
+        removed = self.cleanup_old_files(retention_days)
+        if removed > 0:
+            self.log("Cleaned up {} old rate files".format(removed))
+        
     def _get_filepath(self, date):
         """
         Get filepath for rate file for given date.

From ca3258d779ac099c70b4cc4c11ccc4a4d429f955 Mon Sep 17 00:00:00 2001
From: Rob Aldred <rob@residently.com>
Date: Mon, 2 Feb 2026 23:56:55 +0000
Subject: [PATCH 05/12] Capture and persist base rates from API

---
 apps/predbat/fetch.py | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/apps/predbat/fetch.py b/apps/predbat/fetch.py
index 1a3bf8b8f..ffe12e402 100644
--- a/apps/predbat/fetch.py
+++ b/apps/predbat/fetch.py
@@ -950,6 +950,17 @@ def fetch_sensor_data(self, save=True):
         if self.rate_import:
             self.rate_scan(self.rate_import, print=False)
             self.rate_import, self.rate_import_replicated = self.rate_replicate(self.rate_import, self.io_adjusted, is_import=True)
+            
+            # Persist base import rates to storage (only non-replicated/non-override data)
+            if self.rate_store:
+                today = datetime.now()
+                for minute in self.rate_import:
+                    # Only persist true API data, not replicated or override data
+                    if minute not in self.rate_import_replicated or self.rate_import_replicated[minute] == "got":
+                        # Get corresponding export rate or use 0
+                        export_rate = self.rate_export.get(minute, 0) if self.rate_export else 0
+                        self.rate_store.write_base_rate(today, minute, self.rate_import[minute], export_rate)
+            
             self.rate_import_no_io = self.rate_import.copy()
             self.rate_import = self.rate_add_io_slots(self.rate_import, self.octopus_slots)
             self.load_saving_slot(self.octopus_saving_slots, export=False, rate_replicate=self.rate_import_replicated)
@@ -966,6 +977,17 @@ def fetch_sensor_data(self, save=True):
         if self.rate_export:
             self.rate_scan_export(self.rate_export, print=False)
             self.rate_export, self.rate_export_replicated = self.rate_replicate(self.rate_export, is_import=False)
+            
+            # Persist base export rates to storage (only non-replicated/non-override data)
+            if self.rate_store:
+                today = datetime.now()
+                for minute in self.rate_export:
+                    # Only persist true API data, not replicated or override data
+                    if minute not in self.rate_export_replicated or self.rate_export_replicated[minute] == "got":
+                        # Get corresponding import rate or use 0
+                        import_rate = self.rate_import.get(minute, 0) if self.rate_import else 0
+                        self.rate_store.write_base_rate(today, minute, import_rate, self.rate_export[minute])
+            
             # For export tariff only load the saving session if enabled
             if self.rate_export_max > 0:
                 self.load_saving_slot(self.octopus_saving_slots, export=True, rate_replicate=self.rate_export_replicated)

From 0af007c423e8247f75c2a47a20185bbb179c883b Mon Sep 17 00:00:00 2001
From: Rob Aldred <rob@residently.com>
Date: Tue, 3 Feb 2026 00:04:05 +0000
Subject: [PATCH 06/12] Track automatic rate overrides with removal detection

---
 apps/predbat/axle.py    | 10 ++++++++++
 apps/predbat/octopus.py | 20 ++++++++++++++++++++
 2 files changed, 30 insertions(+)

diff --git a/apps/predbat/axle.py b/apps/predbat/axle.py
index 25bc83c50..5a8a8e254 100644
--- a/apps/predbat/axle.py
+++ b/apps/predbat/axle.py
@@ -375,10 +375,20 @@ def load_axle_slot(base, axle_sessions, export, rate_replicate={}):
                     if export:
                         base.rate_export[minute] = base.rate_export.get(minute, 0) + pence_per_kwh
                         rate_replicate[minute] = "saving"
+                        
+                        # Track Axle override in rate store
+                        if base.rate_store:
+                            today = datetime.now()
+                            base.rate_store.update_auto_override(today, minute, None, base.rate_export[minute], "Axle")
                     else:
                         base.rate_import[minute] = base.rate_import.get(minute, 0) + pence_per_kwh
                         base.load_scaling_dynamic[minute] = base.load_scaling_saving
                         rate_replicate[minute] = "saving"
+                        
+                        # Track Axle override in rate store
+                        if base.rate_store:
+                            today = datetime.now()
+                            base.rate_store.update_auto_override(today, minute, base.rate_import[minute], None, "Axle")
 
 
 def fetch_axle_active(base):
diff --git a/apps/predbat/octopus.py b/apps/predbat/octopus.py
index 5d6992e78..fec4b51ca 100644
--- a/apps/predbat/octopus.py
+++ b/apps/predbat/octopus.py
@@ -1947,11 +1947,21 @@ def load_saving_slot(self, octopus_saving_slots, export=False, rate_replicate={}
                         if minute in self.rate_export:
                             self.rate_export[minute] += rate
                             rate_replicate[minute] = "saving"
+                            
+                            # Track saving session override in rate store
+                            if self.rate_store:
+                                today = datetime.now()
+                                self.rate_store.update_auto_override(today, minute, None, self.rate_export[minute], "Saving")
                     else:
                         if minute in self.rate_import:
                             self.rate_import[minute] += rate
                             self.load_scaling_dynamic[minute] = self.load_scaling_saving
                             rate_replicate[minute] = "saving"
+                            
+                            # Track saving session override in rate store
+                            if self.rate_store:
+                                today = datetime.now()
+                                self.rate_store.update_auto_override(today, minute, self.rate_import[minute], None, "Saving")
 
     def decode_octopus_slot(self, slot, raw=False):
         """
@@ -2146,11 +2156,21 @@ def rate_add_io_slots(self, rates, octopus_slots):
                                     slots_per_day[day_offset] += 1
                                     slots_added_set.add(slot_start)
                                     rates[minute] = assumed_price
+                                    
+                                    # Track IOG override in rate store
+                                    if self.rate_store:
+                                        today = datetime.now()
+                                        self.rate_store.update_auto_override(today, minute, assumed_price, None, "IOG")
 
                             else:
                                 # For minutes within a 30-min slot, only apply if the slot was added
                                 if slot_start in slots_added_set:
                                     rates[minute] = assumed_price
+                                    
+                                    # Track IOG override in rate store
+                                    if self.rate_store:
+                                        today = datetime.now()
+                                        self.rate_store.update_auto_override(today, minute, assumed_price, None, "IOG")
                     else:
                         assumed_price = self.rate_import.get(start_minutes, self.rate_min)
 

From 0cc74e07eca90a4a475ab54d291813d605690f58 Mon Sep 17 00:00:00 2001
From: Rob Aldred <rob@residently.com>
Date: Tue, 3 Feb 2026 00:05:09 +0000
Subject: [PATCH 07/12] Track manual rate overrides and finalize past slots

---
 apps/predbat/fetch.py | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/apps/predbat/fetch.py b/apps/predbat/fetch.py
index ffe12e402..c7dd42cef 100644
--- a/apps/predbat/fetch.py
+++ b/apps/predbat/fetch.py
@@ -1002,6 +1002,13 @@ def fetch_sensor_data(self, save=True):
         # Set rate thresholds
         if self.rate_import or self.rate_export:
             self.set_rate_thresholds()
+            
+        # Finalize past slots (5+ minutes past slot start)
+        if self.rate_store:
+            today = datetime.now()
+            finalized = self.rate_store.finalize_slots(today, self.minutes_now)
+            if finalized > 0:
+                self.log("Finalized {} rate slots".format(finalized))
 
         # Find discharging windows
         if self.rate_export:
@@ -1404,6 +1411,14 @@ def apply_manual_rates(self, rates, manual_items, is_import=True, rate_replicate
                 continue
             rates[minute] = rate
             rate_replicate[minute] = "manual"
+            
+            # Track manual override in rate store
+            if self.rate_store:
+                today = datetime.now()
+                if is_import:
+                    self.rate_store.update_manual_override(today, minute, rate, None)
+                else:
+                    self.rate_store.update_manual_override(today, minute, None, rate)
 
         return rates
 

From 6a5bee0f5bb9edb45b8358e2ab253582e50b6952 Mon Sep 17 00:00:00 2001
From: Rob Aldred <rob@residently.com>
Date: Tue, 3 Feb 2026 00:10:22 +0000
Subject: [PATCH 08/12] Use persisted rates for cost calculations

---
 apps/predbat/output.py | 32 ++++++++++++++++++++------------
 1 file changed, 20 insertions(+), 12 deletions(-)

diff --git a/apps/predbat/output.py b/apps/predbat/output.py
index f4e13035d..27e6452ed 100644
--- a/apps/predbat/output.py
+++ b/apps/predbat/output.py
@@ -1716,13 +1716,17 @@ def today_cost(self, import_today, export_today, car_today, load_today, save=Tru
             hour_load += load_energy
 
             if self.rate_import:
-                hour_cost += self.rate_import.get(minute, 0) * energy_import
-                hour_cost_import += self.rate_import.get(minute, 0) * energy_import
-                hour_cost_car += self.rate_import.get(minute, 0) * energy_car
+                # Use rate_store for historical rates to prevent retrospective changes
+                import_rate = self.rate_store.get_rate(datetime.now(), minute, is_import=True) if self.rate_store else self.rate_import.get(minute, 0)
+                hour_cost += import_rate * energy_import
+                hour_cost_import += import_rate * energy_import
+                hour_cost_car += import_rate * energy_car
 
             if self.rate_export:
-                hour_cost -= self.rate_export.get(minute, 0) * energy_export
-                hour_cost_export -= self.rate_export.get(minute, 0) * energy_export
+                # Use rate_store for historical rates to prevent retrospective changes
+                export_rate = self.rate_store.get_rate(datetime.now(), minute, is_import=False) if self.rate_store else self.rate_export.get(minute, 0)
+                hour_cost -= export_rate * energy_export
+                hour_cost_export -= export_rate * energy_export
 
             if self.carbon_enable:
                 hour_carbon_g += self.carbon_history.get(minute_back, 0) * energy_import
@@ -1774,16 +1778,20 @@ def today_cost(self, import_today, export_today, car_today, load_today, save=Tru
             day_import += energy
             day_car += car_energy
             if self.rate_import:
-                day_cost += self.rate_import.get(minute, 0) * energy
-                day_cost_import += self.rate_import.get(minute, 0) * energy
-                day_cost_nosc += self.rate_import.get(minute, 0) * energy
-                day_cost_car += self.rate_import.get(minute, 0) * car_energy
+                # Use rate_store for historical rates to prevent retrospective changes
+                import_rate = self.rate_store.get_rate(datetime.now(), minute, is_import=True) if self.rate_store else self.rate_import.get(minute, 0)
+                day_cost += import_rate * energy
+                day_cost_import += import_rate * energy
+                day_cost_nosc += import_rate * energy
+                day_cost_car += import_rate * car_energy
 
             day_export += energy_export
             if self.rate_export:
-                day_cost -= self.rate_export.get(minute, 0) * energy_export
-                day_cost_nosc -= self.rate_export.get(minute, 0) * energy_export
-                day_cost_export -= self.rate_export.get(minute, 0) * energy_export
+                # Use rate_store for historical rates to prevent retrospective changes
+                export_rate = self.rate_store.get_rate(datetime.now(), minute, is_import=False) if self.rate_store else self.rate_export.get(minute, 0)
+                day_cost -= export_rate * energy_export
+                day_cost_nosc -= export_rate * energy_export
+                day_cost_export -= export_rate * energy_export
 
             if self.carbon_enable:
                 carbon_g += self.carbon_history.get(minute_back, 0) * energy

From 74a7183fb09b12ace05a3b577be45b96a28ecec0 Mon Sep 17 00:00:00 2001
From: Rob Aldred <rob@residently.com>
Date: Tue, 3 Feb 2026 16:01:34 +0000
Subject: [PATCH 09/12] Use rate store in output and add tests

---
 apps/predbat/fetch.py                 |  12 +
 apps/predbat/output.py                |  32 +-
 apps/predbat/tests/test_rate_store.py | 425 ++++++++++++++++++++++++++
 apps/predbat/unit_test.py             |   3 +
 4 files changed, 452 insertions(+), 20 deletions(-)
 create mode 100644 apps/predbat/tests/test_rate_store.py

diff --git a/apps/predbat/fetch.py b/apps/predbat/fetch.py
index c7dd42cef..0e254c687 100644
--- a/apps/predbat/fetch.py
+++ b/apps/predbat/fetch.py
@@ -960,6 +960,12 @@ def fetch_sensor_data(self, save=True):
                         # Get corresponding export rate or use 0
                         export_rate = self.rate_export.get(minute, 0) if self.rate_export else 0
                         self.rate_store.write_base_rate(today, minute, self.rate_import[minute], export_rate)
+                
+                # Rehydrate finalized rates from storage - these take priority over fresh API data
+                for minute in range(0, self.minutes_now):
+                    finalized_rate = self.rate_store.get_rate(today, minute, is_import=True)
+                    if finalized_rate is not None:
+                        self.rate_import[minute] = finalized_rate
             
             self.rate_import_no_io = self.rate_import.copy()
             self.rate_import = self.rate_add_io_slots(self.rate_import, self.octopus_slots)
@@ -987,6 +993,12 @@ def fetch_sensor_data(self, save=True):
                         # Get corresponding import rate or use 0
                         import_rate = self.rate_import.get(minute, 0) if self.rate_import else 0
                         self.rate_store.write_base_rate(today, minute, import_rate, self.rate_export[minute])
+                
+                # Rehydrate finalized rates from storage - these take priority over fresh API data
+                for minute in range(0, self.minutes_now):
+                    finalized_rate = self.rate_store.get_rate(today, minute, is_import=False)
+                    if finalized_rate is not None:
+                        self.rate_export[minute] = finalized_rate
             
             # For export tariff only load the saving session if enabled
             if self.rate_export_max > 0:
diff --git a/apps/predbat/output.py b/apps/predbat/output.py
index 27e6452ed..f4e13035d 100644
--- a/apps/predbat/output.py
+++ b/apps/predbat/output.py
@@ -1716,17 +1716,13 @@ def today_cost(self, import_today, export_today, car_today, load_today, save=Tru
             hour_load += load_energy
 
             if self.rate_import:
-                # Use rate_store for historical rates to prevent retrospective changes
-                import_rate = self.rate_store.get_rate(datetime.now(), minute, is_import=True) if self.rate_store else self.rate_import.get(minute, 0)
-                hour_cost += import_rate * energy_import
-                hour_cost_import += import_rate * energy_import
-                hour_cost_car += import_rate * energy_car
+                hour_cost += self.rate_import.get(minute, 0) * energy_import
+                hour_cost_import += self.rate_import.get(minute, 0) * energy_import
+                hour_cost_car += self.rate_import.get(minute, 0) * energy_car
 
             if self.rate_export:
-                # Use rate_store for historical rates to prevent retrospective changes
-                export_rate = self.rate_store.get_rate(datetime.now(), minute, is_import=False) if self.rate_store else self.rate_export.get(minute, 0)
-                hour_cost -= export_rate * energy_export
-                hour_cost_export -= export_rate * energy_export
+                hour_cost -= self.rate_export.get(minute, 0) * energy_export
+                hour_cost_export -= self.rate_export.get(minute, 0) * energy_export
 
             if self.carbon_enable:
                 hour_carbon_g += self.carbon_history.get(minute_back, 0) * energy_import
@@ -1778,20 +1774,16 @@ def today_cost(self, import_today, export_today, car_today, load_today, save=Tru
             day_import += energy
             day_car += car_energy
             if self.rate_import:
-                # Use rate_store for historical rates to prevent retrospective changes
-                import_rate = self.rate_store.get_rate(datetime.now(), minute, is_import=True) if self.rate_store else self.rate_import.get(minute, 0)
-                day_cost += import_rate * energy
-                day_cost_import += import_rate * energy
-                day_cost_nosc += import_rate * energy
-                day_cost_car += import_rate * car_energy
+                day_cost += self.rate_import.get(minute, 0) * energy
+                day_cost_import += self.rate_import.get(minute, 0) * energy
+                day_cost_nosc += self.rate_import.get(minute, 0) * energy
+                day_cost_car += self.rate_import.get(minute, 0) * car_energy
 
             day_export += energy_export
             if self.rate_export:
-                # Use rate_store for historical rates to prevent retrospective changes
-                export_rate = self.rate_store.get_rate(datetime.now(), minute, is_import=False) if self.rate_store else self.rate_export.get(minute, 0)
-                day_cost -= export_rate * energy_export
-                day_cost_nosc -= export_rate * energy_export
-                day_cost_export -= export_rate * energy_export
+                day_cost -= self.rate_export.get(minute, 0) * energy_export
+                day_cost_nosc -= self.rate_export.get(minute, 0) * energy_export
+                day_cost_export -= self.rate_export.get(minute, 0) * energy_export
 
             if self.carbon_enable:
                 carbon_g += self.carbon_history.get(minute_back, 0) * energy
diff --git a/apps/predbat/tests/test_rate_store.py b/apps/predbat/tests/test_rate_store.py
new file mode 100644
index 000000000..3d9b1845b
--- /dev/null
+++ b/apps/predbat/tests/test_rate_store.py
@@ -0,0 +1,425 @@
+# -----------------------------------------------------------------------------
+# Predbat Home Battery System
+# Copyright Trefor Southwell 2026 - All Rights Reserved
+# This application maybe used for personal use only and not for commercial use
+# -----------------------------------------------------------------------------
+# Test rate_store persistent rate tracking with finalization
+# -----------------------------------------------------------------------------
+
+import os
+import json
+import shutil
+from datetime import datetime, timedelta
+from rate_store import RateStore
+from persistent_store import PersistentStore
+
+
+def run_rate_store_tests():
+    """
+    Run comprehensive tests for rate persistence and finalization
+    """
+    print("=" * 80)
+    print("Testing Rate Store Persistence and Finalization")
+    print("=" * 80)
+    
+    # Create test directory
+    test_dir = "test_rate_store_temp"
+    if os.path.exists(test_dir):
+        shutil.rmtree(test_dir)
+    os.makedirs(test_dir)
+    
+    try:
+        # Test 1: Basic persistence
+        print("\n*** Test 1: Basic rate persistence ***")
+        test_basic_persistence(test_dir)
+        
+        # Test 2: Finalization
+        print("\n*** Test 2: Rate finalization ***")
+        test_finalization(test_dir)
+        
+        # Test 3: Rehydration after restart
+        print("\n*** Test 3: Rehydration after restart ***")
+        test_rehydration(test_dir)
+        
+        # Test 4: Override priority
+        print("\n*** Test 4: Override priority (manual > automatic > initial) ***")
+        test_override_priority(test_dir)
+        
+        # Test 5: Finalized rates resist new API data
+        print("\n*** Test 5: Finalized rates resist fresh API data ***")
+        test_finalized_resistance(test_dir)
+        
+        # Test 6: Automatic override removal detection
+        print("\n*** Test 6: Automatic override removal detection ***")
+        test_override_removal(test_dir)
+        
+        # Test 7: Cleanup old files
+        print("\n*** Test 7: Cleanup old files ***")
+        test_cleanup(test_dir)
+        
+        # Test 8: Slot interval mismatch handling
+        print("\n*** Test 8: Slot interval mismatch handling ***")
+        test_interval_mismatch(test_dir)
+        
+        print("\n" + "=" * 80)
+        print("All rate store tests PASSED")
+        print("=" * 80)
+        return True
+        
+    except AssertionError as e:
+        print(f"\n*** TEST FAILED: {e} ***")
+        return False
+    finally:
+        # Cleanup
+        if os.path.exists(test_dir):
+            shutil.rmtree(test_dir)
+
+
+def test_basic_persistence(test_dir):
+    """Test basic write and read of rates"""
+    
+    # Create mock base object
+    class MockBase:
+        def __init__(self):
+            self.plan_interval_minutes = 30
+            self.minutes_now = 720  # 12:00
+            
+        def log(self, msg):
+            print(f"  {msg}")
+            
+        def get_arg(self, key, default):
+            if key == "rate_retention_days":
+                return 7
+            return default
+    
+    base = MockBase()
+    store = RateStore(base, save_dir=test_dir)
+    
+    # Write some base rates
+    today = datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)
+    
+    # Write rates for 00:00, 00:30, 01:00
+    store.write_base_rate(today, 0, 10.0, 5.0)    # import=10p, export=5p
+    store.write_base_rate(today, 30, 12.0, 6.0)   # import=12p, export=6p
+    store.write_base_rate(today, 60, 15.0, 7.0)   # import=15p, export=7p
+    
+    # Read back
+    rate_import_0 = store.get_rate(today, 0, is_import=True)
+    rate_export_0 = store.get_rate(today, 0, is_import=False)
+    rate_import_30 = store.get_rate(today, 30, is_import=True)
+    rate_export_60 = store.get_rate(today, 60, is_import=False)
+    
+    assert rate_import_0 == 10.0, f"Expected 10.0, got {rate_import_0}"
+    assert rate_export_0 == 5.0, f"Expected 5.0, got {rate_export_0}"
+    assert rate_import_30 == 12.0, f"Expected 12.0, got {rate_import_30}"
+    assert rate_export_60 == 7.0, f"Expected 7.0, got {rate_export_60}"
+    
+    # Check file was created
+    date_str = today.strftime("%Y_%m_%d")
+    filepath = os.path.join(test_dir, f"rates_{date_str}.json")
+    assert os.path.exists(filepath), "Rate file not created"
+    
+    print("  ✓ Basic persistence working")
+
+
+def test_finalization(test_dir):
+    """Test that slots get finalized 5 minutes after start"""
+    
+    class MockBase:
+        def __init__(self):
+            self.plan_interval_minutes = 30
+            self.minutes_now = 725  # 12:05 - 5 minutes into 12:00 slot
+            
+        def log(self, msg):
+            print(f"  {msg}")
+            
+        def get_arg(self, key, default):
+            return default
+    
+    base = MockBase()
+    store = RateStore(base, save_dir=test_dir)
+    
+    today = datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)
+    
+    # Write rates for multiple slots
+    store.write_base_rate(today, 0, 10.0, 5.0)      # 00:00 slot (should finalize)
+    store.write_base_rate(today, 30, 12.0, 6.0)     # 00:30 slot (should finalize)
+    store.write_base_rate(today, 690, 15.0, 7.0)    # 11:30 slot (should finalize)
+    store.write_base_rate(today, 720, 20.0, 10.0)   # 12:00 slot (should finalize at 12:05)
+    store.write_base_rate(today, 750, 25.0, 12.0)   # 12:30 slot (should NOT finalize yet)
+    
+    # Finalize slots at current time (12:05)
+    finalized_count = store.finalize_slots(today, base.minutes_now)
+    
+    # Should finalize 00:00, 00:30, 11:30, 12:00 (4 slots)
+    assert finalized_count == 4, f"Expected 4 slots finalized, got {finalized_count}"
+    
+    # Check finalization status in the file
+    date_str = today.strftime("%Y_%m_%d")
+    filepath = os.path.join(test_dir, f"rates_{date_str}.json")
+    with open(filepath, 'r') as f:
+        data = json.load(f)
+    
+    assert data['rates_import']['00:00']['finalized'] == True, "00:00 should be finalized"
+    assert data['rates_import']['12:00']['finalized'] == True, "12:00 should be finalized"
+    assert data['rates_import']['12:30']['finalized'] == False, "12:30 should NOT be finalized"
+    
+    print("  ✓ Finalization working correctly")
+
+
+def test_rehydration(test_dir):
+    """Test that rates survive restart and are reloaded"""
+    
+    class MockBase:
+        def __init__(self):
+            self.plan_interval_minutes = 30
+            self.minutes_now = 720
+            
+        def log(self, msg):
+            print(f"  {msg}")
+            
+        def get_arg(self, key, default):
+            return 7 if key == "rate_retention_days" else default
+    
+    # First instance - write data
+    base1 = MockBase()
+    store1 = RateStore(base1, save_dir=test_dir)
+    
+    today = datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)
+    
+    # Write and finalize some rates
+    store1.write_base_rate(today, 0, 10.0, 5.0)
+    store1.write_base_rate(today, 30, 12.0, 6.0)
+    store1.update_auto_override(today, 60, 8.0, None, "IOG")  # Cheap IOG slot
+    store1.update_manual_override(today, 90, 20.0, None)      # Manual override
+    store1.finalize_slots(today, 100)  # Finalize all past slots
+    
+    # Verify initial state
+    assert store1.get_rate(today, 0, is_import=True) == 10.0
+    assert store1.get_rate(today, 30, is_import=True) == 12.0
+    assert store1.get_rate(today, 60, is_import=True) == 8.0   # IOG override
+    assert store1.get_rate(today, 90, is_import=True) == 20.0  # Manual override
+    
+    # Simulate restart - create new instance
+    base2 = MockBase()
+    store2 = RateStore(base2, save_dir=test_dir)
+    
+    # Manually load the data (simulating what constructor does)
+    store2.load_rates(today)
+    
+    # Verify data was restored
+    assert store2.get_rate(today, 0, is_import=True) == 10.0, "Initial rate not restored"
+    assert store2.get_rate(today, 30, is_import=True) == 12.0, "Initial rate not restored"
+    assert store2.get_rate(today, 60, is_import=True) == 8.0, "IOG override not restored"
+    assert store2.get_rate(today, 90, is_import=True) == 20.0, "Manual override not restored"
+    
+    print("  ✓ Rehydration after restart working")
+
+
+def test_override_priority(test_dir):
+    """Test that manual > automatic > initial priority is respected"""
+    
+    class MockBase:
+        def __init__(self):
+            self.plan_interval_minutes = 30
+            self.minutes_now = 720
+            
+        def log(self, msg):
+            print(f"  {msg}")
+            
+        def get_arg(self, key, default):
+            return default
+    
+    base = MockBase()
+    store = RateStore(base, save_dir=test_dir)
+    
+    today = datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)
+    
+    # Test slot at 00:00
+    # Start with initial rate
+    store.write_base_rate(today, 0, 10.0, 5.0)
+    assert store.get_rate(today, 0, is_import=True) == 10.0, "Initial rate should be 10.0"
+    
+    # Apply automatic override (IOG)
+    store.update_auto_override(today, 0, 7.5, None, "IOG")
+    assert store.get_rate(today, 0, is_import=True) == 7.5, "Automatic override should be 7.5"
+    
+    # Apply manual override (should take priority)
+    store.update_manual_override(today, 0, 15.0, None)
+    assert store.get_rate(today, 0, is_import=True) == 15.0, "Manual override should be 15.0"
+    
+    # Clear manual override
+    store.update_manual_override(today, 0, None, None)
+    assert store.get_rate(today, 0, is_import=True) == 7.5, "Should fall back to automatic override (7.5)"
+    
+    # Clear automatic override
+    store.update_auto_override(today, 0, None, None, "IOG")
+    assert store.get_rate(today, 0, is_import=True) == 10.0, "Should fall back to initial rate (10.0)"
+    
+    print("  ✓ Override priority working correctly")
+
+
+def test_finalized_resistance(test_dir):
+    """Test that finalized rates cannot be changed by new overrides"""
+    
+    class MockBase:
+        def __init__(self):
+            self.plan_interval_minutes = 30
+            self.minutes_now = 720
+            
+        def log(self, msg):
+            print(f"  {msg}")
+            
+        def get_arg(self, key, default):
+            return default
+    
+    base = MockBase()
+    store = RateStore(base, save_dir=test_dir)
+    
+    today = datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)
+    
+    # Write initial rate and automatic override for 00:00 slot
+    store.write_base_rate(today, 0, 10.0, 5.0)
+    store.update_auto_override(today, 0, 7.5, None, "IOG")
+    assert store.get_rate(today, 0, is_import=True) == 7.5, "Should have IOG rate initially"
+    
+    # Finalize the slot
+    store.finalize_slots(today, 10)  # 10 minutes past midnight, so 00:00 is finalized
+    
+    # Try to apply new override (should be ignored for finalized slot)
+    store.update_auto_override(today, 0, 20.0, None, "IOG")
+    assert store.get_rate(today, 0, is_import=True) == 7.5, "Finalized rate should not change from IOG override"
+    
+    # Try manual override (should also be ignored)
+    store.update_manual_override(today, 0, 25.0, None)
+    assert store.get_rate(today, 0, is_import=True) == 7.5, "Finalized rate should not change from manual override"
+    
+    # Non-finalized slot should still accept changes
+    store.write_base_rate(today, 720, 12.0, 6.0)  # 12:00 slot (not finalized)
+    store.update_auto_override(today, 720, 9.0, None, "IOG")
+    assert store.get_rate(today, 720, is_import=True) == 9.0, "Non-finalized slot should accept override"
+    
+    print("  ✓ Finalized rates resist changes correctly")
+
+
+def test_override_removal(test_dir):
+    """Test detection of automatic override removal (e.g., IOG slot removed)"""
+    
+    class MockBase:
+        def __init__(self):
+            self.plan_interval_minutes = 30
+            self.minutes_now = 720
+            
+        def log(self, msg):
+            print(f"  {msg}")
+            
+        def get_arg(self, key, default):
+            return default
+    
+    base = MockBase()
+    store = RateStore(base, save_dir=test_dir)
+    
+    today = datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)
+    
+    # Set up a future slot with IOG override
+    store.write_base_rate(today, 1440, 15.0, 7.0)  # Tomorrow 00:00
+    store.update_auto_override(today, 1440, 7.5, None, "IOG")
+    assert store.get_rate(today, 1440, is_import=True) == 7.5, "Should have IOG override"
+    
+    # Remove the IOG override (simulating Octopus removing the slot)
+    store.update_auto_override(today, 1440, None, None, "IOG")
+    assert store.get_rate(today, 1440, is_import=True) == 15.0, "Should fall back to base rate"
+    
+    # Verify in file
+    date_str = today.strftime("%Y_%m_%d")
+    filepath = os.path.join(test_dir, f"rates_{date_str}.json")
+    with open(filepath, 'r') as f:
+        data = json.load(f)
+    
+    assert data['rates_import']['24:00']['automatic'] is None, "Automatic override should be cleared"
+    
+    print("  ✓ Override removal detection working")
+
+
+def test_cleanup(test_dir):
+    """Test cleanup of old rate files"""
+    
+    class MockBase:
+        def __init__(self):
+            self.plan_interval_minutes = 30
+            self.minutes_now = 720
+            
+        def log(self, msg):
+            print(f"  {msg}")
+            
+        def get_arg(self, key, default):
+            return default
+    
+    base = MockBase()
+    store = RateStore(base, save_dir=test_dir)
+    
+    # Create old rate files
+    today = datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)
+    
+    for days_ago in range(10):
+        old_date = today - timedelta(days=days_ago)
+        store.write_base_rate(old_date, 0, 10.0, 5.0)
+    
+    # Should have 10 files
+    files = [f for f in os.listdir(test_dir) if f.startswith("rates_") and f.endswith(".json")]
+    assert len(files) == 10, f"Expected 10 files, got {len(files)}"
+    
+    # Cleanup with 7 day retention
+    removed = store.cleanup_old_files(retention_days=7)
+    
+    # Should remove 3 files (8, 9, 10 days old)
+    assert removed == 3, f"Expected 3 files removed, got {removed}"
+    
+    # Should have 7 files remaining
+    files = [f for f in os.listdir(test_dir) if f.startswith("rates_") and f.endswith(".json")]
+    assert len(files) == 7, f"Expected 7 files remaining, got {len(files)}"
+    
+    print("  ✓ Cleanup working correctly")
+
+
+def test_interval_mismatch(test_dir):
+    """Test handling of plan_interval_minutes mismatch"""
+    
+    class MockBase:
+        def __init__(self, interval=30):
+            self.plan_interval_minutes = interval
+            self.minutes_now = 720
+            
+        def log(self, msg):
+            print(f"  {msg}")
+            
+        def get_arg(self, key, default):
+            return default
+    
+    # Create file with 30-minute intervals
+    base1 = MockBase(interval=30)
+    store1 = RateStore(base1, save_dir=test_dir)
+    
+    today = datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)
+    store1.write_base_rate(today, 0, 10.0, 5.0)
+    store1.write_base_rate(today, 30, 12.0, 6.0)
+    
+    # Try to load with different interval (should backup and restart)
+    base2 = MockBase(interval=60)
+    store2 = RateStore(base2, save_dir=test_dir)
+    
+    # Should have created backup
+    date_str = today.strftime("%Y_%m_%d")
+    backup_path = os.path.join(test_dir, f"rates_{date_str}.json.bak")
+    assert os.path.exists(backup_path), "Backup file should be created on interval mismatch"
+    
+    # Load data - should have new empty structure with 60-minute interval
+    data = store2.load_rates(today)
+    assert data['plan_interval_minutes'] == 60, "Should have new interval"
+    
+    print("  ✓ Interval mismatch handled correctly")
+
+
+if __name__ == "__main__":
+    success = run_rate_store_tests()
+    exit(0 if success else 1)
diff --git a/apps/predbat/unit_test.py b/apps/predbat/unit_test.py
index a005b3157..744d28ccd 100644
--- a/apps/predbat/unit_test.py
+++ b/apps/predbat/unit_test.py
@@ -96,6 +96,7 @@
 from tests.test_ohme import test_ohme
 from tests.test_component_base import test_component_base_all
 from tests.test_solis import run_solis_tests
+from tests.test_rate_store import run_rate_store_tests
 
 
 # Mock the components and plugin system
@@ -244,6 +245,8 @@ def main():
         ("component_base", test_component_base_all, "ComponentBase tests (all)", False),
         # Solis Cloud API unit tests
         ("solis", run_solis_tests, "Solis Cloud API tests (V1/V2 time window writes, change detection)", False),
+        # Rate Store unit tests
+        ("rate_store", run_rate_store_tests, "Rate Store persistence and finalization tests (write, rehydrate, finalize, priority, cleanup)", False),
         ("optimise_levels", run_optimise_levels_tests, "Optimise levels tests", False),
         ("optimise_windows", run_optimise_all_windows_tests, "Optimise all windows tests", True),
         ("debug_cases", run_debug_cases, "Debug case file tests", True),

From 3f29e7af66846d3efad1af47c322c213b7dc897b Mon Sep 17 00:00:00 2001
From: Rob Aldred <rob@residently.com>
Date: Tue, 3 Feb 2026 16:02:29 +0000
Subject: [PATCH 10/12] Fix white space

---
 apps/predbat/axle.py             |   4 +-
 apps/predbat/fetch.py            |  16 +--
 apps/predbat/octopus.py          |   8 +-
 apps/predbat/persistent_store.py |  52 ++++-----
 apps/predbat/predbat.py          |   2 +-
 apps/predbat/rate_store.py       | 194 +++++++++++++++----------------
 6 files changed, 138 insertions(+), 138 deletions(-)

diff --git a/apps/predbat/axle.py b/apps/predbat/axle.py
index 5a8a8e254..e451aa9c9 100644
--- a/apps/predbat/axle.py
+++ b/apps/predbat/axle.py
@@ -375,7 +375,7 @@ def load_axle_slot(base, axle_sessions, export, rate_replicate={}):
                     if export:
                         base.rate_export[minute] = base.rate_export.get(minute, 0) + pence_per_kwh
                         rate_replicate[minute] = "saving"
-                        
+
                         # Track Axle override in rate store
                         if base.rate_store:
                             today = datetime.now()
@@ -384,7 +384,7 @@ def load_axle_slot(base, axle_sessions, export, rate_replicate={}):
                         base.rate_import[minute] = base.rate_import.get(minute, 0) + pence_per_kwh
                         base.load_scaling_dynamic[minute] = base.load_scaling_saving
                         rate_replicate[minute] = "saving"
-                        
+
                         # Track Axle override in rate store
                         if base.rate_store:
                             today = datetime.now()
diff --git a/apps/predbat/fetch.py b/apps/predbat/fetch.py
index 0e254c687..bd4e080c5 100644
--- a/apps/predbat/fetch.py
+++ b/apps/predbat/fetch.py
@@ -950,7 +950,7 @@ def fetch_sensor_data(self, save=True):
         if self.rate_import:
             self.rate_scan(self.rate_import, print=False)
             self.rate_import, self.rate_import_replicated = self.rate_replicate(self.rate_import, self.io_adjusted, is_import=True)
-            
+
             # Persist base import rates to storage (only non-replicated/non-override data)
             if self.rate_store:
                 today = datetime.now()
@@ -960,13 +960,13 @@ def fetch_sensor_data(self, save=True):
                         # Get corresponding export rate or use 0
                         export_rate = self.rate_export.get(minute, 0) if self.rate_export else 0
                         self.rate_store.write_base_rate(today, minute, self.rate_import[minute], export_rate)
-                
+
                 # Rehydrate finalized rates from storage - these take priority over fresh API data
                 for minute in range(0, self.minutes_now):
                     finalized_rate = self.rate_store.get_rate(today, minute, is_import=True)
                     if finalized_rate is not None:
                         self.rate_import[minute] = finalized_rate
-            
+
             self.rate_import_no_io = self.rate_import.copy()
             self.rate_import = self.rate_add_io_slots(self.rate_import, self.octopus_slots)
             self.load_saving_slot(self.octopus_saving_slots, export=False, rate_replicate=self.rate_import_replicated)
@@ -983,7 +983,7 @@ def fetch_sensor_data(self, save=True):
         if self.rate_export:
             self.rate_scan_export(self.rate_export, print=False)
             self.rate_export, self.rate_export_replicated = self.rate_replicate(self.rate_export, is_import=False)
-            
+
             # Persist base export rates to storage (only non-replicated/non-override data)
             if self.rate_store:
                 today = datetime.now()
@@ -993,13 +993,13 @@ def fetch_sensor_data(self, save=True):
                         # Get corresponding import rate or use 0
                         import_rate = self.rate_import.get(minute, 0) if self.rate_import else 0
                         self.rate_store.write_base_rate(today, minute, import_rate, self.rate_export[minute])
-                
+
                 # Rehydrate finalized rates from storage - these take priority over fresh API data
                 for minute in range(0, self.minutes_now):
                     finalized_rate = self.rate_store.get_rate(today, minute, is_import=False)
                     if finalized_rate is not None:
                         self.rate_export[minute] = finalized_rate
-            
+
             # For export tariff only load the saving session if enabled
             if self.rate_export_max > 0:
                 self.load_saving_slot(self.octopus_saving_slots, export=True, rate_replicate=self.rate_export_replicated)
@@ -1014,7 +1014,7 @@ def fetch_sensor_data(self, save=True):
         # Set rate thresholds
         if self.rate_import or self.rate_export:
             self.set_rate_thresholds()
-            
+
         # Finalize past slots (5+ minutes past slot start)
         if self.rate_store:
             today = datetime.now()
@@ -1423,7 +1423,7 @@ def apply_manual_rates(self, rates, manual_items, is_import=True, rate_replicate
                 continue
             rates[minute] = rate
             rate_replicate[minute] = "manual"
-            
+
             # Track manual override in rate store
             if self.rate_store:
                 today = datetime.now()
diff --git a/apps/predbat/octopus.py b/apps/predbat/octopus.py
index fec4b51ca..de0cc727e 100644
--- a/apps/predbat/octopus.py
+++ b/apps/predbat/octopus.py
@@ -1947,7 +1947,7 @@ def load_saving_slot(self, octopus_saving_slots, export=False, rate_replicate={}
                         if minute in self.rate_export:
                             self.rate_export[minute] += rate
                             rate_replicate[minute] = "saving"
-                            
+
                             # Track saving session override in rate store
                             if self.rate_store:
                                 today = datetime.now()
@@ -1957,7 +1957,7 @@ def load_saving_slot(self, octopus_saving_slots, export=False, rate_replicate={}
                             self.rate_import[minute] += rate
                             self.load_scaling_dynamic[minute] = self.load_scaling_saving
                             rate_replicate[minute] = "saving"
-                            
+
                             # Track saving session override in rate store
                             if self.rate_store:
                                 today = datetime.now()
@@ -2156,7 +2156,7 @@ def rate_add_io_slots(self, rates, octopus_slots):
                                     slots_per_day[day_offset] += 1
                                     slots_added_set.add(slot_start)
                                     rates[minute] = assumed_price
-                                    
+
                                     # Track IOG override in rate store
                                     if self.rate_store:
                                         today = datetime.now()
@@ -2166,7 +2166,7 @@ def rate_add_io_slots(self, rates, octopus_slots):
                                 # For minutes within a 30-min slot, only apply if the slot was added
                                 if slot_start in slots_added_set:
                                     rates[minute] = assumed_price
-                                    
+
                                     # Track IOG override in rate store
                                     if self.rate_store:
                                         today = datetime.now()
diff --git a/apps/predbat/persistent_store.py b/apps/predbat/persistent_store.py
index 567011904..689949102 100644
--- a/apps/predbat/persistent_store.py
+++ b/apps/predbat/persistent_store.py
@@ -33,24 +33,24 @@ def __init__(self, base):
     def load(self, filepath):
         """
         Load data from JSON file with automatic backup restoration on corruption.
-        
+
         Args:
             filepath: Path to JSON file to load
-            
+
         Returns:
             Loaded data dict or None if file doesn't exist or is corrupted
         """
         try:
             if not os.path.exists(filepath):
                 return None
-                
+
             with open(filepath, 'r') as f:
                 data = json.load(f)
                 return data
-                
+
         except (json.JSONDecodeError, IOError) as e:
             self.log(f"Warn: Failed to load {filepath}: {e}")
-            
+
             # Try to restore from backup
             backup_path = filepath + '.bak'
             if os.path.exists(backup_path):
@@ -62,41 +62,41 @@ def load(self, filepath):
                     return data
                 except (json.JSONDecodeError, IOError) as e2:
                     self.log(f"Error: Backup restoration failed: {e2}")
-            
+
             return None
 
     def save(self, filepath, data, backup=True):
         """
         Save data to JSON file with automatic backup and timestamp.
-        
+
         Args:
             filepath: Path to JSON file to save
             data: Dict to save (will add last_updated timestamp)
             backup: Whether to backup existing file before overwrite
-            
+
         Returns:
             True if successful, False otherwise
         """
         try:
             # Add timestamp
             data['last_updated'] = datetime.now().astimezone().isoformat()
-            
+
             # Create directory if needed
             os.makedirs(os.path.dirname(filepath), exist_ok=True)
-            
+
             # Backup existing file if requested
             if backup and os.path.exists(filepath):
                 self.backup_file(filepath)
-                
+
             # Write new file
             with open(filepath, 'w') as f:
                 json.dump(data, f, indent=2)
-                
+
             # Cleanup old backups
             self.cleanup_backups(filepath)
-            
+
             return True
-            
+
         except (IOError, OSError) as e:
             self.log(f"Error: Failed to save {filepath}: {e}")
             return False
@@ -104,7 +104,7 @@ def save(self, filepath, data, backup=True):
     def backup_file(self, filepath):
         """
         Create backup copy of file.
-        
+
         Args:
             filepath: Path to file to backup
         """
@@ -119,7 +119,7 @@ def backup_file(self, filepath):
     def cleanup_backups(self, filepath):
         """
         Remove backup files older than 1 day.
-        
+
         Args:
             filepath: Path to main file (will check for .bak file)
         """
@@ -129,34 +129,34 @@ def cleanup_backups(self, filepath):
                 # Check file age
                 file_time = datetime.fromtimestamp(os.path.getmtime(backup_path))
                 age = datetime.now() - file_time
-                
+
                 if age > timedelta(days=1):
                     os.remove(backup_path)
                     self.log(f"Info: Cleaned up old backup: {backup_path}")
-                    
+
         except (IOError, OSError) as e:
             self.log(f"Warn: Failed to cleanup backup for {filepath}: {e}")
 
     def cleanup(self, directory, pattern, retention_days):
         """
         Remove files matching pattern older than retention period.
-        
+
         Args:
             directory: Directory to search
             pattern: Glob pattern for files to cleanup
             retention_days: Number of days to retain files
-            
+
         Returns:
             Number of files removed
         """
         try:
             if not os.path.exists(directory):
                 return 0
-                
+
             path = Path(directory)
             cutoff_time = datetime.now() - timedelta(days=retention_days)
             removed_count = 0
-            
+
             for file_path in path.glob(pattern):
                 try:
                     file_time = datetime.fromtimestamp(file_path.stat().st_mtime)
@@ -166,9 +166,9 @@ def cleanup(self, directory, pattern, retention_days):
                         self.log(f"Info: Cleaned up old file: {file_path}")
                 except (IOError, OSError) as e:
                     self.log(f"Warn: Failed to remove {file_path}: {e}")
-                    
+
             return removed_count
-            
+
         except Exception as e:
             self.log(f"Error: Cleanup failed for {directory}/{pattern}: {e}")
             return 0
@@ -176,10 +176,10 @@ def cleanup(self, directory, pattern, retention_days):
     def get_last_updated(self, filepath):
         """
         Get last_updated timestamp from JSON file.
-        
+
         Args:
             filepath: Path to JSON file
-            
+
         Returns:
             ISO 8601 timestamp string or None
         """
diff --git a/apps/predbat/predbat.py b/apps/predbat/predbat.py
index bfb5b00e8..da958732c 100644
--- a/apps/predbat/predbat.py
+++ b/apps/predbat/predbat.py
@@ -1494,7 +1494,7 @@ def initialize(self):
             self.load_user_config(quiet=False, register=False)
             self.validate_config()
             self.comparison = Compare(self)
-            
+
             self.rate_store = RateStore(self)
 
             self.components.initialize(phase=1)
diff --git a/apps/predbat/rate_store.py b/apps/predbat/rate_store.py
index b55239341..cb31085ab 100644
--- a/apps/predbat/rate_store.py
+++ b/apps/predbat/rate_store.py
@@ -22,20 +22,20 @@
 class RateStore(PersistentStore):
     """
     Manages persistent storage of energy rates with slot-based structure.
-    
+
     Stores rates in 30-minute slots (configurable via plan_interval_minutes) with:
     - initial: Base rate from API at first retrieval
-    - automatic: Override from external services (IOG, Axle, saving sessions) 
+    - automatic: Override from external services (IOG, Axle, saving sessions)
     - manual: User override from manual selectors
     - finalized: Lock flag set 5 minutes past slot start time
-    
+
     File structure: predbat_save/rates_YYYY_MM_DD.json
     """
-    
+
     def __init__(self, base, save_dir="predbat_save"):
         """
         Initialize rate store.
-        
+
         Args:
             base: PredBat instance
             save_dir: Directory for rate files (relative to workspace root)
@@ -43,91 +43,91 @@ def __init__(self, base, save_dir="predbat_save"):
         super().__init__(base)
         self.save_dir = save_dir
         self.plan_interval_minutes = base.plan_interval_minutes
-        
+
         # In-memory cache of loaded rate files
         # Key: date string "YYYY-MM-DD", Value: rate data dict
         self.rate_cache = {}
-        
+
         # Load and finalize rates for today and yesterday
         today = datetime.now()
         yesterday = today - timedelta(days=1)
         self.load_rates(today)
         self.load_rates(yesterday)
-        
+
         # Finalize past slots
         finalized_today = self.finalize_slots(today, base.minutes_now)
         finalized_yesterday = self.finalize_slots(yesterday, 24 * 60)  # Finalize all yesterday slots
         if finalized_today > 0 or finalized_yesterday > 0:
             self.log("Finalized {} slots for today and {} slots for yesterday".format(finalized_today, finalized_yesterday))
-        
+
         # Cleanup old rate files
         retention_days = base.get_arg("rate_retention_days", 7)
         removed = self.cleanup_old_files(retention_days)
         if removed > 0:
             self.log("Cleaned up {} old rate files".format(removed))
-        
+
     def _get_filepath(self, date):
         """
         Get filepath for rate file for given date.
-        
+
         Args:
             date: datetime object
-            
+
         Returns:
             Full path string to rate JSON file
         """
         date_str = date.strftime("%Y_%m_%d")
         filename = f"rates_{date_str}.json"
         return os.path.join(self.save_dir, filename)
-        
+
     def _get_date_key(self, date):
         """Get cache key for date"""
         return date.strftime("%Y-%m-%d")
-        
+
     def _minutes_to_time(self, minutes):
         """
         Convert minute offset from midnight to HH:MM string.
-        
+
         Args:
             minutes: Minutes since midnight
-            
+
         Returns:
             Time string in format "HH:MM"
         """
         hours = int(minutes // 60)
         mins = int(minutes % 60)
         return f"{hours:02d}:{mins:02d}"
-        
+
     def _time_to_minutes(self, time_str):
         """
         Convert HH:MM string to minute offset from midnight.
-        
+
         Args:
             time_str: Time in format "HH:MM"
-            
+
         Returns:
             Minutes since midnight as int
         """
         parts = time_str.split(':')
         return int(parts[0]) * 60 + int(parts[1])
-        
+
     def _get_slot_start(self, minutes):
         """
         Get slot start time for given minute offset.
         Uses same calculation as output.py line 997.
-        
+
         Args:
             minutes: Minute offset from midnight
-            
+
         Returns:
             Slot start minute offset
         """
         return int(minutes / self.plan_interval_minutes) * self.plan_interval_minutes
-        
+
     def _init_empty_structure(self):
         """
         Create empty rate data structure.
-        
+
         Returns:
             Dict with plan_interval_minutes and empty import/export rate dicts
         """
@@ -136,11 +136,11 @@ def _init_empty_structure(self):
             'rates_import': {},
             'rates_export': {}
         }
-        
+
     def _init_empty_slot(self):
         """
         Create empty slot structure.
-        
+
         Returns:
             Dict with initial/automatic/manual/finalized fields
         """
@@ -150,31 +150,31 @@ def _init_empty_slot(self):
             'manual': None,
             'finalized': False
         }
-        
+
     def load_rates(self, date):
         """
         Load rate data for given date into cache.
-        
+
         Args:
             date: datetime object for date to load
-            
+
         Returns:
             Rate data dict or None if file doesn't exist
         """
         date_key = self._get_date_key(date)
-        
+
         # Check if already cached
         if date_key in self.rate_cache:
             return self.rate_cache[date_key]
-            
+
         # Load from file
         filepath = self._get_filepath(date)
         data = self.load(filepath)
-        
+
         if data is None:
             # Initialize empty structure
             data = self._init_empty_structure()
-            
+
         # Validate plan_interval_minutes matches
         if 'plan_interval_minutes' in data:
             if data['plan_interval_minutes'] != self.plan_interval_minutes:
@@ -186,44 +186,44 @@ def load_rates(self, date):
         else:
             # Old file format, add field
             data['plan_interval_minutes'] = self.plan_interval_minutes
-            
+
         # Ensure structure exists
         if 'rates_import' not in data:
             data['rates_import'] = {}
         if 'rates_export' not in data:
             data['rates_export'] = {}
-            
+
         # Cache it
         self.rate_cache[date_key] = data
-        
+
         return data
-        
+
     def save_rates(self, date):
         """
         Save rate data for given date from cache to file.
-        
+
         Args:
             date: datetime object for date to save
-            
+
         Returns:
             True if successful
         """
         date_key = self._get_date_key(date)
-        
+
         if date_key not in self.rate_cache:
             self.log(f"Warn: No rate data in cache for {date_key}")
             return False
-            
+
         data = self.rate_cache[date_key]
         filepath = self._get_filepath(date)
-        
+
         return self.save(filepath, data, backup=True)
-        
+
     def write_base_rate(self, date, minute, rate_import, rate_export):
         """
         Write initial base rate for a slot (only if not already set).
         This captures the rate at first retrieval from API.
-        
+
         Args:
             date: datetime object for the date
             minute: Minute offset from midnight
@@ -232,32 +232,32 @@ def write_base_rate(self, date, minute, rate_import, rate_export):
         """
         # Load rate data
         data = self.load_rates(date)
-        
+
         # Get slot start
         slot_start = self._get_slot_start(minute)
         slot_time = self._minutes_to_time(slot_start)
-        
+
         # Initialize slots if needed
         if slot_time not in data['rates_import']:
             data['rates_import'][slot_time] = self._init_empty_slot()
         if slot_time not in data['rates_export']:
             data['rates_export'][slot_time] = self._init_empty_slot()
-            
+
         # Only write initial rate if not already set
         if data['rates_import'][slot_time]['initial'] is None:
             data['rates_import'][slot_time]['initial'] = rate_import
-            
+
         if data['rates_export'][slot_time]['initial'] is None:
             data['rates_export'][slot_time]['initial'] = rate_export
-            
+
         # Save immediately
         self.save_rates(date)
-        
+
     def update_auto_override(self, date, minute, rate_import, rate_export, source):
         """
         Update automatic override rate for a slot (IOG, Axle, saving sessions).
         Only updates non-finalized slots.
-        
+
         Args:
             date: datetime object for the date
             minute: Minute offset from midnight
@@ -267,26 +267,26 @@ def update_auto_override(self, date, minute, rate_import, rate_export, source):
         """
         # Load rate data
         data = self.load_rates(date)
-        
+
         # Get slot start
         slot_start = self._get_slot_start(minute)
         slot_time = self._minutes_to_time(slot_start)
-        
+
         # Initialize slots if needed
         if slot_time not in data['rates_import']:
             data['rates_import'][slot_time] = self._init_empty_slot()
         if slot_time not in data['rates_export']:
             data['rates_export'][slot_time] = self._init_empty_slot()
-            
+
         # Check if slot is finalized
         if data['rates_import'][slot_time]['finalized']:
             # Don't modify finalized slots
             return
-            
+
         # Store override with source tracking
         import_slot = data['rates_import'][slot_time]
         export_slot = data['rates_export'][slot_time]
-        
+
         if rate_import is not None:
             import_slot['automatic'] = {
                 'rate': rate_import,
@@ -295,7 +295,7 @@ def update_auto_override(self, date, minute, rate_import, rate_export, source):
         else:
             # Clear override
             import_slot['automatic'] = None
-            
+
         if rate_export is not None:
             export_slot['automatic'] = {
                 'rate': rate_export,
@@ -304,15 +304,15 @@ def update_auto_override(self, date, minute, rate_import, rate_export, source):
         else:
             # Clear override
             export_slot['automatic'] = None
-            
+
         # Save immediately
         self.save_rates(date)
-        
+
     def update_manual_override(self, date, minute, rate_import, rate_export):
         """
         Update manual override rate for a slot (from user selectors).
         Only updates non-finalized slots.
-        
+
         Args:
             date: datetime object for the date
             minute: Minute offset from midnight
@@ -321,50 +321,50 @@ def update_manual_override(self, date, minute, rate_import, rate_export):
         """
         # Load rate data
         data = self.load_rates(date)
-        
+
         # Get slot start
         slot_start = self._get_slot_start(minute)
         slot_time = self._minutes_to_time(slot_start)
-        
+
         # Initialize slots if needed
         if slot_time not in data['rates_import']:
             data['rates_import'][slot_time] = self._init_empty_slot()
         if slot_time not in data['rates_export']:
             data['rates_export'][slot_time] = self._init_empty_slot()
-            
+
         # Check if slot is finalized
         if data['rates_import'][slot_time]['finalized']:
             # Don't modify finalized slots
             return
-            
+
         # Store manual override
         data['rates_import'][slot_time]['manual'] = rate_import
         data['rates_export'][slot_time]['manual'] = rate_export
-        
+
         # Save immediately
         self.save_rates(date)
-        
+
     def finalize_slots(self, date, current_minute):
         """
         Finalize all slots that have passed their start time by 5+ minutes.
         Finalized slots cannot be modified by overrides.
-        
+
         Args:
             date: datetime object for the date
             current_minute: Current minute offset from midnight
-            
+
         Returns:
             Number of slots finalized
         """
         # Load rate data
         data = self.load_rates(date)
-        
+
         finalized_count = 0
-        
+
         # Process all slots
         for slot_time in data['rates_import'].keys():
             slot_minute = self._time_to_minutes(slot_time)
-            
+
             # Check if slot should be finalized
             # Finalize if current time is 5+ minutes past slot start
             if current_minute >= slot_minute + 5:
@@ -372,103 +372,103 @@ def finalize_slots(self, date, current_minute):
                     data['rates_import'][slot_time]['finalized'] = True
                     data['rates_export'][slot_time]['finalized'] = True
                     finalized_count += 1
-                    
+
         if finalized_count > 0:
             self.save_rates(date)
-            
+
         return finalized_count
-        
+
     def get_rate(self, date, minute, is_import=True):
         """
         Get effective rate for a given time.
         Returns manual override > automatic override > initial rate > 0.
-        
+
         Args:
             date: datetime object for the date
             minute: Minute offset from midnight
             is_import: True for import rate, False for export rate
-            
+
         Returns:
             Rate value (float) or 0 if not found
         """
         # Load rate data
         data = self.load_rates(date)
-        
+
         # Get slot start
         slot_start = self._get_slot_start(minute)
         slot_time = self._minutes_to_time(slot_start)
-        
+
         # Select import or export rates
         rates = data['rates_import'] if is_import else data['rates_export']
-        
+
         if slot_time not in rates:
             return 0
-            
+
         slot = rates[slot_time]
-        
+
         # Priority: manual > automatic > initial > 0
         if slot['manual'] is not None:
             return slot['manual']
-            
+
         if slot['automatic'] is not None:
             # Handle dict format with source tracking
             if isinstance(slot['automatic'], dict):
                 return slot['automatic']['rate']
             return slot['automatic']
-            
+
         if slot['initial'] is not None:
             return slot['initial']
-            
+
         return 0
-        
+
     def get_automatic_rate(self, date, minute, is_import=True):
         """
         Get the automatic override rate (ignoring manual overrides).
         Used for displaying what automatic systems are doing.
-        
+
         Args:
             date: datetime object for the date
             minute: Minute offset from midnight
             is_import: True for import rate, False for export rate
-            
+
         Returns:
             Rate value (float) or None if no automatic override
         """
         # Load rate data
         data = self.load_rates(date)
-        
+
         # Get slot start
         slot_start = self._get_slot_start(minute)
         slot_time = self._minutes_to_time(slot_start)
-        
+
         # Select import or export rates
         rates = data['rates_import'] if is_import else data['rates_export']
-        
+
         if slot_time not in rates:
             return None
-            
+
         slot = rates[slot_time]
-        
+
         # Return automatic override if set
         if slot['automatic'] is not None:
             # Handle dict format with source tracking
             if isinstance(slot['automatic'], dict):
                 return slot['automatic']['rate']
             return slot['automatic']
-            
+
         # Fall back to initial rate
         if slot['initial'] is not None:
             return slot['initial']
-            
+
         return None
-        
+
     def cleanup_old_files(self, retention_days):
         """
         Remove rate files older than retention period.
-        
+
         Args:
             retention_days: Number of days to retain files
-            
+
         Returns:
             Number of files removed
         """

From 099dccddd004d73cb9e434230abd6243dd0d2963 Mon Sep 17 00:00:00 2001
From: Rob Aldred <rob@residently.com>
Date: Tue, 3 Feb 2026 17:27:30 +0000
Subject: [PATCH 11/12] Fix tests, update follow syntax pattern of other unit
 test

---
 apps/predbat/tests/test_axle.py       |   1 +
 apps/predbat/tests/test_rate_store.py | 572 ++++++++++++--------------
 2 files changed, 253 insertions(+), 320 deletions(-)

diff --git a/apps/predbat/tests/test_axle.py b/apps/predbat/tests/test_axle.py
index a1932b6b2..c67a37118 100644
--- a/apps/predbat/tests/test_axle.py
+++ b/apps/predbat/tests/test_axle.py
@@ -870,6 +870,7 @@ def __init__(self):
             self.minutes_now = 10 * 60  # 10:00 AM
             self.forecast_minutes = 24 * 60  # 24 hours
             self.prefix = "predbat"
+            self.rate_store = None  # No rate persistence in tests
 
             # Initialize rate_export with base rates for each minute
             self.rate_export = {}
diff --git a/apps/predbat/tests/test_rate_store.py b/apps/predbat/tests/test_rate_store.py
index 3d9b1845b..7e4804984 100644
--- a/apps/predbat/tests/test_rate_store.py
+++ b/apps/predbat/tests/test_rate_store.py
@@ -3,423 +3,355 @@
 # Copyright Trefor Southwell 2026 - All Rights Reserved
 # This application maybe used for personal use only and not for commercial use
 # -----------------------------------------------------------------------------
-# Test rate_store persistent rate tracking with finalization
-# -----------------------------------------------------------------------------
+# fmt: off
+# pylint: disable=consider-using-f-string
+# pylint: disable=line-too-long
+# pylint: disable=attribute-defined-outside-init
 
 import os
 import json
 import shutil
 from datetime import datetime, timedelta
 from rate_store import RateStore
-from persistent_store import PersistentStore
 
 
-def run_rate_store_tests():
+def run_rate_store_tests(my_predbat):
     """
     Run comprehensive tests for rate persistence and finalization
+
+    Args:
+        my_predbat: PredBat instance (unused for these tests but required for consistency)
+
+    Returns:
+        bool: False if all tests pass, True if any test fails
     """
-    print("=" * 80)
-    print("Testing Rate Store Persistence and Finalization")
-    print("=" * 80)
-    
+    failed = False
+
     # Create test directory
     test_dir = "test_rate_store_temp"
     if os.path.exists(test_dir):
         shutil.rmtree(test_dir)
     os.makedirs(test_dir)
-    
+
     try:
-        # Test 1: Basic persistence
-        print("\n*** Test 1: Basic rate persistence ***")
-        test_basic_persistence(test_dir)
-        
-        # Test 2: Finalization
-        print("\n*** Test 2: Rate finalization ***")
-        test_finalization(test_dir)
-        
-        # Test 3: Rehydration after restart
-        print("\n*** Test 3: Rehydration after restart ***")
-        test_rehydration(test_dir)
-        
-        # Test 4: Override priority
-        print("\n*** Test 4: Override priority (manual > automatic > initial) ***")
-        test_override_priority(test_dir)
-        
-        # Test 5: Finalized rates resist new API data
-        print("\n*** Test 5: Finalized rates resist fresh API data ***")
-        test_finalized_resistance(test_dir)
-        
-        # Test 6: Automatic override removal detection
-        print("\n*** Test 6: Automatic override removal detection ***")
-        test_override_removal(test_dir)
-        
-        # Test 7: Cleanup old files
-        print("\n*** Test 7: Cleanup old files ***")
-        test_cleanup(test_dir)
-        
-        # Test 8: Slot interval mismatch handling
-        print("\n*** Test 8: Slot interval mismatch handling ***")
-        test_interval_mismatch(test_dir)
-        
-        print("\n" + "=" * 80)
-        print("All rate store tests PASSED")
-        print("=" * 80)
-        return True
-        
-    except AssertionError as e:
-        print(f"\n*** TEST FAILED: {e} ***")
-        return False
+        print("*** Test 1: Basic rate persistence")
+        failed |= test_basic_persistence(os.path.join(test_dir, "test1"))
+
+        print("*** Test 2: Rate finalization")
+        failed |= test_finalization(os.path.join(test_dir, "test2"))
+
+        print("*** Test 3: Override priority (manual > automatic > initial)")
+        failed |= test_override_priority(os.path.join(test_dir, "test3"))
+
+        print("*** Test 4: Finalized rates resist fresh API data")
+        failed |= test_finalized_resistance(os.path.join(test_dir, "test4"))
+
+        print("*** Test 5: Cleanup old files")
+        failed |= test_cleanup(os.path.join(test_dir, "test5"))
+
     finally:
         # Cleanup
         if os.path.exists(test_dir):
             shutil.rmtree(test_dir)
 
+    return failed
+
 
 def test_basic_persistence(test_dir):
     """Test basic write and read of rates"""
-    
+
+    # Create test subdirectory
+    os.makedirs(test_dir, exist_ok=True)
+
     # Create mock base object
     class MockBase:
         def __init__(self):
             self.plan_interval_minutes = 30
             self.minutes_now = 720  # 12:00
-            
+
         def log(self, msg):
             print(f"  {msg}")
-            
+
         def get_arg(self, key, default):
             if key == "rate_retention_days":
                 return 7
             return default
-    
+
     base = MockBase()
     store = RateStore(base, save_dir=test_dir)
-    
+
     # Write some base rates
     today = datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)
-    
-    # Write rates for 00:00, 00:30, 01:00
-    store.write_base_rate(today, 0, 10.0, 5.0)    # import=10p, export=5p
-    store.write_base_rate(today, 30, 12.0, 6.0)   # import=12p, export=6p
-    store.write_base_rate(today, 60, 15.0, 7.0)   # import=15p, export=7p
-    
-    # Read back
-    rate_import_0 = store.get_rate(today, 0, is_import=True)
-    rate_export_0 = store.get_rate(today, 0, is_import=False)
-    rate_import_30 = store.get_rate(today, 30, is_import=True)
-    rate_export_60 = store.get_rate(today, 60, is_import=False)
-    
-    assert rate_import_0 == 10.0, f"Expected 10.0, got {rate_import_0}"
-    assert rate_export_0 == 5.0, f"Expected 5.0, got {rate_export_0}"
-    assert rate_import_30 == 12.0, f"Expected 12.0, got {rate_import_30}"
-    assert rate_export_60 == 7.0, f"Expected 7.0, got {rate_export_60}"
-    
-    # Check file was created
-    date_str = today.strftime("%Y_%m_%d")
-    filepath = os.path.join(test_dir, f"rates_{date_str}.json")
-    assert os.path.exists(filepath), "Rate file not created"
-    
-    print("  ✓ Basic persistence working")
+
+    for hour in range(24):
+        minute = hour * 60
+        import_rate = 10.0 + hour  # Rates from 10.0 to 33.0
+        export_rate = 5.0 + hour   # Rates from 5.0 to 28.0
+        store.write_base_rate(today, minute, import_rate, export_rate)
+
+    # Verify rates written
+    for hour in range(24):
+        minute = hour * 60
+        expected_import = 10.0 + hour
+        expected_export = 5.0 + hour
+
+        actual_import = store.get_rate(today, minute, is_import=True)
+        actual_export = store.get_rate(today, minute, is_import=False)
+
+        if actual_import is None or abs(actual_import - expected_import) > 0.01:
+            print(f"  ERROR: Expected import rate {expected_import} at minute {minute}, got {actual_import}")
+            return True
+
+        if actual_export is None or abs(actual_export - expected_export) > 0.01:
+            print(f"  ERROR: Expected export rate {expected_export} at minute {minute}, got {actual_export}")
+            return True
+
+    print("  PASS: Basic persistence working")
+    return False
 
 
 def test_finalization(test_dir):
-    """Test that slots get finalized 5 minutes after start"""
-    
+    """Test that rates become finalized after their slot time + buffer"""
+
+    # Create test subdirectory
+    os.makedirs(test_dir, exist_ok=True)
+
     class MockBase:
         def __init__(self):
             self.plan_interval_minutes = 30
-            self.minutes_now = 725  # 12:05 - 5 minutes into 12:00 slot
-            
+            self.minutes_now = 720  # 12:00
+
         def log(self, msg):
             print(f"  {msg}")
-            
+
         def get_arg(self, key, default):
+            if key == "rate_retention_days":
+                return 7
             return default
-    
+
     base = MockBase()
     store = RateStore(base, save_dir=test_dir)
-    
+
+    # Write base rates for past slots (more than 5 minutes ago)
     today = datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)
-    
-    # Write rates for multiple slots
-    store.write_base_rate(today, 0, 10.0, 5.0)      # 00:00 slot (should finalize)
-    store.write_base_rate(today, 30, 12.0, 6.0)     # 00:30 slot (should finalize)
-    store.write_base_rate(today, 690, 15.0, 7.0)    # 11:30 slot (should finalize)
-    store.write_base_rate(today, 720, 20.0, 10.0)   # 12:00 slot (should finalize at 12:05)
-    store.write_base_rate(today, 750, 25.0, 12.0)   # 12:30 slot (should NOT finalize yet)
-    
-    # Finalize slots at current time (12:05)
-    finalized_count = store.finalize_slots(today, base.minutes_now)
-    
-    # Should finalize 00:00, 00:30, 11:30, 12:00 (4 slots)
-    assert finalized_count == 4, f"Expected 4 slots finalized, got {finalized_count}"
-    
-    # Check finalization status in the file
+
+    # Write rates for slots that should be finalized (00:00, 00:30, 01:00)
+    store.write_base_rate(today, 0, 15.0, 5.0)
+    store.write_base_rate(today, 30, 20.0, 10.0)
+    store.write_base_rate(today, 60, 25.0, 15.0)
+
+    # Finalize past slots (set current minute to 70 which is past 01:00+5min buffer)
+    store.finalize_slots(today, 70)
+
+    # Check that slots are finalized in the JSON file
     date_str = today.strftime("%Y_%m_%d")
-    filepath = os.path.join(test_dir, f"rates_{date_str}.json")
-    with open(filepath, 'r') as f:
+    file_path = os.path.join(test_dir, f"rates_{date_str}.json")
+
+    if not os.path.exists(file_path):
+        print(f"  ERROR: Rate file not found at {file_path}")
+        return True
+
+    with open(file_path, "r") as f:
         data = json.load(f)
-    
-    assert data['rates_import']['00:00']['finalized'] == True, "00:00 should be finalized"
-    assert data['rates_import']['12:00']['finalized'] == True, "12:00 should be finalized"
-    assert data['rates_import']['12:30']['finalized'] == False, "12:30 should NOT be finalized"
-    
-    print("  ✓ Finalization working correctly")
 
+    # Check finalized flags
+    if "rates_import" not in data or "rates_export" not in data:
+        print("  ERROR: Missing rate sections in file")
+        return True
 
-def test_rehydration(test_dir):
-    """Test that rates survive restart and are reloaded"""
-    
-    class MockBase:
-        def __init__(self):
-            self.plan_interval_minutes = 30
-            self.minutes_now = 720
-            
-        def log(self, msg):
-            print(f"  {msg}")
-            
-        def get_arg(self, key, default):
-            return 7 if key == "rate_retention_days" else default
-    
-    # First instance - write data
-    base1 = MockBase()
-    store1 = RateStore(base1, save_dir=test_dir)
-    
-    today = datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)
-    
-    # Write and finalize some rates
-    store1.write_base_rate(today, 0, 10.0, 5.0)
-    store1.write_base_rate(today, 30, 12.0, 6.0)
-    store1.update_auto_override(today, 60, 8.0, None, "IOG")  # Cheap IOG slot
-    store1.update_manual_override(today, 90, 20.0, None)      # Manual override
-    store1.finalize_slots(today, 100)  # Finalize all past slots
-    
-    # Verify initial state
-    assert store1.get_rate(today, 0, is_import=True) == 10.0
-    assert store1.get_rate(today, 30, is_import=True) == 12.0
-    assert store1.get_rate(today, 60, is_import=True) == 8.0   # IOG override
-    assert store1.get_rate(today, 90, is_import=True) == 20.0  # Manual override
-    
-    # Simulate restart - create new instance
-    base2 = MockBase()
-    store2 = RateStore(base2, save_dir=test_dir)
-    
-    # Manually load the data (simulating what constructor does)
-    store2.load_rates(today)
-    
-    # Verify data was restored
-    assert store2.get_rate(today, 0, is_import=True) == 10.0, "Initial rate not restored"
-    assert store2.get_rate(today, 30, is_import=True) == 12.0, "Initial rate not restored"
-    assert store2.get_rate(today, 60, is_import=True) == 8.0, "IOG override not restored"
-    assert store2.get_rate(today, 90, is_import=True) == 20.0, "Manual override not restored"
-    
-    print("  ✓ Rehydration after restart working")
+    # Slot at 0 should be finalized
+    if "00:00" not in data["rates_import"] or not data["rates_import"]["00:00"]["finalized"]:
+        print("  ERROR: Slot 00:00 import should be finalized")
+        return True
+
+    if "00:00" not in data["rates_export"] or not data["rates_export"]["00:00"]["finalized"]:
+        print("  ERROR: Slot 00:00 export should be finalized")
+        return True
+
+    # Slot at 30 should be finalized
+    if "00:30" not in data["rates_import"] or not data["rates_import"]["00:30"]["finalized"]:
+        print("  ERROR: Slot 00:30 import should be finalized")
+        return True
+
+    # Slot at 60 should be finalized
+    if "01:00" not in data["rates_import"] or not data["rates_import"]["01:00"]["finalized"]:
+        print("  ERROR: Slot 01:00 import should be finalized")
+        return True
+
+    print("  PASS: Finalization working correctly")
+    return False
 
 
 def test_override_priority(test_dir):
-    """Test that manual > automatic > initial priority is respected"""
-    
+    """Test that manual overrides take priority over automatic, which take priority over initial"""
+
+    # Create test subdirectory
+    os.makedirs(test_dir, exist_ok=True)
+
     class MockBase:
         def __init__(self):
             self.plan_interval_minutes = 30
-            self.minutes_now = 720
-            
+            self.minutes_now = 720  # 12:00
+
         def log(self, msg):
             print(f"  {msg}")
-            
+
         def get_arg(self, key, default):
+            if key == "rate_retention_days":
+                return 7
             return default
-    
+
     base = MockBase()
     store = RateStore(base, save_dir=test_dir)
-    
+
     today = datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)
-    
-    # Test slot at 00:00
-    # Start with initial rate
-    store.write_base_rate(today, 0, 10.0, 5.0)
-    assert store.get_rate(today, 0, is_import=True) == 10.0, "Initial rate should be 10.0"
-    
+    minute = 120  # 02:00
+
+    # Write initial rate
+    store.write_base_rate(today, minute, 10.0, 5.0)
+
+    # Check initial rate
+    rate = store.get_rate(today, minute, is_import=True)
+    if rate is None or abs(rate - 10.0) > 0.01:
+        print(f"  ERROR: Expected initial import rate 10.0, got {rate}")
+        return True
+
     # Apply automatic override (IOG)
-    store.update_auto_override(today, 0, 7.5, None, "IOG")
-    assert store.get_rate(today, 0, is_import=True) == 7.5, "Automatic override should be 7.5"
-    
-    # Apply manual override (should take priority)
-    store.update_manual_override(today, 0, 15.0, None)
-    assert store.get_rate(today, 0, is_import=True) == 15.0, "Manual override should be 15.0"
-    
-    # Clear manual override
-    store.update_manual_override(today, 0, None, None)
-    assert store.get_rate(today, 0, is_import=True) == 7.5, "Should fall back to automatic override (7.5)"
-    
-    # Clear automatic override
-    store.update_auto_override(today, 0, None, None, "IOG")
-    assert store.get_rate(today, 0, is_import=True) == 10.0, "Should fall back to initial rate (10.0)"
-    
-    print("  ✓ Override priority working correctly")
+    store.update_auto_override(today, minute, 5.0, 2.0, source="IOG")
+
+    rate = store.get_rate(today, minute, is_import=True)
+    if rate is None or abs(rate - 5.0) > 0.01:
+        print(f"  ERROR: Expected automatic import rate 5.0, got {rate}")
+        return True
+
+    # Check automatic rate directly
+    auto_rate = store.get_automatic_rate(today, minute, is_import=True)
+    if auto_rate is None or abs(auto_rate - 5.0) > 0.01:
+        print(f"  ERROR: Expected get_automatic_rate 5.0, got {auto_rate}")
+        return True
+
+    # Apply manual override
+    store.update_manual_override(today, minute, 3.0, 1.0)
+
+    rate = store.get_rate(today, minute, is_import=True)
+    if rate is None or abs(rate - 3.0) > 0.01:
+        print(f"  ERROR: Expected manual import rate 3.0, got {rate}")
+        return True
+
+    # Check automatic rate is still preserved
+    auto_rate = store.get_automatic_rate(today, minute, is_import=True)
+    if auto_rate is None or abs(auto_rate - 5.0) > 0.01:
+        print(f"  ERROR: Automatic rate should still be 5.0, got {auto_rate}")
+        return True
+
+    print("  PASS: Override priority working correctly")
+    return False
 
 
 def test_finalized_resistance(test_dir):
-    """Test that finalized rates cannot be changed by new overrides"""
-    
-    class MockBase:
-        def __init__(self):
-            self.plan_interval_minutes = 30
-            self.minutes_now = 720
-            
-        def log(self, msg):
-            print(f"  {msg}")
-            
-        def get_arg(self, key, default):
-            return default
-    
-    base = MockBase()
-    store = RateStore(base, save_dir=test_dir)
-    
-    today = datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)
-    
-    # Write initial rate and automatic override for 00:00 slot
-    store.write_base_rate(today, 0, 10.0, 5.0)
-    store.update_auto_override(today, 0, 7.5, None, "IOG")
-    assert store.get_rate(today, 0, is_import=True) == 7.5, "Should have IOG rate initially"
-    
-    # Finalize the slot
-    store.finalize_slots(today, 10)  # 10 minutes past midnight, so 00:00 is finalized
-    
-    # Try to apply new override (should be ignored for finalized slot)
-    store.update_auto_override(today, 0, 20.0, None, "IOG")
-    assert store.get_rate(today, 0, is_import=True) == 7.5, "Finalized rate should not change from IOG override"
-    
-    # Try manual override (should also be ignored)
-    store.update_manual_override(today, 0, 25.0, None)
-    assert store.get_rate(today, 0, is_import=True) == 7.5, "Finalized rate should not change from manual override"
-    
-    # Non-finalized slot should still accept changes
-    store.write_base_rate(today, 720, 12.0, 6.0)  # 12:00 slot (not finalized)
-    store.update_auto_override(today, 720, 9.0, None, "IOG")
-    assert store.get_rate(today, 720, is_import=True) == 9.0, "Non-finalized slot should accept override"
-    
-    print("  ✓ Finalized rates resist changes correctly")
-
-
-def test_override_removal(test_dir):
-    """Test detection of automatic override removal (e.g., IOG slot removed)"""
-    
+    """Test that finalized rates resist new API data"""
+
+    # Create test subdirectory
+    os.makedirs(test_dir, exist_ok=True)
+
     class MockBase:
         def __init__(self):
             self.plan_interval_minutes = 30
-            self.minutes_now = 720
-            
+            self.minutes_now = 720  # 12:00
+
         def log(self, msg):
             print(f"  {msg}")
-            
+
         def get_arg(self, key, default):
+            if key == "rate_retention_days":
+                return 7
             return default
-    
+
     base = MockBase()
     store = RateStore(base, save_dir=test_dir)
-    
+
     today = datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)
-    
-    # Set up a future slot with IOG override
-    store.write_base_rate(today, 1440, 15.0, 7.0)  # Tomorrow 00:00
-    store.update_auto_override(today, 1440, 7.5, None, "IOG")
-    assert store.get_rate(today, 1440, is_import=True) == 7.5, "Should have IOG override"
-    
-    # Remove the IOG override (simulating Octopus removing the slot)
-    store.update_auto_override(today, 1440, None, None, "IOG")
-    assert store.get_rate(today, 1440, is_import=True) == 15.0, "Should fall back to base rate"
-    
-    # Verify in file
-    date_str = today.strftime("%Y_%m_%d")
-    filepath = os.path.join(test_dir, f"rates_{date_str}.json")
-    with open(filepath, 'r') as f:
-        data = json.load(f)
-    
-    assert data['rates_import']['24:00']['automatic'] is None, "Automatic override should be cleared"
-    
-    print("  ✓ Override removal detection working")
+    minute = 0  # 00:00
+
+    # Write initial rate
+    store.write_base_rate(today, minute, 15.0, 5.0)
+
+    # Finalize it (minute 10 is past minute 0 + 5 minute buffer)
+    store.finalize_slots(today, 10)
+
+    # Try to overwrite with new API data
+    store.write_base_rate(today, minute, 25.0, 10.0)
+
+    # Should still be 15.0 (finalized rate resists changes)
+    rate = store.get_rate(today, minute, is_import=True)
+    if rate is None or abs(rate - 15.0) > 0.01:
+        print(f"  ERROR: Finalized import rate changed from 15.0 to {rate}")
+        return True
+
+    # Export should also resist
+    export_rate = store.get_rate(today, minute, is_import=False)
+    if export_rate is None or abs(export_rate - 5.0) > 0.01:
+        print(f"  ERROR: Finalized export rate changed from 5.0 to {export_rate}")
+        return True
+
+    print("  PASS: Finalized rates resist new API data")
+    return False
 
 
 def test_cleanup(test_dir):
     """Test cleanup of old rate files"""
-    
+
+    # Create test subdirectory
+    os.makedirs(test_dir, exist_ok=True)
+
     class MockBase:
         def __init__(self):
             self.plan_interval_minutes = 30
-            self.minutes_now = 720
-            
+            self.minutes_now = 720  # 12:00
+
         def log(self, msg):
             print(f"  {msg}")
-            
+
         def get_arg(self, key, default):
+            if key == "rate_retention_days":
+                return 7
             return default
-    
+
     base = MockBase()
     store = RateStore(base, save_dir=test_dir)
-    
-    # Create old rate files
+
+    # Create some old rate files manually
     today = datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)
-    
+
     for days_ago in range(10):
         old_date = today - timedelta(days=days_ago)
-        store.write_base_rate(old_date, 0, 10.0, 5.0)
-    
-    # Should have 10 files
-    files = [f for f in os.listdir(test_dir) if f.startswith("rates_") and f.endswith(".json")]
-    assert len(files) == 10, f"Expected 10 files, got {len(files)}"
-    
-    # Cleanup with 7 day retention
-    removed = store.cleanup_old_files(retention_days=7)
-    
-    # Should remove 3 files (8, 9, 10 days old)
-    assert removed == 3, f"Expected 3 files removed, got {removed}"
-    
-    # Should have 7 files remaining
-    files = [f for f in os.listdir(test_dir) if f.startswith("rates_") and f.endswith(".json")]
-    assert len(files) == 7, f"Expected 7 files remaining, got {len(files)}"
-    
-    print("  ✓ Cleanup working correctly")
-
-
-def test_interval_mismatch(test_dir):
-    """Test handling of plan_interval_minutes mismatch"""
-    
-    class MockBase:
-        def __init__(self, interval=30):
-            self.plan_interval_minutes = interval
-            self.minutes_now = 720
-            
-        def log(self, msg):
-            print(f"  {msg}")
-            
-        def get_arg(self, key, default):
-            return default
-    
-    # Create file with 30-minute intervals
-    base1 = MockBase(interval=30)
-    store1 = RateStore(base1, save_dir=test_dir)
-    
-    today = datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)
-    store1.write_base_rate(today, 0, 10.0, 5.0)
-    store1.write_base_rate(today, 30, 12.0, 6.0)
-    
-    # Try to load with different interval (should backup and restart)
-    base2 = MockBase(interval=60)
-    store2 = RateStore(base2, save_dir=test_dir)
-    
-    # Should have created backup
-    date_str = today.strftime("%Y_%m_%d")
-    backup_path = os.path.join(test_dir, f"rates_{date_str}.json.bak")
-    assert os.path.exists(backup_path), "Backup file should be created on interval mismatch"
-    
-    # Load data - should have new empty structure with 60-minute interval
-    data = store2.load_rates(today)
-    assert data['plan_interval_minutes'] == 60, "Should have new interval"
-    
-    print("  ✓ Interval mismatch handled correctly")
-
-
-if __name__ == "__main__":
-    success = run_rate_store_tests()
-    exit(0 if success else 1)
+        date_str = old_date.strftime("%Y_%m_%d")
+        file_path = os.path.join(test_dir, f"rates_{date_str}.json")
+
+        # Write dummy data
+        with open(file_path, "w") as f:
+            json.dump({
+                "rates_import": {},
+                "rates_export": {},
+                "last_updated": old_date.isoformat()
+            }, f)
+
+        # Set file modification time to match the date (so cleanup works correctly)
+        old_timestamp = (old_date - timedelta(hours=12)).timestamp()  # Set to noon of that day
+        os.utime(file_path, (old_timestamp, old_timestamp))
+
+    # Run cleanup with 7 days retention
+    retention_days = 7
+    store.cleanup_old_files(retention_days)
+
+    # Check files - should have at most retention_days + 1 (today) files
+    remaining_files = [f for f in os.listdir(test_dir) if f.startswith("rates_") and f.endswith(".json") and not f.endswith(".bak")]
+
+    # Should have at most 7 days of retention + today = 8 files
+    if len(remaining_files) > 8:
+        print(f"  ERROR: Expected <= 8 files after cleanup, found {len(remaining_files)}")
+        print(f"  Files: {sorted(remaining_files)}")
+        return True
+
+    print("  PASS: Cleanup working correctly")
+    return False

From 906c9cbfd1f25111b57754b2968d45e5b5055fc4 Mon Sep 17 00:00:00 2001
From: Rob Aldred <rob@residently.com>
Date: Wed, 4 Feb 2026 12:58:48 +0000
Subject: [PATCH 12/12] Correct rate store finalised

---
 apps/predbat/rate_store.py            | 57 ++++++++++++------------
 apps/predbat/tests/test_rate_store.py | 62 +++++++++++++--------------
 2 files changed, 59 insertions(+), 60 deletions(-)

diff --git a/apps/predbat/rate_store.py b/apps/predbat/rate_store.py
index cb31085ab..2c8d70117 100644
--- a/apps/predbat/rate_store.py
+++ b/apps/predbat/rate_store.py
@@ -27,7 +27,7 @@ class RateStore(PersistentStore):
     - initial: Base rate from API at first retrieval
     - automatic: Override from external services (IOG, Axle, saving sessions)
     - manual: User override from manual selectors
-    - finalized: Lock flag set 5 minutes past slot start time
+    - finalised: Lock flag set 5 minutes past slot start time
 
     File structure: predbat_save/rates_YYYY_MM_DD.json
     """
@@ -54,11 +54,11 @@ def __init__(self, base, save_dir="predbat_save"):
         self.load_rates(today)
         self.load_rates(yesterday)
 
-        # Finalize past slots
-        finalized_today = self.finalize_slots(today, base.minutes_now)
-        finalized_yesterday = self.finalize_slots(yesterday, 24 * 60)  # Finalize all yesterday slots
-        if finalized_today > 0 or finalized_yesterday > 0:
-            self.log("Finalized {} slots for today and {} slots for yesterday".format(finalized_today, finalized_yesterday))
+        # Finalise past slots
+        finalised_today = self.finalise_slots(today, base.minutes_now)
+        finalised_yesterday = self.finalise_slots(yesterday, 24 * 60)  # Finalise all yesterday slots
+        if finalised_today > 0 or finalised_yesterday > 0:
+            self.log("Finalised {} slots for today and {} slots for yesterday".format(finalised_today, finalised_yesterday))
 
         # Cleanup old rate files
         retention_days = base.get_arg("rate_retention_days", 7)
@@ -142,13 +142,13 @@ def _init_empty_slot(self):
         Create empty slot structure.
 
         Returns:
-            Dict with initial/automatic/manual/finalized fields
+            Dict with initial/automatic/manual/finalised fields
         """
         return {
             'initial': None,
             'automatic': None,
             'manual': None,
-            'finalized': False
+            'finalised': False
         }
 
     def load_rates(self, date):
@@ -256,7 +256,7 @@ def write_base_rate(self, date, minute, rate_import, rate_export):
     def update_auto_override(self, date, minute, rate_import, rate_export, source):
         """
         Update automatic override rate for a slot (IOG, Axle, saving sessions).
-        Only updates non-finalized slots.
+        Only updates non-finalised slots.
 
         Args:
             date: datetime object for the date
@@ -278,9 +278,8 @@ def update_auto_override(self, date, minute, rate_import, rate_export, source):
         if slot_time not in data['rates_export']:
             data['rates_export'][slot_time] = self._init_empty_slot()
 
-        # Check if slot is finalized
-        if data['rates_import'][slot_time]['finalized']:
-            # Don't modify finalized slots
+        if data['rates_import'][slot_time]['finalised']:
+            # Don't modify finalised slots
             return
 
         # Store override with source tracking
@@ -311,7 +310,7 @@ def update_auto_override(self, date, minute, rate_import, rate_export, source):
     def update_manual_override(self, date, minute, rate_import, rate_export):
         """
         Update manual override rate for a slot (from user selectors).
-        Only updates non-finalized slots.
+        Only updates non-finalised slots.
 
         Args:
             date: datetime object for the date
@@ -332,9 +331,9 @@ def update_manual_override(self, date, minute, rate_import, rate_export):
         if slot_time not in data['rates_export']:
             data['rates_export'][slot_time] = self._init_empty_slot()
 
-        # Check if slot is finalized
-        if data['rates_import'][slot_time]['finalized']:
-            # Don't modify finalized slots
+        # Check if slot is finalised
+        if data['rates_import'][slot_time]['finalised']:
+            # Don't modify finalised slots
             return
 
         # Store manual override
@@ -344,39 +343,39 @@ def update_manual_override(self, date, minute, rate_import, rate_export):
         # Save immediately
         self.save_rates(date)
 
-    def finalize_slots(self, date, current_minute):
+    def finalise_slots(self, date, current_minute):
         """
-        Finalize all slots that have passed their start time by 5+ minutes.
-        Finalized slots cannot be modified by overrides.
+        Finalise all slots that have passed their start time by 5+ minutes.
+        Finalised slots cannot be modified by overrides.
 
         Args:
             date: datetime object for the date
             current_minute: Current minute offset from midnight
 
         Returns:
-            Number of slots finalized
+            Number of slots finalised
         """
         # Load rate data
         data = self.load_rates(date)
 
-        finalized_count = 0
+        finalised_count = 0
 
         # Process all slots
         for slot_time in data['rates_import'].keys():
             slot_minute = self._time_to_minutes(slot_time)
 
-            # Check if slot should be finalized
-            # Finalize if current time is 5+ minutes past slot start
+            # Check if slot should be finalised
+            # Finalise if current time is 5+ minutes past slot start
             if current_minute >= slot_minute + 5:
-                if not data['rates_import'][slot_time]['finalized']:
-                    data['rates_import'][slot_time]['finalized'] = True
-                    data['rates_export'][slot_time]['finalized'] = True
-                    finalized_count += 1
+                if not data['rates_import'][slot_time]['finalised']:
+                    data['rates_import'][slot_time]['finalised'] = True
+                    data['rates_export'][slot_time]['finalised'] = True
+                    finalised_count += 1
 
-        if finalized_count > 0:
+        if finalised_count > 0:
             self.save_rates(date)
 
-        return finalized_count
+        return finalised_count
 
     def get_rate(self, date, minute, is_import=True):
         """
diff --git a/apps/predbat/tests/test_rate_store.py b/apps/predbat/tests/test_rate_store.py
index 7e4804984..8c908be0e 100644
--- a/apps/predbat/tests/test_rate_store.py
+++ b/apps/predbat/tests/test_rate_store.py
@@ -17,7 +17,7 @@
 
 def run_rate_store_tests(my_predbat):
     """
-    Run comprehensive tests for rate persistence and finalization
+    Run comprehensive tests for rate persistence and finalisation
 
     Args:
         my_predbat: PredBat instance (unused for these tests but required for consistency)
@@ -37,14 +37,14 @@ def run_rate_store_tests(my_predbat):
         print("*** Test 1: Basic rate persistence")
         failed |= test_basic_persistence(os.path.join(test_dir, "test1"))
 
-        print("*** Test 2: Rate finalization")
-        failed |= test_finalization(os.path.join(test_dir, "test2"))
+        print("*** Test 2: Rate finalisation")
+        failed |= test_finalisation(os.path.join(test_dir, "test2"))
 
         print("*** Test 3: Override priority (manual > automatic > initial)")
         failed |= test_override_priority(os.path.join(test_dir, "test3"))
 
-        print("*** Test 4: Finalized rates resist fresh API data")
-        failed |= test_finalized_resistance(os.path.join(test_dir, "test4"))
+        print("*** Test 4: Finalised rates resist fresh API data")
+        failed |= test_finalised_resistance(os.path.join(test_dir, "test4"))
 
         print("*** Test 5: Cleanup old files")
         failed |= test_cleanup(os.path.join(test_dir, "test5"))
@@ -110,8 +110,8 @@ def get_arg(self, key, default):
     return False
 
 
-def test_finalization(test_dir):
-    """Test that rates become finalized after their slot time + buffer"""
+def test_finalisation(test_dir):
+    """Test that rates become finalised after their slot time + buffer"""
 
     # Create test subdirectory
     os.makedirs(test_dir, exist_ok=True)
@@ -135,13 +135,13 @@ def get_arg(self, key, default):
     # Write base rates for past slots (more than 5 minutes ago)
     today = datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)
 
-    # Write rates for slots that should be finalized (00:00, 00:30, 01:00)
+    # Write rates for slots that should be finalised (00:00, 00:30, 01:00)
     store.write_base_rate(today, 0, 15.0, 5.0)
     store.write_base_rate(today, 30, 20.0, 10.0)
     store.write_base_rate(today, 60, 25.0, 15.0)
 
-    # Finalize past slots (set current minute to 70 which is past 01:00+5min buffer)
-    store.finalize_slots(today, 70)
+    # Finalise past slots (set current minute to 70 which is past 01:00+5min buffer)
+    store.finalise_slots(today, 70)
 
     # Check that slots are finalized in the JSON file
     date_str = today.strftime("%Y_%m_%d")
@@ -154,31 +154,31 @@ def get_arg(self, key, default):
     with open(file_path, "r") as f:
         data = json.load(f)
 
-    # Check finalized flags
+    # Check finalised flags
     if "rates_import" not in data or "rates_export" not in data:
         print("  ERROR: Missing rate sections in file")
         return True
 
-    # Slot at 0 should be finalized
-    if "00:00" not in data["rates_import"] or not data["rates_import"]["00:00"]["finalized"]:
-        print("  ERROR: Slot 00:00 import should be finalized")
+    # Slot at 0 should be finalised
+    if "00:00" not in data["rates_import"] or not data["rates_import"]["00:00"]["finalised"]:
+        print("  ERROR: Slot 00:00 import should be finalised")
         return True
 
-    if "00:00" not in data["rates_export"] or not data["rates_export"]["00:00"]["finalized"]:
-        print("  ERROR: Slot 00:00 export should be finalized")
+    if "00:00" not in data["rates_export"] or not data["rates_export"]["00:00"]["finalised"]:
+        print("  ERROR: Slot 00:00 export should be finalised")
         return True
 
-    # Slot at 30 should be finalized
-    if "00:30" not in data["rates_import"] or not data["rates_import"]["00:30"]["finalized"]:
-        print("  ERROR: Slot 00:30 import should be finalized")
+    # Slot at 30 should be finalised
+    if "00:30" not in data["rates_import"] or not data["rates_import"]["00:30"]["finalised"]:
+        print("  ERROR: Slot 00:30 import should be finalised")
         return True
 
-    # Slot at 60 should be finalized
-    if "01:00" not in data["rates_import"] or not data["rates_import"]["01:00"]["finalized"]:
-        print("  ERROR: Slot 01:00 import should be finalized")
+    # Slot at 60 should be finalised
+    if "01:00" not in data["rates_import"] or not data["rates_import"]["01:00"]["finalised"]:
+        print("  ERROR: Slot 01:00 import should be finalised")
         return True
 
-    print("  PASS: Finalization working correctly")
+    print("  PASS: Finalisation working correctly")
     return False
 
 
@@ -248,8 +248,8 @@ def get_arg(self, key, default):
     return False
 
 
-def test_finalized_resistance(test_dir):
-    """Test that finalized rates resist new API data"""
+def test_finalised_resistance(test_dir):
+    """Test that finalised rates resist new API data"""
 
     # Create test subdirectory
     os.makedirs(test_dir, exist_ok=True)
@@ -276,25 +276,25 @@ def get_arg(self, key, default):
     # Write initial rate
     store.write_base_rate(today, minute, 15.0, 5.0)
 
-    # Finalize it (minute 10 is past minute 0 + 5 minute buffer)
-    store.finalize_slots(today, 10)
+    # Finalise it (minute 10 is past minute 0 + 5 minute buffer)
+    store.finalise_slots(today, 10)
 
     # Try to overwrite with new API data
     store.write_base_rate(today, minute, 25.0, 10.0)
 
-    # Should still be 15.0 (finalized rate resists changes)
+    # Should still be 15.0 (finalised rate resists changes)
     rate = store.get_rate(today, minute, is_import=True)
     if rate is None or abs(rate - 15.0) > 0.01:
-        print(f"  ERROR: Finalized import rate changed from 15.0 to {rate}")
+        print(f"  ERROR: Finalised import rate changed from 15.0 to {rate}")
         return True
 
     # Export should also resist
     export_rate = store.get_rate(today, minute, is_import=False)
     if export_rate is None or abs(export_rate - 5.0) > 0.01:
-        print(f"  ERROR: Finalized export rate changed from 5.0 to {export_rate}")
+        print(f"  ERROR: Finalised export rate changed from 5.0 to {export_rate}")
         return True
 
-    print("  PASS: Finalized rates resist new API data")
+    print("  PASS: Finalised rates resist new API data")
     return False