meteocat 4.0.3 → 4.0.5

package/.github/workflows/publish-zip.yml

@@ -32,10 +32,10 @@ jobs:
         id: ha-version
         run: |
           # ──────────────────────────────────────────────────────────────
-          #  Comportamiento normal: usar siempre la última versión
-          # latest=$(curl -s https://api.github.com/repos/home-assistant/core/releases/latest | jq -r .tag_name)
-          # latest_clean=${latest#v}
-          # echo "ha_version=$latest_clean" >> $GITHUB_OUTPUT
+          # Comportamiento normal: usar siempre la última versión
+          #latest=$(curl -s https://api.github.com/repos/home-assistant/core/releases/latest | jq -r .tag_name)
+          #latest_clean=${latest#v}
+          #echo "ha_version=$latest_clean" >> $GITHUB_OUTPUT
 
           # Temporal: forzado a 2025.12.5 (enero 2026) por posible incompatibilidad con 2026.1.0
           echo "ha_version=2025.12.5" >> $GITHUB_OUTPUT

package/CHANGELOG.md

@@ -1,3 +1,18 @@
+## [4.0.5](https://github.com/figorr/meteocat/compare/v4.0.4...v4.0.5) (2026-01-31)
+
+
+### Bug Fixes
+
+* fix state for UVI, Hourly and Daily File sensors ([af645a6](https://github.com/figorr/meteocat/commit/af645a6a99189b1d0dac3b9b1019a400ae4e92f5))
+* include last update check to avoid continuous API calls when API returns outdated hourly and daily forecast data ([939a8ac](https://github.com/figorr/meteocat/commit/939a8ac66bfb3c3d750fda0cd719f310493f06c0))
+
+## [4.0.4](https://github.com/figorr/meteocat/compare/v4.0.3...v4.0.4) (2026-01-25)
+
+
+### Bug Fixes
+
+* include last update check to avoid continuous API calls when API returns outdated data ([32760e8](https://github.com/figorr/meteocat/commit/32760e854e3dd2a6af07c48373995df4f78106cb))
+
 ## [4.0.3](https://github.com/figorr/meteocat/compare/v4.0.2...v4.0.3) (2026-01-10)
 
 

package/custom_components/meteocat/__init__.py

@@ -24,7 +24,7 @@ from .const import DOMAIN, PLATFORMS
 _LOGGER = logging.getLogger(__name__)
 
 # Versión
-__version__ = "4.0.3"
+__version__ = "4.0.5"
 
 # Definir el esquema de configuración CONFIG_SCHEMA
 CONFIG_SCHEMA = vol.Schema(

package/custom_components/meteocat/const.py

@@ -61,10 +61,13 @@ DEFAULT_NAME = "METEOCAT"
 DEFAULT_VALIDITY_DAYS = 1  # Número de días a partir de los cuales se considera que el archivo de información está obsoleto
 DEFAULT_VALIDITY_HOURS = 6  # Hora a partir de la cual la API tiene la información actualizada de predicciones disponible para descarga
 DEFAULT_VALIDITY_MINUTES = 0  # Minutos a partir de los cuales la API tiene la información actualizada de predicciones disponible para descarga
+DEFAULT_HOURLY_FORECAST_MIN_HOURS_SINCE_LAST_UPDATE = 15  # Horas mínimas desde la última actualización de predicciones horararias para proceder a una nueva llamada a la API
+DEFAULT_DAILY_FORECAST_MIN_HOURS_SINCE_LAST_UPDATE = 15  # Horas mínimas desde la última actualización de predicciones diarias para proceder a una nueva llamada a la API
 DEFAULT_UVI_LOW_VALIDITY_HOURS = 5  # Hora a partir de la cual la API tiene la información actualizada de datos UVI disponible para descarga con límite bajo de cuota
 DEFAULT_UVI_LOW_VALIDITY_MINUTES = 0  # Minutos a partir de los cuales la API tiene la información actualizada de datos UVI disponible para descarga con límite bajo de cuota
 DEFAULT_UVI_HIGH_VALIDITY_HOURS = 9  # Hora a partir de la cual la API tiene la información actualizada de datos UVI disponible para descarga con límite alto de cuota
 DEFAULT_UVI_HIGH_VALIDITY_MINUTES = 0  # Minutos a partir de los cuales la API tiene la información actualizada de datos UVI disponible para descarga con límite alto de cuota
+DEFAULT_UVI_MIN_HOURS_SINCE_LAST_UPDATE = 15 # Horas mínimas desde la última actualización de datos UVI para proceder a una nueva llamada a la API
 DEFAULT_ALERT_VALIDITY_TIME = 120  # Minutos a partir de los cuales las alertas están obsoletas y se se debe proceder a una nueva llamada a la API
 DEFAULT_QUOTES_VALIDITY_TIME = 240 # Minutos a partir de los cuales los datos de cuotas están obsoletos y se se debe proceder a una nueva llamada a la API
 DEFAULT_LIGHTNING_VALIDITY_TIME = 240 # Minutos a partir de los cuales los datos de rayos están obsoletos y se se debe proceder a una nueva llamada a la API

package/custom_components/meteocat/coordinator.py

@@ -52,10 +52,13 @@ from .const import (
     DEFAULT_VALIDITY_DAYS,
     DEFAULT_VALIDITY_HOURS,
     DEFAULT_VALIDITY_MINUTES,
+    DEFAULT_HOURLY_FORECAST_MIN_HOURS_SINCE_LAST_UPDATE,
+    DEFAULT_DAILY_FORECAST_MIN_HOURS_SINCE_LAST_UPDATE,
     DEFAULT_UVI_LOW_VALIDITY_HOURS,
     DEFAULT_UVI_LOW_VALIDITY_MINUTES,
     DEFAULT_UVI_HIGH_VALIDITY_HOURS,
     DEFAULT_UVI_HIGH_VALIDITY_MINUTES,
+    DEFAULT_UVI_MIN_HOURS_SINCE_LAST_UPDATE,
     DEFAULT_ALERT_VALIDITY_TIME,
     DEFAULT_QUOTES_VALIDITY_TIME,
     ALERT_VALIDITY_MULTIPLIER_100,
@@ -406,26 +409,24 @@ class MeteocatUviCoordinator(DataUpdateCoordinator):
         )
 
     async def is_uvi_data_valid(self) -> Optional[dict]:
-        """Valida datos UVI: misma lógica que predicción, basada en limit_prediccio.
-
-        - Si `limit_prediccio >= 550` → actualiza **el día siguiente** después de las DEFAULT_VALIDITY_HOURS:DEFAULT_VALIDITY_MINUTES.
-        - Si `limit_prediccio < 550`  → actualiza **dos días después** después de las DEFAULT_VALIDITY_HOURS:DEFAULT_VALIDITY_MINUTES.
+        """Valida si los datos UVI en caché son aún válidos, considerando:
+           1. Antigüedad de la fecha del primer día (lógica existente según cuota)
+           2. Hora mínima del día (según cuota)
+           3. Han pasado más de DEFAULT_UVI_MIN_HOURS_SINCE_LAST_UPDATE horas desde la última actualización exitosa
         """
         if not self.uvi_file.exists():
             _LOGGER.debug("Archivo UVI no existe: %s", self.uvi_file)
             return None
 
         try:
-            async with aiofiles.open(self.uvi_file, "r", encoding="utf-8") as f:
-                content = await f.read()
-                data = json.loads(content)
+            data = await load_json_from_file(self.uvi_file)
 
             # Validar estructura básica
             if not isinstance(data, dict) or "uvi" not in data or not isinstance(data["uvi"], list) or not data["uvi"]:
                 _LOGGER.warning("Estructura UVI inválida en %s", self.uvi_file)
                 return None
 
-            # Fecha del primer día
+            # ── Condición 1: Antigüedad de la fecha del primer día ──
             try:
                 first_date_str = data["uvi"][0].get("date")
                 first_date = datetime.strptime(first_date_str, "%Y-%m-%d").date()
@@ -433,39 +434,64 @@ class MeteocatUviCoordinator(DataUpdateCoordinator):
                 _LOGGER.warning("Fecha UVI inválida en %s: %s", self.uvi_file, exc)
                 return None
 
-            # Fecha y hora actual en zona local (Europe/Madrid)
             now_local = datetime.now(TIMEZONE)
             today = now_local.date()
             current_time_local = now_local.time()
-            # Horas para actualización según límite de cuota
-            min_update_time_high = time(DEFAULT_UVI_HIGH_VALIDITY_HOURS, DEFAULT_UVI_HIGH_VALIDITY_MINUTES)  # Hora para cuota alta
-            min_update_time_low = time(DEFAULT_UVI_LOW_VALIDITY_HOURS, DEFAULT_UVI_LOW_VALIDITY_MINUTES)  # Hora para cuota baja
-            # Diferencia en días
             days_diff = (today - first_date).days
 
-            # === LÓGICA DINÁMICA SEGÚN CUOTA ===
+            # Determinar umbrales según cuota
             if self.limit_prediccio >= PREDICCIO_HIGH_QUOTA_LIMIT:
-                should_update = days_diff >= DEFAULT_VALIDITY_DAYS and current_time_local >= min_update_time_high
+                min_days = DEFAULT_VALIDITY_DAYS           # ej: 1 día
+                min_update_time = time(DEFAULT_UVI_HIGH_VALIDITY_HOURS, DEFAULT_UVI_HIGH_VALIDITY_MINUTES)
+                quota_level = "ALTA"
             else:
-                should_update = days_diff > DEFAULT_VALIDITY_DAYS and current_time_local >= min_update_time_low
+                min_days = DEFAULT_VALIDITY_DAYS + 1       # ej: 2 días
+                min_update_time = time(DEFAULT_UVI_LOW_VALIDITY_HOURS, DEFAULT_UVI_LOW_VALIDITY_MINUTES)
+                quota_level = "BAJA"
+
+            cond1 = days_diff >= min_days
+            cond2 = current_time_local >= min_update_time
+
+            # ── Condición 3: Más de X horas desde última actualización ──
+            cond3 = True  # por defecto (si no hay dataUpdate → permite actualizar)
+            last_update_str = None
+            if "actualitzat" in data and "dataUpdate" in data["actualitzat"]:
+                try:
+                    last_update = datetime.fromisoformat(data["actualitzat"]["dataUpdate"])
+                    time_since = now_local - last_update
+                    cond3 = time_since > timedelta(hours=DEFAULT_UVI_MIN_HOURS_SINCE_LAST_UPDATE)
+                    last_update_str = last_update.strftime("%Y-%m-%d %H:%M:%S %z")
+                    _LOGGER.debug(
+                        "Tiempo desde última actualización: %s (%s %dh)",
+                        time_since,
+                        "supera" if cond3 else "NO supera",
+                        DEFAULT_UVI_MIN_HOURS_SINCE_LAST_UPDATE
+                    )
+                except ValueError:
+                    _LOGGER.warning("Formato inválido en dataUpdate: %s", data["actualitzat"]["dataUpdate"])
+                    cond3 = True  # si corrupto → permite actualizar
+
+            should_update = cond1 and cond2 and cond3
 
             _LOGGER.debug(
-                "[UVI %s] Validación: primer_día=%s, hoy=%s → días=%d, "
-                "cuota=%d (%s), hora=%s ≥ %s → actualizar=%s",
+                "[UVI %s] Validación → cond1(días >=%d)=%s | cond2(hora >=%s)=%s | "
+                "cond3(>%dh desde %s)=%s | cuota=%d (%s) | actualizar=%s",
                 self.town_id,
-                first_date,
-                today,
-                days_diff,
+                min_days,
+                cond1,
+                min_update_time.strftime("%H:%M"),
+                cond2,
+                DEFAULT_UVI_MIN_HOURS_SINCE_LAST_UPDATE,
+                last_update_str or "nunca",
+                cond3,
                 self.limit_prediccio,
-                "ALTA" if self.limit_prediccio >= 550 else "BAJA",
-                current_time_local.strftime("%H:%M"),
-                min_update_time_high.strftime("%H:%M") if self.limit_prediccio >= 550 else min_update_time_low.strftime("%H:%M"),
+                quota_level,
                 should_update,
             )
 
             if should_update:
                 _LOGGER.info(
-                    "Datos UVI obsoletos → llamando API (town=%s, cuota=%d)",
+                    "Datos UVI obsoletos o antiguos → llamando API (town=%s, cuota=%d)",
                     self.town_id, self.limit_prediccio
                 )
                 return None
@@ -480,14 +506,15 @@ class MeteocatUviCoordinator(DataUpdateCoordinator):
             _LOGGER.error("Error validando UVI: %s", e)
             return None
 
-    async def _async_update_data(self) -> List[Dict]:
-        """Actualiza los datos de UVI desde la API de Meteocat o caché."""
+    async def _async_update_data(self) -> Optional[dict]:
+        """Actualiza los datos de UVI desde la API o caché."""
         try:
             valid_data = await self.is_uvi_data_valid()
             if valid_data:
                 _LOGGER.debug("Los datos del índice UV están actualizados. No se realiza llamada a la API.")
-                return valid_data["uvi"]
+                return valid_data
 
+            # ── Llamada a la API ──
             data = await asyncio.wait_for(
                 self.meteocat_uvi_data.get_uvi_index(self.town_id),
                 timeout=30,
@@ -500,8 +527,19 @@ class MeteocatUviCoordinator(DataUpdateCoordinator):
                 _LOGGER.error("Formato inválido: se esperaba un dict con 'uvi' -> %s", data)
                 raise ValueError("Formato de datos inválido")
 
-            await save_json_to_file(data, self.uvi_file)
-            return data["uvi"]
+            # Añadir timestamp de actualización exitosa
+            now_iso = datetime.now(TIMEZONE).isoformat()
+            enhanced_data = {
+                "actualitzat": {
+                    "dataUpdate": now_iso
+                },
+                **data  # conserva ine, nom, comarca, capital, uvi, ...
+            }
+
+            await save_json_to_file(enhanced_data, self.uvi_file)
+            _LOGGER.debug("Datos UVI guardados con dataUpdate: %s", now_iso)
+
+            return enhanced_data   # ← en lugar de return data["uvi"]
 
         except asyncio.TimeoutError as err:
             _LOGGER.warning("Tiempo de espera agotado al obtener datos UVI.")
@@ -517,17 +555,16 @@ class MeteocatUviCoordinator(DataUpdateCoordinator):
             raise
         except Exception as err:
             _LOGGER.exception("Error inesperado al obtener datos del índice UV para %s: %s", self.town_id, err)
-            
-        # === FALLBACK SEGURO ===
+
+        # ── FALLBACK SEGURO ──
         cached_data = await load_json_from_file(self.uvi_file)
         if cached_data and "uvi" in cached_data and cached_data["uvi"]:
             raw_date = cached_data["uvi"][0].get("date", "unknown")
-            # Formatear fecha para log
             try:
                 first_date = datetime.strptime(raw_date, "%Y-%m-%d").strftime("%d/%m/%Y")
             except (ValueError, TypeError):
                 first_date = raw_date
-                
+
             _LOGGER.warning(
                 "API UVI falló → usando caché local:\n"
                 " • Archivo: %s\n"
@@ -535,13 +572,13 @@ class MeteocatUviCoordinator(DataUpdateCoordinator):
                 self.uvi_file.name,
                 first_date
             )
-            
-            self.async_set_updated_data(cached_data["uvi"])
-            return cached_data["uvi"]
-        
+
+            self.async_set_updated_data(cached_data)
+            return cached_data
+
         _LOGGER.error("No hay datos UVI ni en caché para %s", self.town_id)
-        self.async_set_updated_data([])
-        return []
+        self.async_set_updated_data(None)
+        return None
 
 class MeteocatUviFileCoordinator(BaseFileCoordinator):
     """Coordinator to read and process UV data from a file."""
@@ -646,81 +683,100 @@ class MeteocatEntityCoordinator(DataUpdateCoordinator):
             name=f"{DOMAIN} Entity Coordinator",
             update_interval=DEFAULT_ENTITY_UPDATE_INTERVAL,
         )
-    
+
     # --------------------------------------------------------------------- #
     #  VALIDACIÓN DINÁMICA DE DATOS DE PREDICCIÓN
     # --------------------------------------------------------------------- #
-    async def validate_forecast_data(self, file_path: Path) -> dict:
-        """Valida y retorna datos de predicción si son válidos.
-        
-        - Si `limit_prediccio >= 550` → actualiza **el día siguiente** después de las DEFAULT_VALIDITY_HOURS:DEFAULT_VALIDITY_MINUTES.
-        - Si `limit_prediccio < 550`  → actualiza **dos días después** después de las DEFAULT_VALIDITY_HOURS:DEFAULT_VALIDITY_MINUTES.
-        """
+    async def validate_forecast_data(self, file_path: Path) -> Optional[dict]:
+        """Valida si los datos de predicción son válidos considerando 3 condiciones."""
         if not file_path.exists():
-            _LOGGER.warning("El archivo %s no existe. Se considerará inválido.", file_path)
+            _LOGGER.warning("Archivo no existe: %s", file_path)
             return None
+
         try:
-            async with aiofiles.open(file_path, "r", encoding="utf-8") as f:
-                content = await f.read()
-                data = json.loads(content)
+            data = await load_json_from_file(file_path)
 
-            # Fecha del primer día de predicción (solo fecha)
-            first_date_str = data["dies"][0]["data"].rstrip("Z")
-            first_date = datetime.fromisoformat(first_date_str).date()
-            today = datetime.now(timezone.utc).date()
+            if not isinstance(data, dict) or "dies" not in data or not data["dies"]:
+                _LOGGER.warning("Estructura inválida en %s", file_path)
+                return None
 
-            # Hora actual en zona local (Europe/Madrid)
-            current_time_local = datetime.now(TIMEZONE).time()
-            min_update_time = time(DEFAULT_VALIDITY_HOURS, DEFAULT_VALIDITY_MINUTES)
+            # ── Condición 1: Antigüedad del primer día de predicción ──
+            first_date_str = data["dies"][0]["data"].rstrip("Z")
+            try:
+                first_date = datetime.fromisoformat(first_date_str).date()
+            except Exception as exc:
+                _LOGGER.warning("Fecha inválida en %s: %s", file_path, exc)
+                return None
 
+            now_local = datetime.now(TIMEZONE)
+            today = now_local.date()  # Si queremos respetar que los datos del json son UTC quizás mejor usar today = datetime.now(timezone.utc).date()
+            current_time_local = now_local.time()
             days_diff = (today - first_date).days
 
-            # -----------------------------------------------------------------
-            #  Lógica según cuota
-            # -----------------------------------------------------------------
+            #  ── Condición 2: Lógica de umbrales según cuota para determinar días y horas válidos de actualización ──
             if self.limit_prediccio >= PREDICCIO_HIGH_QUOTA_LIMIT:
-                # Cuota alta → actualiza cuando los datos son de ayer (o antes) + hora OK
-                should_update = days_diff >= DEFAULT_VALIDITY_DAYS and current_time_local >= min_update_time
+                min_days = DEFAULT_VALIDITY_DAYS
+                min_update_time = time(DEFAULT_VALIDITY_HOURS, DEFAULT_VALIDITY_MINUTES)
+                quota_level = "ALTA"
             else:
-                # Cuota baja → actualiza solo cuando los datos son de anteayer + hora OK
-                should_update = days_diff > DEFAULT_VALIDITY_DAYS and current_time_local >= min_update_time
+                min_days = DEFAULT_VALIDITY_DAYS + 1
+                min_update_time = time(DEFAULT_VALIDITY_HOURS, DEFAULT_VALIDITY_MINUTES)
+                quota_level = "BAJA"
+
+            cond1 = days_diff >= min_days
+            cond2 = current_time_local >= min_update_time
+
+            # ── Condición 3: Más de X horas desde última actualización ──
+            cond3 = True  # por defecto permite actualizar si no hay timestamp
+            last_update_str = None
+            hours_threshold = (
+                DEFAULT_HOURLY_FORECAST_MIN_HOURS_SINCE_LAST_UPDATE
+                if "hourly" in file_path.name.lower()
+                else DEFAULT_DAILY_FORECAST_MIN_HOURS_SINCE_LAST_UPDATE
+            )
+
+            if "actualitzat" in data and "dataUpdate" in data["actualitzat"]:
+                try:
+                    last_update = datetime.fromisoformat(data["actualitzat"]["dataUpdate"])
+                    time_since = now_local - last_update
+                    cond3 = time_since > timedelta(hours=hours_threshold)
+                    last_update_str = last_update.strftime("%Y-%m-%d %H:%M:%S %z")
+                    _LOGGER.debug(
+                        "%s → tiempo desde última act.: %s (%s %dh)",
+                        file_path.name, time_since,
+                        "supera" if cond3 else "NO supera", hours_threshold
+                    )
+                except ValueError:
+                    _LOGGER.warning("dataUpdate inválido en %s: %s", file_path, data["actualitzat"]["dataUpdate"])
+                    cond3 = True
+
+            should_update = cond1 and cond2 and cond3
 
-            # -----------------------------------------------------------------
-            #  Logs detallados
-            # -----------------------------------------------------------------
             _LOGGER.debug(
-                "[%s] Validación: primer_día=%s, hoy=%s → días=%d, "
-                "cuota=%d (%s), hora_local=%s ≥ %s → actualizar=%s",
-                file_path.name,
-                first_date,
-                today,
-                days_diff,
-                self.limit_prediccio,
-                "ALTA" if self.limit_prediccio >= 550 else "BAJA",
-                current_time_local.strftime("%H:%M"),
-                min_update_time.strftime("%H:%M"),
-                should_update,
+                "[%s] Validación → cond1(días >=%d)=%s | cond2(hora >=%s)=%s | "
+                "cond3(>%dh desde %s)=%s | cuota=%d (%s) | actualizar=%s",
+                file_path.name, min_days, cond1,
+                min_update_time.strftime("%H:%M"), cond2,
+                hours_threshold, last_update_str or "nunca", cond3,
+                self.limit_prediccio, quota_level, should_update
             )
 
             if should_update:
-                _LOGGER.debug(
-                    "Datos obsoletos o actualizables → llamando API (%s, cuota=%d)",
-                    file_path.name, self.limit_prediccio
-                )
-                return None  # → forzar actualización
+                _LOGGER.info("Datos obsoletos → llamando API para %s", file_path.name)
+                return None
 
-            _LOGGER.debug("Datos válidos en %s → usando caché", file_path.name)
+            _LOGGER.debug("Datos válidos → usando caché %s", file_path.name)
             return data
 
+        except json.JSONDecodeError:
+            _LOGGER.error("JSON corrupto en %s", file_path)
+            return None
         except Exception as e:
-            _LOGGER.warning("Error validando %s: %s", file_path, e)
+            _LOGGER.error("Error validando %s: %s", file_path, e)
             return None
 
-    # --------------------------------------------------------------------- #
-    #  OBTENCIÓN Y GUARDADO DE DATOS DESDE LA API
-    # --------------------------------------------------------------------- #
     async def _fetch_and_save_data(self, api_method, file_path: Path) -> dict:
-        """Obtiene datos de la API y los guarda en un archivo JSON."""
+        """Obtiene datos de la API, los procesa y guarda con timestamp."""
         try:
             data = await asyncio.wait_for(api_method(self.town_id), timeout=30)
 
@@ -734,16 +790,24 @@ class MeteocatEntityCoordinator(DataUpdateCoordinator):
                     ):
                         details["valor"] = "0.0"
 
-            await save_json_to_file(data, file_path)
+            # Añadir timestamp de actualización exitosa
+            now_iso = datetime.now(TIMEZONE).isoformat()
+            enhanced_data = {
+                "actualitzat": {"dataUpdate": now_iso},
+                **data
+            }
+
+            await save_json_to_file(enhanced_data, file_path)
+            _LOGGER.debug("Guardado %s con dataUpdate: %s", file_path.name, now_iso)
 
-            # Actualizar cuotas (dependiendo del tipo de predicción horaria/diaria)
+            # Actualizar cuotas
             if api_method.__name__ in ("get_prediccion_horaria", "get_prediccion_diaria"):
                 await _update_quotes(self.hass, "Prediccio")
 
-            return data
+            return enhanced_data
 
         except Exception as err:
-            _LOGGER.error(f"Error al obtener datos de la API para {file_path}: {err}")
+            _LOGGER.error("Error al obtener/guardar %s: %s", file_path, err)
             raise
 
     # --------------------------------------------------------------------- #
@@ -801,7 +865,7 @@ class MeteocatEntityCoordinator(DataUpdateCoordinator):
         # === FALLBACK SEGURO ===
         hourly_cache = await load_json_from_file(self.hourly_file) or {}
         daily_cache = await load_json_from_file(self.daily_file) or {}
-        
+
         # --- Fecha horaria ---
         h_raw = hourly_cache.get("dies", [{}])[0].get("data", "")
         try:
@@ -825,7 +889,7 @@ class MeteocatEntityCoordinator(DataUpdateCoordinator):
             self.hourly_file.name, h_display,
             self.daily_file.name, d_display
         )
-        
+
         self.async_set_updated_data({"hourly": hourly_cache, "daily": daily_cache})
         return {"hourly": hourly_cache, "daily": daily_cache}
 

package/custom_components/meteocat/manifest.json

@@ -21,5 +21,5 @@
     "packaging>=20.3",
     "wrapt>=1.14.0"
   ],
-  "version": "4.0.3"
+  "version": "4.0.5"
 }

package/custom_components/meteocat/sensor.py

@@ -97,6 +97,10 @@ from .const import (
     DEFAULT_VALIDITY_DAYS,
     DEFAULT_VALIDITY_HOURS,
     DEFAULT_VALIDITY_MINUTES,
+    DEFAULT_UVI_LOW_VALIDITY_HOURS,
+    DEFAULT_UVI_LOW_VALIDITY_MINUTES,
+    DEFAULT_UVI_HIGH_VALIDITY_HOURS,
+    DEFAULT_UVI_HIGH_VALIDITY_MINUTES,
     DEFAULT_ALERT_VALIDITY_TIME,
     DEFAULT_QUOTES_VALIDITY_TIME,
     ALERT_VALIDITY_MULTIPLIER_100,
@@ -114,6 +118,10 @@ from .const import (
     MOON_FILE_STATUS,
     MOONRISE,
     MOONSET,
+    PREDICCIO_HIGH_QUOTA_LIMIT,
+    DEFAULT_HOURLY_FORECAST_MIN_HOURS_SINCE_LAST_UPDATE,
+    DEFAULT_DAILY_FORECAST_MIN_HOURS_SINCE_LAST_UPDATE,
+    DEFAULT_UVI_MIN_HOURS_SINCE_LAST_UPDATE,
 )
 
 from .coordinator import (
@@ -1181,46 +1189,83 @@ class MeteocatHourlyForecastStatusSensor(CoordinatorEntity[MeteocatEntityCoordin
         self._town_name = entry_data["town_name"]
         self._town_id = entry_data["town_id"]
         self._station_id = entry_data["station_id"]
+        self._limit_prediccio = entry_data["limit_prediccio"]
         self._attr_unique_id = f"sensor.{DOMAIN}_{self._town_id}_hourly_status"
         self._attr_entity_category = getattr(description, "entity_category", None)
 
+    def _get_forecast_data(self, forecast_type: str) -> Optional[dict]:
+        """Devuelve los datos del tipo de forecast (hourly o daily) o None."""
+        if not self.coordinator.data:
+            return None
+        return self.coordinator.data.get(forecast_type)
+
     def _get_first_date(self):
-        hourly_data = self.coordinator.data.get("hourly")
-        if hourly_data and "dies" in hourly_data:
-            return datetime.fromisoformat(hourly_data["dies"][0]["data"].rstrip("Z")).date()
+        hourly_data = self._get_forecast_data("hourly")
+        if hourly_data and "dies" in hourly_data and hourly_data["dies"]:
+            try:
+                first_date_str = hourly_data["dies"][0]["data"].rstrip("Z")
+                return datetime.fromisoformat(first_date_str).date()
+            except (ValueError, TypeError, KeyError, IndexError):
+                _LOGGER.warning("No se pudo parsear primera fecha del forecast horario")
+                return None
+        return None
+
+    def _get_last_api_update(self):
+        hourly_data = self._get_forecast_data("hourly")
+        if hourly_data and "actualitzat" in hourly_data and "dataUpdate" in hourly_data["actualitzat"]:
+            try:
+                return datetime.fromisoformat(hourly_data["actualitzat"]["dataUpdate"])
+            except ValueError:
+                _LOGGER.warning("Formato inválido en dataUpdate del forecast horario")
+                return None
         return None
 
     @property
-    def native_value(self):
+    def native_value(self) -> str:
         first_date = self._get_first_date()
-        if first_date:
-            today = datetime.now(timezone.utc).date()
-            current_time = datetime.now(timezone.utc).time()
-            days_difference = (today - first_date).days
-            _LOGGER.debug(
-                f"Diferencia de días para predicciones horarias: {days_difference}."
-                f"Hora actual de validación: {current_time}."
-                f"Para la validación: "
-                f"número de días= {DEFAULT_VALIDITY_DAYS}, "
-                f"hora de contacto a la API >= {DEFAULT_VALIDITY_HOURS}, "
-                f"minutos de contacto a la API >= {DEFAULT_VALIDITY_MINUTES}."
-            )
-            if days_difference > DEFAULT_VALIDITY_DAYS and current_time >= time(DEFAULT_VALIDITY_HOURS, DEFAULT_VALIDITY_MINUTES):
-                return "obsolete"
-            return "updated"
-        return "unknown"
+        if not first_date:
+            _LOGGER.debug("Hourly status: no hay datos disponibles aún")
+            return "unknown"
+
+        now_local = datetime.now(TIMEZONE)
+        today = now_local.date()
+        current_time = now_local.time()
+        days_difference = (today - first_date).days
+
+        # Replicar lógica del coordinador
+        min_days = DEFAULT_VALIDITY_DAYS if self._limit_prediccio >= PREDICCIO_HIGH_QUOTA_LIMIT else DEFAULT_VALIDITY_DAYS + 1
+        min_time = time(DEFAULT_VALIDITY_HOURS + 1, DEFAULT_VALIDITY_MINUTES)  # Margen adicional de +1 hora sobre la hora mínima configurada.
+
+        cond1 = days_difference >= min_days
+        cond2 = current_time >= min_time
+
+        _LOGGER.debug(
+            "Hourly status → días: %d (≥%d)=%s | hora: %s (≥%s)=%s → %s",
+            days_difference, min_days, cond1,
+            current_time.strftime("%H:%M"), min_time.strftime("%H:%M"), cond2,
+            "obsolete" if cond1 and cond2 else "updated"
+        )
+
+        if cond1 and cond2:
+            return "obsolete"
+        return "updated"
 
     @property
-    def extra_state_attributes(self):
-        attributes = super().extra_state_attributes or {}
+    def extra_state_attributes(self) -> dict:
+        attributes: dict = {}
+
         first_date = self._get_first_date()
         if first_date:
             attributes["update_date"] = first_date.isoformat()
+
+        last_update = self._get_last_api_update()
+        if last_update:
+            attributes["data_updatetime"] = last_update.isoformat()
+
         return attributes
-    
+
     @property
     def device_info(self) -> DeviceInfo:
-        """Return the device info."""
         return DeviceInfo(
             identifiers={(DOMAIN, self._town_id)},
             name=f"Meteocat {self._station_id} {self._town_name}",
@@ -1237,46 +1282,83 @@ class MeteocatDailyForecastStatusSensor(CoordinatorEntity[MeteocatEntityCoordina
         self._town_name = entry_data["town_name"]
         self._town_id = entry_data["town_id"]
         self._station_id = entry_data["station_id"]
+        self._limit_prediccio = entry_data["limit_prediccio"]
         self._attr_unique_id = f"sensor.{DOMAIN}_{self._town_id}_daily_status"
         self._attr_entity_category = getattr(description, "entity_category", None)
 
+    def _get_forecast_data(self, forecast_type: str) -> Optional[dict]:
+        """Devuelve los datos del tipo de forecast (hourly o daily) o None."""
+        if not self.coordinator.data:
+            return None
+        return self.coordinator.data.get(forecast_type)
+
     def _get_first_date(self):
-        daily_data = self.coordinator.data.get("daily")
-        if daily_data and "dies" in daily_data:
-            return datetime.fromisoformat(daily_data["dies"][0]["data"].rstrip("Z")).date()
+        daily_data = self._get_forecast_data("daily")
+        if daily_data and "dies" in daily_data and daily_data["dies"]:
+            try:
+                first_date_str = daily_data["dies"][0]["data"].rstrip("Z")
+                return datetime.fromisoformat(first_date_str).date()
+            except (ValueError, TypeError, KeyError, IndexError):
+                _LOGGER.warning("No se pudo parsear primera fecha del forecast diario")
+                return None
+        return None
+
+    def _get_last_api_update(self):
+        daily_data = self._get_forecast_data("daily")
+        if daily_data and "actualitzat" in daily_data and "dataUpdate" in daily_data["actualitzat"]:
+            try:
+                return datetime.fromisoformat(daily_data["actualitzat"]["dataUpdate"])
+            except ValueError:
+                _LOGGER.warning("Formato inválido en dataUpdate del forecast diario")
+                return None
         return None
 
     @property
-    def native_value(self):
+    def native_value(self) -> str:
         first_date = self._get_first_date()
-        if first_date:
-            today = datetime.now(timezone.utc).date()
-            current_time = datetime.now(timezone.utc).time()
-            days_difference = (today - first_date).days
-            _LOGGER.debug(
-                f"Diferencia de días para predicciones diarias: {days_difference}."
-                f"Hora actual de validación: {current_time}."
-                f"Para la validación: "
-                f"número de días= {DEFAULT_VALIDITY_DAYS}, "
-                f"hora de contacto a la API >= {DEFAULT_VALIDITY_HOURS}, "
-                f"minutos de contacto a la API >= {DEFAULT_VALIDITY_MINUTES}."
-            )
-            if days_difference > DEFAULT_VALIDITY_DAYS and current_time >= time(DEFAULT_VALIDITY_HOURS, DEFAULT_VALIDITY_MINUTES):
-                return "obsolete"
-            return "updated"
-        return "unknown"
+        if not first_date:
+            _LOGGER.debug("Daily status: no hay datos disponibles aún")
+            return "unknown"
+
+        now_local = datetime.now(TIMEZONE)
+        today = now_local.date()
+        current_time = now_local.time()
+        days_difference = (today - first_date).days
+
+        # Replicar lógica del coordinador
+        min_days = DEFAULT_VALIDITY_DAYS if self._limit_prediccio >= PREDICCIO_HIGH_QUOTA_LIMIT else DEFAULT_VALIDITY_DAYS + 1
+        min_time = time(DEFAULT_VALIDITY_HOURS + 1, DEFAULT_VALIDITY_MINUTES)  # Margen adicional de +1 hora sobre la hora mínima configurada.
+
+        cond1 = days_difference >= min_days
+        cond2 = current_time >= min_time
+
+        _LOGGER.debug(
+            "Daily status → días: %d (≥%d)=%s | hora: %s (≥%s)=%s → %s",
+            days_difference, min_days, cond1,
+            current_time.strftime("%H:%M"), min_time.strftime("%H:%M"), cond2,
+            "obsolete" if cond1 and cond2 else "updated"
+        )
+
+        if cond1 and cond2:
+            return "obsolete"
+        return "updated"
 
     @property
-    def extra_state_attributes(self):
-        attributes = super().extra_state_attributes or {}
+    def extra_state_attributes(self) -> dict:
+        attributes: dict = {}
+
         first_date = self._get_first_date()
         if first_date:
             attributes["update_date"] = first_date.isoformat()
+
+        last_update = self._get_last_api_update()
+        if last_update:
+            attributes["data_updatetime"] = last_update.isoformat()
+
         return attributes
-    
+
     @property
     def device_info(self) -> DeviceInfo:
-        """Return the device info."""
         return DeviceInfo(
             identifiers={(DOMAIN, self._town_id)},
             name=f"Meteocat {self._station_id} {self._town_name}",
@@ -1293,40 +1375,91 @@ class MeteocatUviStatusSensor(CoordinatorEntity[MeteocatUviCoordinator], SensorE
         self._town_name = entry_data["town_name"]
         self._town_id = entry_data["town_id"]
         self._station_id = entry_data["station_id"]
+        self._limit_prediccio = entry_data["limit_prediccio"]
         self._attr_unique_id = f"sensor.{DOMAIN}_{self._town_id}_uvi_status"
         self._attr_entity_category = getattr(description, "entity_category", None)
 
+    def _get_uvi_data_dict(self):
+        """Devuelve el diccionario completo de datos UVI (incluyendo 'actualitzat') o None."""
+        if self.coordinator.data and isinstance(self.coordinator.data, dict):
+            return self.coordinator.data
+        return None
+    
     def _get_first_date(self):
-        if self.coordinator.data:
-            return datetime.strptime(self.coordinator.data[0].get("date"), "%Y-%m-%d").date()
+        data_dict = self._get_uvi_data_dict()
+        if data_dict and "uvi" in data_dict and data_dict["uvi"]:
+            try:
+                return datetime.strptime(data_dict["uvi"][0].get("date"), "%Y-%m-%d").date()
+            except (ValueError, TypeError, KeyError):
+                return None
+        return None
+    
+    def _get_last_api_update(self):
+        """Devuelve el datetime de la última llamada exitosa a la API o None."""
+        data_dict = self._get_uvi_data_dict()
+        if data_dict and "actualitzat" in data_dict and "dataUpdate" in data_dict["actualitzat"]:
+            try:
+                return datetime.fromisoformat(data_dict["actualitzat"]["dataUpdate"])
+            except ValueError:
+                _LOGGER.warning("Formato inválido en dataUpdate del sensor UVI status")
+                return None
         return None
 
     @property
-    def native_value(self):
+    def native_value(self) -> str:
+        data_dict = self._get_uvi_data_dict()
+        if not data_dict:
+            _LOGGER.debug("UVI Status: no hay datos disponibles aún")
+            return "unknown"
+
         first_date = self._get_first_date()
-        if first_date:
-            today = datetime.now(timezone.utc).date()
-            current_time = datetime.now(timezone.utc).time()
-            days_difference = (today - first_date).days
-            _LOGGER.debug(
-                f"Diferencia de días para datos UVI: {days_difference}."
-                f"Hora actual de validación: {current_time}."
-                f"Para la validación: "
-                f"número de días= {DEFAULT_VALIDITY_DAYS}, "
-                f"hora de contacto a la API >= {DEFAULT_VALIDITY_HOURS}, "
-                f"minutos de contacto a la API >= {DEFAULT_VALIDITY_MINUTES}."
-            )
-            if days_difference > DEFAULT_VALIDITY_DAYS and current_time >= time(DEFAULT_VALIDITY_HOURS, DEFAULT_VALIDITY_MINUTES):
-                return "obsolete"
-            return "updated"
-        return "unknown"
+        if not first_date:
+            _LOGGER.debug("UVI Status: no se pudo obtener first_date")
+            return "unknown"
+
+        now_local = datetime.now(TIMEZONE)
+        today = now_local.date()
+        current_time = now_local.time()
+        days_difference = (today - first_date).days
+
+        # ── Replicar lógica exacta del coordinador ──
+        if self._limit_prediccio >= PREDICCIO_HIGH_QUOTA_LIMIT:
+            min_days = DEFAULT_VALIDITY_DAYS
+            min_time = time(DEFAULT_UVI_HIGH_VALIDITY_HOURS + 1, DEFAULT_UVI_HIGH_VALIDITY_MINUTES)  # Margen adicional de +1 hora sobre la hora mínima configurada.
+            quota_level = "ALTA"
+        else:
+            min_days = DEFAULT_VALIDITY_DAYS + 1
+            min_time = time(DEFAULT_UVI_LOW_VALIDITY_HOURS + 1, DEFAULT_UVI_LOW_VALIDITY_MINUTES)  # Margen adicional de +1 hora sobre la hora mínima configurada.
+            quota_level = "BAJA"
+
+        cond1 = days_difference >= min_days
+        cond2 = current_time >= min_time
+
+        _LOGGER.debug(
+            "UVI Status → días: %d (≥%d)=%s | hora: %s (≥%s)=%s → %s",
+            days_difference, min_days, cond1,
+            current_time.strftime("%H:%M"), min_time.strftime("%H:%M"), cond2,
+            self._limit_prediccio, quota_level,
+            "obsolete" if cond1 and cond2 else "updated"
+        )
+
+        if cond1 and cond2:
+            return "obsolete"
+        return "updated"
 
     @property
-    def extra_state_attributes(self):
-        attributes = super().extra_state_attributes or {}
+    def extra_state_attributes(self) -> dict:
+        attributes: dict = {}
+
+        # Primera fecha de los datos UVI
         first_date = self._get_first_date()
         if first_date:
             attributes["update_date"] = first_date.isoformat()
+        # Última actualizaciónde la API
+        last_update = self._get_last_api_update()
+        if last_update:
+            attributes["data_updatetime"] = last_update.isoformat()
+
         return attributes
     
     @property

package/custom_components/meteocat/strings.json

@@ -212,6 +212,9 @@
         "state_attributes": {
           "update_date": {
             "name": "Date"
+          },
+          "data_updatetime": {
+            "name": "Updated"
           }
         }
       },
@@ -224,6 +227,9 @@
         "state_attributes": {
           "update_date": {
             "name": "Date"
+          },
+          "data_updatetime": {
+            "name": "Updated"
           }
         }
       },
@@ -236,6 +242,9 @@
         "state_attributes": {
           "update_date": {
             "name": "Date"
+          },
+          "data_updatetime": {
+            "name": "Updated"
           }
         }
       },

package/custom_components/meteocat/translations/ca.json

@@ -212,6 +212,9 @@
         "state_attributes": {
           "update_date": {
             "name": "Data"
+          },
+          "data_updatetime": {
+            "name": "Actualitzat"
           }
         }
       },
@@ -224,6 +227,9 @@
         "state_attributes": {
           "update_date": {
             "name": "Data"
+          },
+          "data_updatetime": {
+            "name": "Actualitzat"
           }
         }
       },
@@ -236,6 +242,9 @@
         "state_attributes": {
           "update_date": {
             "name": "Data"
+          },
+          "data_updatetime": {
+            "name": "Actualitzat"
           }
         }
       },

package/custom_components/meteocat/translations/en.json

@@ -212,6 +212,9 @@
         "state_attributes": {
           "update_date": {
             "name": "Date"
+          },
+          "data_updatetime": {
+            "name": "Updated"
           }
         }
       },
@@ -224,6 +227,9 @@
         "state_attributes": {
           "update_date": {
             "name": "Date"
+          },
+          "data_updatetime": {
+            "name": "Updated"
           }
         }
       },
@@ -236,6 +242,9 @@
         "state_attributes": {
           "update_date": {
             "name": "Date"
+          },
+          "data_updatetime": {
+            "name": "Updated"
           }
         }
       },

package/custom_components/meteocat/translations/es.json

@@ -212,6 +212,9 @@
         "state_attributes": {
           "update_date": {
             "name": "Fecha"
+          },
+          "data_updatetime": {
+            "name": "Actualizado"
           }
         }
       },
@@ -224,6 +227,9 @@
         "state_attributes": {
           "update_date": {
             "name": "Fecha"
+          },
+          "data_updatetime": {
+            "name": "Actualizado"
           }
         }
       },
@@ -236,6 +242,9 @@
         "state_attributes": {
           "update_date": {
             "name": "Fecha"
+          },
+          "data_updatetime": {
+            "name": "Actualizado"
           }
         }
       },

package/custom_components/meteocat/version.py

@@ -1 +1 @@
-__version__ = "4.0.3"
+__version__ = "4.0.5"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "meteocat",
-  "version": "4.0.3",
+  "version": "4.0.5",
   "description": "[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)\r [![Python version compatibility](https://img.shields.io/pypi/pyversions/meteocat)](https://pypi.org/project/meteocat)\r [![pipeline status](https://gitlab.com/figorr/meteocat/badges/master/pipeline.svg)](https://gitlab.com/figorr/meteocat/commits/master)",
   "main": "index.js",
   "directories": {

package/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "meteocat"
-version = "4.0.3"
+version = "4.0.5"
 description = "Script para obtener datos meteorológicos de la API de Meteocat"
 authors = ["figorr <jdcuartero@yahoo.es>"]
 license = "Apache-2.0"