Fixes to ge cloud timeout

fixes to logfile search on web
fixes to code for dynamic load

Author: springfall2008

apps/predbat/gecloud.py

@@ -6,7 +6,7 @@
 
 import requests
 from datetime import timedelta, datetime, timezone
-from utils import str2time, dp1
+from utils import str2time, dp1, dp2
 import asyncio
 import random
 import time
@@ -224,7 +224,7 @@ def wait_api_started(self):
         """
         self.log("GECloud: Waiting for API to start")
         count = 0
-        while not self.api_started and count < 120:
+        while not self.api_started and count < 240:
             time.sleep(1)
             count += 1
         if not self.api_started:
@@ -1391,5 +1391,29 @@ def download_ge_data(self, now_utc):
         self.import_today_now = self.import_today.get(0, 0) - self.import_today.get(self.minutes_now, 0)
         self.export_today_now = self.export_today.get(0, 0) - self.export_today.get(self.minutes_now, 0)
         self.pv_today_now = self.pv_today.get(0, 0) - self.pv_today.get(self.minutes_now, 0)
+
+
+        self.log("GE GECloud load_last_period is {} kW".format(dp2(self.load_last_period)))
+        # More up to date sensors for current values if set
+        if "load_today" in self.args:
+            load_minutes, load_minutes_age = self.minute_data_load(self.now_utc, "load_today", self.max_days_previous, required_unit="kWh", load_scaling=self.load_scaling)
+            self.load_minutes_now = max(load_minutes.get(0, 0) - load_minutes.get(self.minutes_now, 0), 0)
+            self.load_last_period = (load_minutes.get(0, 0) - load_minutes.get(PREDICT_STEP, 0)) * 60 / PREDICT_STEP
+            self.log("GE GECloud load_last_period from immediate sensor is {} kW".format(dp2(self.load_last_period)))
+
+        if "import_today" in self.args:
+            import_today = self.minute_data_import_export(self.now_utc, "import_today", scale=self.import_export_scaling, required_unit="kWh")
+            self.import_today_now = max(import_today.get(0, 0) - import_today.get(self.minutes_now, 0), 0)
+
+        # Load export today data
+        if "export_today" in self.args:
+            export_today = self.minute_data_import_export(self.now_utc, "export_today", scale=self.import_export_scaling, required_unit="kWh")
+            self.export_today_now = max(export_today.get(0, 0) - export_today.get(self.minutes_now, 0), 0)
+
+        # PV today data
+        if "pv_today" in self.args:
+            pv_today = self.minute_data_import_export(self.now_utc, "pv_today", required_unit="kWh")
+            self.pv_today_now = max(pv_today.get(0, 0) - pv_today.get(self.minutes_now, 0), 0)
+
         self.log("Downloaded {} datapoints from GE going back {} days".format(len(self.load_minutes), self.load_minutes_age))
         return True

apps/predbat/plan.py

@@ -13,7 +13,7 @@
 from datetime import datetime, timedelta
 from multiprocessing import Pool, cpu_count
 from config import PREDICT_STEP, TIME_FORMAT, MINUTE_WATT
-from utils import calc_percent_limit, dp0, dp1, dp2, dp3, dp4, remove_intersecting_windows, calc_percent_limit
+from utils import calc_percent_limit, dp0, dp1, dp2, dp3, dp4, remove_intersecting_windows, calc_percent_limit, in_car_slot
 from prediction import Prediction, wrapped_run_prediction_single, wrapped_run_prediction_charge, wrapped_run_prediction_charge_min_max, wrapped_run_prediction_export, wrapped_run_prediction_charge_min_max
 
 """
@@ -64,7 +64,7 @@ def dynamic_load(self):
             if self.load_last_status == "high":
                 have_printed = False
                 for minute_absolute in range(minutes_now, minutes_end_slot, PREDICT_STEP):
-                    car_load = self.in_car_slot(minute_absolute)
+                    car_load = sum(in_car_slot(minute_absolute, self.num_cars, self.car_charging_slots))
                     load_last_period = self.load_last_period / 60 * PREDICT_STEP
                     load_last_period = max(load_last_period - car_load, 0)
                     if load_last_period > 0:

apps/predbat/prediction.py

@@ -10,7 +10,7 @@
 
 from datetime import timedelta
 from config import PREDICT_STEP, RUN_EVERY, TIME_FORMAT
-from utils import remove_intersecting_windows, get_charge_rate_curve, get_discharge_rate_curve, find_charge_rate, calc_percent_limit
+from utils import remove_intersecting_windows, get_charge_rate_curve, get_discharge_rate_curve, find_charge_rate, calc_percent_limit, in_iboost_slot, in_car_slot
 
 
 # Only assign globals once to avoid re-creating them with processes are forked
@@ -366,47 +366,6 @@ def find_charge_window_optimised(self, charge_windows, charge_limit, is_export=F
                     charge_window_optimised[minute] = window_n
         return charge_window_optimised
 
-    def in_iboost_slot(self, minute):
-        """
-        Is the given minute inside a car slot
-        """
-        load_amount = 0
-
-        if self.iboost_plan:
-            for slot in self.iboost_plan:
-                start_minutes = slot["start"]
-                end_minutes = slot["end"]
-                kwh = slot["kwh"]
-                slot_minutes = end_minutes - start_minutes
-                slot_hours = slot_minutes / 60.0
-
-                # Return the load in that slot
-                if minute >= start_minutes and minute < end_minutes:
-                    load_amount = abs(kwh / slot_hours)
-                    break
-        return load_amount
-
-    def in_car_slot(self, minute):
-        """
-        Is the given minute inside a car slot
-        """
-        load_amount = [0 for car_n in range(self.num_cars)]
-
-        for car_n in range(self.num_cars):
-            if self.car_charging_slots[car_n]:
-                for slot in self.car_charging_slots[car_n]:
-                    start_minutes = slot["start"]
-                    end_minutes = slot["end"]
-                    kwh = slot["kwh"]
-                    slot_minutes = end_minutes - start_minutes
-                    slot_hours = slot_minutes / 60.0
-
-                    # Return the load in that slot
-                    if minute >= start_minutes and minute < end_minutes:
-                        load_amount[car_n] = abs(kwh / slot_hours)
-                        break
-        return load_amount
-
     def run_prediction(self, charge_limit, charge_window, export_window, export_limits, pv10, end_record, save=None, step=PREDICT_STEP, cache=False):
         """
         Run a prediction scenario given a charge limit, return the results
@@ -679,7 +638,7 @@ def run_prediction(self, charge_limit, charge_window, export_window, export_limi
             car_freeze = False
 
             if car_enable:
-                car_load = self.in_car_slot(minute_absolute)
+                car_load = in_car_slot(minute_absolute, self.num_cars, self.car_charging_slots)
 
                 # Car charging?
                 for car_n in range(self.num_cars):
@@ -724,7 +683,7 @@ def run_prediction(self, charge_limit, charge_window, export_window, export_limi
                 # IBoost solar diverter on load, don't do on discharge
                 # IBoost based on plan for given rates
                 if self.iboost_plan and (self.iboost_on_export or (export_window_n < 0)):
-                    iboost_load = self.in_iboost_slot(minute_absolute) * step / 60.0
+                    iboost_load = in_iboost_slot(minute_absolute, self.iboost_plan) * step / 60.0
                     iboost_amount = min(iboost_load, self.iboost_max_power * step, max(self.iboost_max_energy - iboost_today_kwh, 0))
 
                 # IBoost based on Predbat charging

apps/predbat/utils.py

@@ -12,6 +12,47 @@
 from config import MINUTE_WATT, PREDICT_STEP, TIME_FORMAT, TIME_FORMAT_SECONDS, TIME_FORMAT_OCTOPUS
 
 
+def in_iboost_slot(minute, iboost_plan):
+    """
+    Is the given minute inside a car slot
+    """
+    load_amount = 0
+
+    if iboost_plan:
+        for slot in iboost_plan:
+            start_minutes = slot["start"]
+            end_minutes = slot["end"]
+            kwh = slot["kwh"]
+            slot_minutes = end_minutes - start_minutes
+            slot_hours = slot_minutes / 60.0
+
+            # Return the load in that slot
+            if minute >= start_minutes and minute < end_minutes:
+                load_amount = abs(kwh / slot_hours)
+                break
+    return load_amount
+
+def in_car_slot(minute, num_cars, car_charging_slots):
+    """
+    Is the given minute inside a car slot
+    """
+    load_amount = [0 for car_n in range(num_cars)]
+
+    for car_n in range(num_cars):
+        if car_charging_slots[car_n]:
+            for slot in car_charging_slots[car_n]:
+                start_minutes = slot["start"]
+                end_minutes = slot["end"]
+                kwh = slot["kwh"]
+                slot_minutes = end_minutes - start_minutes
+                slot_hours = slot_minutes / 60.0
+
+                # Return the load in that slot
+                if minute >= start_minutes and minute < end_minutes:
+                    load_amount[car_n] = abs(kwh / slot_hours)
+                    break
+    return load_amount
+
 def time_string_to_stamp(time_string):
     """
     Convert a time string to a timestamp

apps/predbat/web_helper.py

@@ -1891,12 +1891,14 @@ def get_log_css():
 }
 
 /* Highlight matching text */
-.search-highlight {
+mark.search-highlight {
     background-color: #ffeb3b;
     font-weight: bold;
+    padding: 0;
+    border-radius: 2px;
 }
 
-body.dark-mode .search-highlight {
+body.dark-mode mark.search-highlight {
     background-color: #ffa000;
     color: #000;
 }
@@ -2364,7 +2366,7 @@ def get_logfile_js(filter_type):
                 // Re-apply filter to include new entries
                 setTimeout(() => {{
                     filterLogEntries();
-                }}, 10);
+                }}, 50);
             }}
 
             // Auto-scroll to top for new entries (since newest are at top)
@@ -2393,7 +2395,7 @@ def get_logfile_js(filter_type):
             const searchTerm = document.getElementById('logSearchInput').value.toLowerCase();
             const rows = document.querySelectorAll('#logTableBody tr[data-line]');
             const statusDiv = document.getElementById('searchStatus');
-
+            
             let visibleCount = 0;
             let totalCount = rows.length;
 
@@ -2402,10 +2404,7 @@ def get_logfile_js(filter_type):
                 rows.forEach(row => {{
                     row.classList.remove('log-entry-hidden');
                     // Remove any existing highlights
-                    const cells = row.querySelectorAll('td');
-                    cells.forEach(cell => {{
-                        cell.innerHTML = cell.innerHTML.replace(/<mark class="search-highlight">(.*?)<\\/mark>/gi, '$1');
-                    }});
+                    clearHighlights(row);
                     visibleCount++;
                 }});
                 statusDiv.textContent = '';
@@ -2415,36 +2414,89 @@ def get_logfile_js(filter_type):
             // Filter and highlight entries
             rows.forEach(row => {{
                 const rowText = row.textContent.toLowerCase();
-
+                
                 if (rowText.includes(searchTerm)) {{
                     row.classList.remove('log-entry-hidden');
                     visibleCount++;
-
-                    // Highlight matching text
-                    const cells = row.querySelectorAll('td');
-                    cells.forEach(cell => {{
-                        // First remove any existing highlights
-                        cell.innerHTML = cell.innerHTML.replace(/<mark class="search-highlight">(.*?)<\\/mark>/gi, '$1');
-
-                        // Then add new highlights
-                        const regex = new RegExp(`(${{escapeRegExp(searchTerm)}})`, 'gi');
-                        cell.innerHTML = cell.innerHTML.replace(regex, '<mark class="search-highlight">$1</mark>');
-                    }});
+                    
+                    // Clear existing highlights first
+                    clearHighlights(row);
+                    
+                    // Apply new highlights
+                    highlightTextInElement(row, searchTerm);
                 }} else {{
                     row.classList.add('log-entry-hidden');
-                    // Remove highlights from hidden rows
-                    const cells = row.querySelectorAll('td');
-                    cells.forEach(cell => {{
-                        cell.innerHTML = cell.innerHTML.replace(/<mark class="search-highlight">(.*?)<\\/mark>/gi, '$1');
-                    }});
+                    // Clear highlights from hidden rows
+                    clearHighlights(row);
                 }}
             }});
 
             // Update status
             statusDiv.textContent = `Showing ${{visibleCount}} of ${{totalCount}} entries`;
         }}
 
-        // Clear search function
+        // Clear all highlights in an element
+        function clearHighlights(element) {{
+            const highlightedElements = element.querySelectorAll('.search-highlight');
+            highlightedElements.forEach(highlighted => {{
+                const parent = highlighted.parentNode;
+                parent.replaceChild(document.createTextNode(highlighted.textContent), highlighted);
+                parent.normalize(); // Merge adjacent text nodes
+            }});
+        }}
+
+        // Highlight text in an element without corrupting HTML
+        function highlightTextInElement(element, searchTerm) {{
+            const walker = document.createTreeWalker(
+                element,
+                NodeFilter.SHOW_TEXT,
+                null,
+                false
+            );
+
+            const textNodes = [];
+            let node;
+            while (node = walker.nextNode()) {{
+                textNodes.push(node);
+            }}
+
+            textNodes.forEach(textNode => {{
+                const text = textNode.textContent;
+                const lowerText = text.toLowerCase();
+                const lowerSearchTerm = searchTerm.toLowerCase();
+                
+                if (lowerText.includes(lowerSearchTerm)) {{
+                    const parent = textNode.parentNode;
+                    const fragment = document.createDocumentFragment();
+                    
+                    let lastIndex = 0;
+                    let index = lowerText.indexOf(lowerSearchTerm, 0);
+                    
+                    while (index !== -1) {{
+                        // Add text before the match
+                        if (index > lastIndex) {{
+                            fragment.appendChild(document.createTextNode(text.substring(lastIndex, index)));
+                        }}
+                        
+                        // Add highlighted match
+                        const mark = document.createElement('mark');
+                        mark.className = 'search-highlight';
+                        mark.textContent = text.substring(index, index + searchTerm.length);
+                        fragment.appendChild(mark);
+                        
+                        lastIndex = index + searchTerm.length;
+                        index = lowerText.indexOf(lowerSearchTerm, lastIndex);
+                    }}
+                    
+                    // Add remaining text
+                    if (lastIndex < text.length) {{
+                        fragment.appendChild(document.createTextNode(text.substring(lastIndex)));
+                    }}
+                    
+                    parent.replaceChild(fragment, textNode);
+                }}
+            }});
+        }}        // Clear search function
         function clearLogSearch() {{
             document.getElementById('logSearchInput').value = '';
             filterLogEntries();