Fix race conditions, error handling, timezone, divergence check

backend/api/main.py

@@ -196,15 +196,16 @@ async def lifespan(app: FastAPI):
 
     # Start background refresh loops
     import asyncio
-    ims_task = asyncio.create_task(_ims_refresh_loop())
-    sensor_task = asyncio.create_task(_sensor_refresh_loop())
-    alert_task = asyncio.create_task(_data_flow_alert_loop())
-
-    yield
-    ims_task.cancel()
-    sensor_task.cancel()
-    alert_task.cancel()
-    log.info("SolarWine API shutting down (uptime=%.0fs)", get_uptime())
+    tasks: list[asyncio.Task] = []
+    try:
+        tasks.append(asyncio.create_task(_ims_refresh_loop()))
+        tasks.append(asyncio.create_task(_sensor_refresh_loop()))
+        tasks.append(asyncio.create_task(_data_flow_alert_loop()))
+        yield
+    finally:
+        for t in tasks:
+            t.cancel()
+        log.info("SolarWine API shutting down (uptime=%.0fs)", get_uptime())
 
 
 def get_uptime() -> float:

backend/api/routes/chatbot.py

@@ -45,13 +45,11 @@ _chatbot_init_failed = False
 
 def _get_chatbot(hub: DataHub):
     global _chatbot, _chatbot_init_failed
-    if _chatbot is not None:
-        return _chatbot
-    if _chatbot_init_failed:
-        return None
     with _chatbot_lock:
         if _chatbot is not None:
             return _chatbot
+        if _chatbot_init_failed:
+            return None
         try:
             from src.chatbot.vineyard_chatbot import VineyardChatbot
             _chatbot = VineyardChatbot(hub=hub)
@@ -90,7 +88,8 @@ async def chat_briefing(hub: DataHub = Depends(get_datahub)):
     if bot is None:
         raise HTTPException(status_code=503, detail="Chatbot unavailable")
     try:
-        return {"briefing": bot._build_status_briefing()}
+        briefing_fn = getattr(bot, "build_status_briefing", None) or getattr(bot, "_build_status_briefing", None)
+        return {"briefing": briefing_fn() if briefing_fn else ""}
     except Exception as exc:
         log.error("Briefing error: %s", exc)
         return {"briefing": ""}

backend/api/routes/energy.py

@@ -8,6 +8,7 @@ import re
 from fastapi import APIRouter, Depends, HTTPException, Query
 
 from backend.api.deps import get_datahub
+from backend.api.utils import check_service_error
 from src.data.data_providers import DataHub
 
 log = logging.getLogger(__name__)
@@ -22,26 +23,17 @@ def _validate_date(value: str) -> str:
     return value
 
 
-def _check_error(result: dict, context: str = "") -> dict:
-    """If a data provider returned an error dict, raise HTTPException."""
-    if isinstance(result, dict) and "error" in result and result.get("daily_kwh") is None:
-        msg = result["error"]
-        log.warning("Data provider error%s: %s", f" ({context})" if context else "", msg)
-        raise HTTPException(status_code=502, detail=msg)
-    return result
-
-
 @router.get("/current")
 async def energy_current(hub: DataHub = Depends(get_datahub)):
     result = hub.energy.get_current()
-    return _check_error(result, "energy current")
+    return check_service_error(result, "energy current")
 
 
 @router.get("/daily/{target_date}")
 async def energy_daily(target_date: str, hub: DataHub = Depends(get_datahub)):
     _validate_date(target_date)
     result = hub.energy.get_daily_production(target_date=target_date)
-    return _check_error(result, "energy daily")
+    return check_service_error(result, "energy daily")
 
 
 @router.get("/history")
@@ -50,11 +42,11 @@ async def energy_history(
     hub: DataHub = Depends(get_datahub),
 ):
     result = hub.energy.get_history(hours_back=hours)
-    return _check_error(result, "energy history")
+    return check_service_error(result, "energy history")
 
 
 @router.get("/predict/{target_date}")
 async def energy_predict(target_date: str, hub: DataHub = Depends(get_datahub)):
     _validate_date(target_date)
     result = hub.energy.predict(target_date=target_date)
-    return _check_error(result, "energy predict")
+    return check_service_error(result, "energy predict")

backend/api/routes/health.py

@@ -34,7 +34,10 @@ async def _check_thingsboard() -> bool:
 @router.api_route("/health", methods=["GET", "HEAD"])
 async def health():
     redis = get_redis_client()
-    redis_ok = redis.ping() if redis else False
+    try:
+        redis_ok = redis.ping() if redis else False
+    except Exception:
+        redis_ok = False
 
     from backend.api.main import get_uptime
 

backend/api/routes/sensors.py

@@ -9,6 +9,7 @@ from typing import Optional
 from fastapi import APIRouter, Depends, HTTPException, Query
 
 from backend.api.deps import get_datahub
+from backend.api.utils import check_service_error
 from src.data.data_providers import DataHub
 
 log = logging.getLogger(__name__)
@@ -27,22 +28,13 @@ class AreaType(str, Enum):
     ambient = "ambient"
 
 
-def _check_error(result: dict, context: str = "") -> dict:
-    """If a data provider returned an error dict, raise HTTPException."""
-    if isinstance(result, dict) and "error" in result:
-        msg = result["error"]
-        log.warning("Data provider error%s: %s", f" ({context})" if context else "", msg)
-        raise HTTPException(status_code=502, detail=msg)
-    return result
-
-
 @router.get("/snapshot")
 async def sensors_snapshot(
     light: bool = False,
     hub: DataHub = Depends(get_datahub),
 ):
     result = hub.vine_sensors.get_snapshot(light=light)
-    return _check_error(result, "snapshot")
+    return check_service_error(result, "snapshot")
 
 
 @router.get("/history")
@@ -58,7 +50,7 @@ async def sensors_history(
             area=area.value if area else "treatment",
             hours_back=hours,
         )
-        return _check_error(result, "sensor history")
+        return check_service_error(result, "sensor history")
     except HTTPException:
         raise
     except Exception as exc:

backend/api/utils.py

@@ -0,0 +1,21 @@
+"""Shared utilities for API route handlers."""
+
+from __future__ import annotations
+
+import logging
+
+from fastapi import HTTPException
+
+log = logging.getLogger("solarwine.api")
+
+
+def check_service_error(result, context: str = ""):
+    """If a data provider returned an error dict, raise HTTPException(502).
+
+    Standardized error check used by all route modules.
+    """
+    if isinstance(result, dict) and "error" in result:
+        msg = result["error"]
+        log.warning("Data provider error%s: %s", f" ({context})" if context else "", msg)
+        raise HTTPException(status_code=502, detail=msg)
+    return result

backend/workers/control_tick.py

@@ -62,11 +62,12 @@ def main():
         log.info("Tick result saved to Redis")
 
         # Also persist budget state for the /control/budget endpoint
+        from config.settings import MAX_ENERGY_REDUCTION_PCT
         budget_info = {
             "energy_cost_kwh": result_dict.get("energy_cost_kwh", 0),
             "budget_spent_kwh": result_dict.get("budget_spent_kwh", 0),
             "budget_remaining_kwh": result_dict.get("budget_remaining_kwh", 0),
-            "daily_budget_kwh": 25.0 * 5.0 / 100.0,  # MAX_ENERGY_REDUCTION_PCT
+            "daily_budget_kwh": 25.0 * MAX_ENERGY_REDUCTION_PCT / 100.0,
             "stage": result_dict.get("stage_id", "unknown"),
             "last_updated": datetime.now(timezone.utc).isoformat(),
         }

backend/workers/daily_planner.py

@@ -80,8 +80,11 @@ def main():
     from src.data.redis_cache import get_redis
     from config.settings import DAILY_PLAN_PATH, MAX_ENERGY_REDUCTION_PCT
 
-    target = date.today()
-    log.info("Computing day-ahead plan for %s", target)
+    from datetime import timedelta
+    # Use Israel Standard Time (UTC+2) — HF Spaces runs in UTC
+    IST = timezone(timedelta(hours=2))
+    target = datetime.now(IST).date()
+    log.info("Computing day-ahead plan for %s (IST)", target)
 
     # Build forecast inputs
     forecast_temps, forecast_ghi = _get_forecast(target)

src/control_loop.py

@@ -701,7 +701,7 @@ class ControlLoop:
 
         # 10. Check plan divergence and trigger re-plan if needed
         if slot_plan:
-            actual_offset = live_offset if not result.live_override else 0.0
+            actual_offset = 0.0 if result.live_override else live_offset
             needs_replan = self._check_plan_divergence(
                 slot_index=slot_index,
                 planned_offset=result.plan_offset_deg,