meteocat 4.0.4 → 4.0.5

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+## [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)
 
 

package/custom_components/meteocat/__init__.py

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

package/custom_components/meteocat/const.py

@@ -61,6 +61,8 @@ 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

package/custom_components/meteocat/coordinator.py

@@ -52,6 +52,8 @@ 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,
@@ -681,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)
 
@@ -769,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
 
     # --------------------------------------------------------------------- #
@@ -836,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:
@@ -860,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.4"
+  "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,6 +1375,7 @@ 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)
 
@@ -1326,7 +1409,7 @@ class MeteocatUviStatusSensor(CoordinatorEntity[MeteocatUviCoordinator], SensorE
     def native_value(self) -> str:
         data_dict = self._get_uvi_data_dict()
         if not data_dict:
-            _LOGGER.debug("UVI Status: no hay data_dict disponible aún")
+            _LOGGER.debug("UVI Status: no hay datos disponibles aún")
             return "unknown"
 
         first_date = self._get_first_date()
@@ -1339,27 +1422,35 @@ class MeteocatUviStatusSensor(CoordinatorEntity[MeteocatUviCoordinator], SensorE
         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 diff: %d | hora actual: %s | umbral días: %d | umbral hora: %02d:%02d",
-            days_difference,
-            current_time.strftime("%H:%M"),
-            DEFAULT_VALIDITY_DAYS,
-            DEFAULT_VALIDITY_HOURS,
-            DEFAULT_VALIDITY_MINUTES,
+            "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 days_difference > DEFAULT_VALIDITY_DAYS and current_time >= time(DEFAULT_VALIDITY_HOURS, DEFAULT_VALIDITY_MINUTES):
+        if cond1 and cond2:
             return "obsolete"
         return "updated"
 
     @property
     def extra_state_attributes(self) -> dict:
-        attributes = {}
-        data_dict = self._get_uvi_data_dict()
+        attributes: dict = {}
 
-        if not data_dict:
-            attributes["debug_info"] = "Aún no hay datos en el coordinador"
-            return attributes
         # Primera fecha de los datos UVI
         first_date = self._get_first_date()
         if first_date:

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"
           }
         }
       },

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"
           }
         }
       },

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"
           }
         }
       },

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"
           }
         }
       },

package/custom_components/meteocat/version.py

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "meteocat",
-  "version": "4.0.4",
+  "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.4"
+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"