meteocat 0.1.41 → 0.1.43

package/CHANGELOG.md

@@ -1,3 +1,27 @@
+## [0.1.43](https://github.com/figorr/meteocat/compare/v0.1.42...v0.1.43) (2024-12-30)
+
+
+### Bug Fixes
+
+* 0.1.43 ([13185b2](https://github.com/figorr/meteocat/commit/13185b2276a5efb02b4fd18d07d30ab03ca7357d))
+* add info station to config_flow ([6c8c652](https://github.com/figorr/meteocat/commit/6c8c652dc54788e2b471984726dc7dd3c0ba30d6))
+* add new hourly, daily and uvi file status sensors ([42aa8b2](https://github.com/figorr/meteocat/commit/42aa8b2abbf6b333287c15d92e19b69d9630e62e))
+* add new hourly, daily and uvi file status sensors translations ([5639489](https://github.com/figorr/meteocat/commit/563948999feb077a5effe9c07df9dda950469d73))
+* add new hourly, daily and uvi sensor constants ([f7a4814](https://github.com/figorr/meteocat/commit/f7a481435abf34926b52312cc5302045c9357e69))
+* fix entity and uvi coordinator ([ee3a557](https://github.com/figorr/meteocat/commit/ee3a5571e5e08737b3393a650509732b1cd4996a))
+* ignore test read json date ([f5ce2ed](https://github.com/figorr/meteocat/commit/f5ce2edfa77d1ec33c4beff8c5c775499c0564fe))
+* include entity and uvi coordinators ([4128d39](https://github.com/figorr/meteocat/commit/4128d3902bd67414eaee6d8d6da4628ecbce3493))
+* set region, province and status to str ([31f58e7](https://github.com/figorr/meteocat/commit/31f58e7d701b2499e4f4d9f385238368703c75ff))
+
+## [0.1.42](https://github.com/figorr/meteocat/compare/v0.1.41...v0.1.42) (2024-12-28)
+
+
+### Bug Fixes
+
+* 0.1.42 ([f180cf1](https://github.com/figorr/meteocat/commit/f180cf1400e614684cfee81849369bb74796ee5e))
+* bump meteocatpy to 0.0.16 ([0e14f79](https://github.com/figorr/meteocat/commit/0e14f79445ee4c059d47a315bcbdc20858a0c666))
+* set logger to warning when using cache data ([b840d72](https://github.com/figorr/meteocat/commit/b840d7202c439f83b08597b9365c007e92aca1c5))
+
 ## [0.1.41](https://github.com/figorr/meteocat/compare/v0.1.40...v0.1.41) (2024-12-27)
 
 

package/custom_components/meteocat/__init__.py

@@ -25,7 +25,7 @@ from .const import DOMAIN, PLATFORMS
 _LOGGER = logging.getLogger(__name__)
 
 # Versión
-__version__ = "0.1.41"
+__version__ = "0.1.43"
 
 def safe_remove(path: Path, is_folder: bool = False):
     """Elimina de forma segura un archivo o carpeta si existe."""
@@ -53,7 +53,8 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     # Validar campos requeridos
     required_fields = [
         "api_key", "town_name", "town_id", "variable_name",
-        "variable_id", "station_name", "station_id"
+        "variable_id", "station_name", "station_id", "province_name", 
+        "province_id", "region_name", "region_id"
     ]
     missing_fields = [field for field in required_fields if field not in entry_data]
     if missing_fields:
@@ -63,7 +64,9 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     _LOGGER.debug(
         f"Datos de configuración: Municipio '{entry_data['town_name']}' (ID: {entry_data['town_id']}), "
         f"Variable '{entry_data['variable_name']}' (ID: {entry_data['variable_id']}), "
-        f"Estación '{entry_data['station_name']}' (ID: {entry_data['station_id']})."
+        f"Estación '{entry_data['station_name']}' (ID: {entry_data['station_id']}), "
+        f"Provincia '{entry_data['province_name']}' (ID: {entry_data['province_id']}), "
+        f"Comarca '{entry_data['region_name']}' (ID: {entry_data['region_id']})."
     )
 
     # Inicializar coordinadores

package/custom_components/meteocat/config_flow.py

@@ -23,7 +23,16 @@ from .const import (
     VARIABLE_NAME,
     VARIABLE_ID,
     STATION_NAME,
-    STATION_ID
+    STATION_ID,
+    STATION_TYPE,
+    LATITUDE,
+    LONGITUDE,
+    ALTITUDE,
+    REGION_ID,
+    REGION_NAME,
+    PROVINCE_ID,
+    PROVINCE_NAME,
+    STATION_STATUS
 )
     
 from .options_flow import MeteocatOptionsFlowHandler
@@ -31,6 +40,8 @@ from meteocatpy.town import MeteocatTown
 from meteocatpy.symbols import MeteocatSymbols
 from meteocatpy.variables import MeteocatVariables
 from meteocatpy.townstations import MeteocatTownStations
+from meteocatpy.infostation import MeteocatInfoStation
+
 from meteocatpy.exceptions import BadRequestError, ForbiddenError, TooManyRequestsError, InternalServerError, UnknownAPIError
 
 _LOGGER = logging.getLogger(__name__)
@@ -103,10 +114,17 @@ class MeteocatConfigFlow(ConfigFlow, domain=DOMAIN):
         errors = {}
 
         # Crear directorio de activos (assets) si no existe
-        assets_dir = Path(__file__).parent / "assets"
-        assets_dir.mkdir(parents=True, exist_ok=True)
-        symbols_file = assets_dir / "symbols.json"
-        variables_file = assets_dir / "variables.json"
+        assets_dir = os.path.join(
+            self.hass.config.path(),
+            "custom_components",
+            "meteocat",
+            "assets"
+        )
+        os.makedirs(assets_dir, exist_ok=True)
+
+        # Rutas para los archivos de símbolos y variables
+        symbols_file = os.path.join(assets_dir, "symbols.json")
+        variables_file = os.path.join(assets_dir, "variables.json")
 
         try:
             # Descargar y guardar los símbolos
@@ -171,6 +189,26 @@ class MeteocatConfigFlow(ConfigFlow, domain=DOMAIN):
                 self.station_id = selected_station["codi"]
                 self.station_name = selected_station["nom"]
 
+                # Obtener metadatos de la estación
+                infostation_client = MeteocatInfoStation(self.api_key)
+                try:
+                    station_metadata = await infostation_client.get_infostation(self.station_id)
+                except Exception as ex:
+                    _LOGGER.error("Error al obtener los metadatos de la estación: %s", ex)
+                    errors["base"] = "metadata_fetch_failed"
+                    station_metadata = {}
+
+                # Extraer los valores necesarios de los metadatos
+                self.station_type = station_metadata.get("tipus", "")
+                self.latitude = station_metadata.get("coordenades", {}).get("latitud", 0.0)
+                self.longitude = station_metadata.get("coordenades", {}).get("longitud", 0.0)
+                self.altitude = station_metadata.get("altitud", 0)
+                self.region_id = station_metadata.get("comarca", {}).get("codi", "")
+                self.region_name = station_metadata.get("comarca", {}).get("nom", "")
+                self.province_id = station_metadata.get("provincia", {}).get("codi", "")
+                self.province_name = station_metadata.get("provincia", {}).get("nom", "")
+                self.station_status = station_metadata.get("estats", [{}])[0].get("codi", "")
+
                 return self.async_create_entry(
                     title=self.selected_municipi["nom"],
                     data={
@@ -180,7 +218,16 @@ class MeteocatConfigFlow(ConfigFlow, domain=DOMAIN):
                         VARIABLE_NAME: "Temperatura",
                         VARIABLE_ID: str(self.variable_id),
                         STATION_NAME: self.station_name,
-                        STATION_ID: self.station_id
+                        STATION_ID: self.station_id,
+                        STATION_TYPE: self.station_type,
+                        LATITUDE: self.latitude,
+                        LONGITUDE: self.longitude,
+                        ALTITUDE: self.altitude,
+                        REGION_ID: str(self.region_id),
+                        REGION_NAME: self.region_name,
+                        PROVINCE_ID: str(self.province_id),
+                        PROVINCE_NAME: self.province_name,
+                        STATION_STATUS: str(self.station_status),
                     },
                 )
             else:

package/custom_components/meteocat/const.py

@@ -8,6 +8,18 @@ VARIABLE_NAME = "variable_name"
 VARIABLE_ID = "variable_id"
 STATION_NAME = "station_name"
 STATION_ID = "station_id"
+STATION_TYPE = "station_type"
+LATITUDE = "latitude"
+LONGITUDE = "longitude"
+ALTITUDE = "altitude"
+REGION_ID = "region_id"
+REGION_NAME = "region_name"
+PROVINCE_ID = "province_id"
+PROVINCE_NAME = "province_name"
+STATION_STATUS = "station_status"
+HOURLY_FORECAST_FILE_STATUS = "hourly_forecast_file_status"
+DAILY_FORECAST_FILE_STATUS = "daily_forecast_file_status"
+UVI_FILE_STATUS = "uvi_file_status"
 
 from homeassistant.const import Platform
 

package/custom_components/meteocat/coordinator.py

@@ -84,7 +84,6 @@ class MeteocatSensorCoordinator(DataUpdateCoordinator):
         self,
         hass: HomeAssistant,
         entry_data: dict,
-        update_interval: timedelta = DEFAULT_SENSOR_UPDATE_INTERVAL,
     ):
         """
         Inicializa el coordinador de sensores de Meteocat.
@@ -103,11 +102,19 @@ class MeteocatSensorCoordinator(DataUpdateCoordinator):
         self.variable_id = entry_data["variable_id"]  # Usamos el ID de la variable
         self.meteocat_station_data = MeteocatStationData(self.api_key)
 
+        self.station_file = os.path.join(
+            hass.config.path(),
+            "custom_components",
+            "meteocat",
+            "files",
+            f"station_{self.station_id.lower()}_data.json"
+        )
+
         super().__init__(
             hass,
             _LOGGER,
             name=f"{DOMAIN} Sensor Coordinator",
-            update_interval=update_interval,
+            update_interval=DEFAULT_SENSOR_UPDATE_INTERVAL,
         )
 
     async def _async_update_data(self) -> Dict:
@@ -129,17 +136,8 @@ class MeteocatSensorCoordinator(DataUpdateCoordinator):
                 )
                 raise ValueError("Formato de datos inválido")
 
-            # Determinar la ruta al archivo en la carpeta raíz del repositorio
-            output_file = os.path.join(
-                self.hass.config.path(),
-                "custom_components",
-                "meteocat",
-                "files",
-                f"station_{self.station_id.lower()}_data.json"
-            )
-
             # Guardar los datos en un archivo JSON
-            await save_json_to_file(data, output_file)
+            await save_json_to_file(data, self.station_file)
 
             return data
         except asyncio.TimeoutError as err:
@@ -182,13 +180,14 @@ class MeteocatSensorCoordinator(DataUpdateCoordinator):
                     self.station_id,
                     err,
                 )
-                # Intentar cargar datos en caché si hay un error
-                cached_data = load_json_from_file(output_file)
-                if cached_data:
-                    _LOGGER.info("Usando datos en caché para la estación %s.", self.station_id)
-                    return cached_data
-                # No se puede actualizar el estado, retornar None o un estado fallido
-                return None  # o cualquier otro valor que indique un estado de error
+        # Intentar cargar datos en caché si hay un error
+        cached_data = load_json_from_file(self.station_file)
+        if cached_data:
+            _LOGGER.warning("Usando datos en caché para la estación %s.", self.station_id)
+            return cached_data
+        # No se puede actualizar el estado, retornar None
+        _LOGGER.error("No se pudo obtener datos actualizados ni cargar datos en caché.")
+        return None  # o cualquier otro valor que indique un estado de error
 
 class MeteocatStaticSensorCoordinator(DataUpdateCoordinator):
     """Coordinator to manage and update static sensor data."""
@@ -197,7 +196,6 @@ class MeteocatStaticSensorCoordinator(DataUpdateCoordinator):
         self,
         hass: HomeAssistant,
         entry_data: dict,
-        update_interval: timedelta = DEFAULT_STATIC_SENSOR_UPDATE_INTERVAL,
     ):
         """
         Initialize the MeteocatStaticSensorCoordinator.
@@ -216,7 +214,7 @@ class MeteocatStaticSensorCoordinator(DataUpdateCoordinator):
             hass,
             _LOGGER,
             name=f"{DOMAIN} Static Sensor Coordinator",
-            update_interval=update_interval,
+            update_interval=DEFAULT_STATIC_SENSOR_UPDATE_INTERVAL,
         )
 
     async def _async_update_data(self):
@@ -240,16 +238,15 @@ class MeteocatStaticSensorCoordinator(DataUpdateCoordinator):
         }
 
 class MeteocatUviCoordinator(DataUpdateCoordinator):
-    """Coordinator para manejar la actualización de datos de los sensores."""
+    """Coordinator para manejar la actualización de datos de UVI desde la API de Meteocat."""
 
     def __init__(
         self,
         hass: HomeAssistant,
         entry_data: dict,
-        update_interval: timedelta = DEFAULT_UVI_UPDATE_INTERVAL,
     ):
         """
-        Inicializa el coordinador del sensor del Índice UV de Meteocat.
+        Inicializa el coordinador del Índice UV de Meteocat.
 
         Args:
             hass (HomeAssistant): Instancia de Home Assistant.
@@ -259,7 +256,7 @@ class MeteocatUviCoordinator(DataUpdateCoordinator):
         self.api_key = entry_data["api_key"]  # Usamos la API key de la configuración
         self.town_id = entry_data["town_id"]  # Usamos el ID del municipio
         self.meteocat_uvi_data = MeteocatUviData(self.api_key)
-        self.output_file = os.path.join(
+        self.uvi_file = os.path.join(
             hass.config.path(),
             "custom_components",
             "meteocat",
@@ -271,43 +268,51 @@ class MeteocatUviCoordinator(DataUpdateCoordinator):
             hass,
             _LOGGER,
             name=f"{DOMAIN} Uvi Coordinator",
-            update_interval=update_interval,
+            update_interval=DEFAULT_UVI_UPDATE_INTERVAL,
         )
 
     async def is_uvi_data_valid(self) -> dict:
         """Comprueba si el archivo JSON contiene datos válidos para el día actual y devuelve los datos si son válidos."""
         try:
-            if not os.path.exists(self.output_file):
+            if not os.path.exists(self.uvi_file):
+                _LOGGER.info("El archivo %s no existe. Se considerará inválido.", self.uvi_file)
                 return None
 
-            async with aiofiles.open(self.output_file, "r", encoding="utf-8") as file:
+            async with aiofiles.open(self.uvi_file, "r", encoding="utf-8") as file:
                 content = await file.read()
                 data = json.loads(content)
 
-            # Verificar que el formato sea correcto
-            if not isinstance(data, dict) or "uvi" not in data:
-                return None
+             # Validar la fecha del primer elemento superior a 1 día
+            first_date = datetime.strptime(data["uvi"][0].get("date"), "%Y-%m-%d").date()
+            today = datetime.now(timezone.utc).date()
 
-            uvi_data = data["uvi"]
-            if not isinstance(uvi_data, list) or not uvi_data:
-                return None
+            # Log detallado
+            _LOGGER.info(
+                "Validando datos UVI en %s: Fecha de hoy: %s, Fecha del primer elemento: %s",
+                self.uvi_file,
+                today,
+                first_date,
+            )
 
-             # Validar la fecha del primer elemento superior a 1 día
-            first_date = datetime.strptime(uvi_data[0].get("date"), "%Y-%m-%d").date()
-            if (datetime.now(timezone.utc).date() - first_date).days > 1:
+            # Verificar si la antigüedad es mayor a un día
+            if (today - first_date).days > 1:
+                _LOGGER.info(
+                    "Los datos en %s son antiguos. Se procederá a llamar a la API.",
+                    self.uvi_file,
+                )
                 return None
-
+            _LOGGER.info("Los datos en %s son válidos. Se usarán sin llamar a la API.", self.uvi_file)
             return data
         except Exception as e:
             _LOGGER.error("Error al validar el archivo JSON del índice UV: %s", e)
             return None
 
     async def _async_update_data(self) -> Dict:
-        """Actualiza los datos de los sensores desde la API de Meteocat."""
+        """Actualiza los datos de UVI desde la API de Meteocat."""
         try:
             # Validar el archivo JSON existente
             valid_data = await self.is_uvi_data_valid()
-            if valid_data and "uvi" in valid_data:
+            if valid_data:
                 _LOGGER.info("Los datos del índice UV están actualizados. No se realiza llamada a la API.")
                 return valid_data['uvi']
 
@@ -316,7 +321,7 @@ class MeteocatUviCoordinator(DataUpdateCoordinator):
                 self.meteocat_uvi_data.get_uvi_index(self.town_id),
                 timeout=30  # Tiempo límite de 30 segundos
             )
-            _LOGGER.debug("Datos de sensores actualizados exitosamente: %s", data)
+            _LOGGER.debug("Datos actualizados exitosamente: %s", data)
 
             # Validar que los datos sean un dict con una clave 'uvi'
             if not isinstance(data, dict) or 'uvi' not in data:
@@ -324,7 +329,7 @@ class MeteocatUviCoordinator(DataUpdateCoordinator):
                 raise ValueError("Formato de datos inválido")
 
             # Guardar los datos en un archivo JSON
-            await save_json_to_file(data, self.output_file)
+            await save_json_to_file(data, self.uvi_file)
 
             return data['uvi']
         except asyncio.TimeoutError as err:
@@ -357,12 +362,14 @@ class MeteocatUviCoordinator(DataUpdateCoordinator):
                 self.town_id,
                 err,
             )
-            # Intentar cargar datos en caché si hay un error
-            cached_data = load_json_from_file(self.output_file)
-            if cached_data:
-                _LOGGER.info("Usando datos en caché para la ciudad %s.", self.town_id)
-                return cached_data.get('uvi', [])
-            return None
+        # Intentar cargar datos en caché si hay un error
+        cached_data = load_json_from_file(self.uvi_file)
+        if cached_data:
+            _LOGGER.warning("Usando datos en caché para la ciudad %s.", self.town_id)
+            return cached_data.get('uvi', [])
+        # No se puede actualizar el estado, retornar None
+        _LOGGER.error("No se pudo obtener datos actualizados ni cargar datos en caché.")
+        return None
 
 class MeteocatUviFileCoordinator(DataUpdateCoordinator):
     """Coordinator to read and process UV data from a file."""
@@ -371,7 +378,6 @@ class MeteocatUviFileCoordinator(DataUpdateCoordinator):
         self,
         hass: HomeAssistant,
         entry_data: dict,
-        update_interval: timedelta = DEFAULT_UVI_SENSOR_UPDATE_INTERVAL,
     ):
         """
         Inicializa el coordinador del sensor del Índice UV de Meteocat.
@@ -387,7 +393,7 @@ class MeteocatUviFileCoordinator(DataUpdateCoordinator):
             hass,
             _LOGGER,
             name=f"{DOMAIN} Uvi File Coordinator",
-            update_interval=update_interval,
+            update_interval=DEFAULT_UVI_SENSOR_UPDATE_INTERVAL,
         )
         self._file_path = os.path.join(
             hass.config.path("custom_components/meteocat/files"),
@@ -449,7 +455,6 @@ class MeteocatEntityCoordinator(DataUpdateCoordinator):
         self,
         hass: HomeAssistant,
         entry_data: dict,
-        update_interval: timedelta = DEFAULT_ENTITY_UPDATE_INTERVAL,
     ):
         """
         Inicializa el coordinador de datos para entidades de predicción.
@@ -468,35 +473,62 @@ class MeteocatEntityCoordinator(DataUpdateCoordinator):
         self.variable_id = entry_data["variable_id"]
         self.meteocat_forecast = MeteocatForecast(self.api_key)
 
+        self.hourly_file = os.path.join(
+            hass.config.path(),
+            "custom_components",
+            "meteocat",
+            "files",
+            f"forecast_{self.town_id}_hourly_data.json",
+        )
+        self.daily_file = os.path.join(
+            hass.config.path(),
+            "custom_components",
+            "meteocat",
+            "files",
+            f"forecast_{self.town_id}_daily_data.json",
+        )
+
         super().__init__(
             hass,
             _LOGGER,
             name=f"{DOMAIN} Entity Coordinator",
-            update_interval=update_interval,
+            update_interval=DEFAULT_ENTITY_UPDATE_INTERVAL,
         )
 
-    async def _is_data_valid(self, file_path: str) -> bool:
-        """Verifica si los datos en el archivo JSON son válidos y actuales."""
+    async def validate_forecast_data(self, file_path: str) -> dict:
+        """Valida y retorna datos de predicción si son válidos."""
         if not os.path.exists(file_path):
-            return False
-
+            _LOGGER.info("El archivo %s no existe. Se considerará inválido.", 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)
 
-            if not data or "dies" not in data or not data["dies"]:
-                return False
-
             # Obtener la fecha del primer día
             first_date = datetime.fromisoformat(data["dies"][0]["data"].rstrip("Z")).date()
             today = datetime.now(timezone.utc).date()
 
+            # Log detallado
+            _LOGGER.info(
+                "Validando datos en %s: Fecha de hoy: %s, Fecha del primer elemento: %s",
+                file_path,
+                today,
+                first_date,
+            )
+
             # Verificar si la antigüedad es mayor a un día
-            return (today - first_date).days <= 1
+            if (today - first_date).days > 1:
+                _LOGGER.info(
+                    "Los datos en %s son antiguos. Se procederá a llamar a la API.",
+                    file_path,
+                )
+                return None
+            _LOGGER.info("Los datos en %s son válidos. Se usarán sin llamar a la API.", file_path)
+            return data
         except Exception as e:
             _LOGGER.warning("Error validando datos en %s: %s", file_path, e)
-            return False
+            return None
 
     async def _fetch_and_save_data(self, api_method, file_path: str) -> dict:
         """Obtiene datos de la API y los guarda en un archivo JSON."""
@@ -504,44 +536,25 @@ class MeteocatEntityCoordinator(DataUpdateCoordinator):
         await save_json_to_file(data, file_path)
         return data
 
-    async def _async_update_data(self) -> Dict:
-        """Actualiza los datos de predicción desde la API de Meteocat."""
-        hourly_file = os.path.join(
-            self.hass.config.path(),
-            "custom_components",
-            "meteocat",
-            "files",
-            f"forecast_{self.town_id.lower()}_hourly_data.json",
-        )
-        daily_file = os.path.join(
-            self.hass.config.path(),
-            "custom_components",
-            "meteocat",
-            "files",
-            f"forecast_{self.town_id.lower()}_daily_data.json",
-        )
-
+    async def _async_update_data(self) -> dict:
+        """Actualiza los datos de predicción horaria y diaria."""
         try:
-            hourly_data = (
-                load_json_from_file(hourly_file)
-                if await self._is_data_valid(hourly_file)
-                else await self._fetch_and_save_data(
-                    self.meteocat_forecast.get_prediccion_horaria, hourly_file
+            # Validar o actualizar datos horarios
+            hourly_data = await self.validate_forecast_data(self.hourly_file)
+            if not hourly_data:
+                hourly_data = await self._fetch_and_save_data(
+                    self.meteocat_forecast.get_prediccion_horaria, self.hourly_file
                 )
-            )
-            daily_data = (
-                load_json_from_file(daily_file)
-                if await self._is_data_valid(daily_file)
-                else await self._fetch_and_save_data(
-                    self.meteocat_forecast.get_prediccion_diaria, daily_file
+
+            # Validar o actualizar datos diarios
+            daily_data = await self.validate_forecast_data(self.daily_file)
+            if not daily_data:
+                daily_data = await self._fetch_and_save_data(
+                    self.meteocat_forecast.get_prediccion_diaria, self.daily_file
                 )
-            )
 
-            _LOGGER.debug(
-                "Datos de predicción horaria y diaria actualizados correctamente para %s.",
-                self.town_id,
-            )
             return {"hourly": hourly_data, "daily": daily_data}
+
         except asyncio.TimeoutError as err:
             _LOGGER.warning("Tiempo de espera agotado al obtener datos de predicción.")
             raise ConfigEntryNotReady from err
@@ -568,10 +581,19 @@ class MeteocatEntityCoordinator(DataUpdateCoordinator):
             raise
         except Exception as err:
             _LOGGER.exception("Error inesperado al obtener datos de predicción: %s", err)
-            return {
-                "hourly": load_json_from_file(hourly_file) or {},
-                "daily": load_json_from_file(daily_file) or {},
-            }
+
+        # Si ocurre un error, intentar cargar datos desde los archivos locales
+        hourly_cache = load_json_from_file(self.hourly_file) or {}
+        daily_cache = load_json_from_file(self.daily_file) or {}
+
+        _LOGGER.warning(
+            "Cargando datos desde caché para %s. Datos horarios: %s, Datos diarios: %s",
+            self.town_id,
+            "Encontrados" if hourly_cache else "No encontrados",
+            "Encontrados" if daily_cache else "No encontrados",
+        )
+
+        return {"hourly": hourly_cache, "daily": daily_cache}
 
 def get_condition_from_code(code: int) -> str:
     """Devuelve la condición meteorológica basada en el código."""
@@ -584,7 +606,6 @@ class HourlyForecastCoordinator(DataUpdateCoordinator):
         self,
         hass: HomeAssistant,
         entry_data: dict,
-        update_interval: timedelta = DEFAULT_HOURLY_FORECAST_UPDATE_INTERVAL,
     ):
         """Inicializa el coordinador para predicciones horarias."""
         self.town_name = entry_data["town_name"]
@@ -602,7 +623,7 @@ class HourlyForecastCoordinator(DataUpdateCoordinator):
             hass,
             _LOGGER,
             name=f"{DOMAIN} Hourly Forecast Coordinator",
-            update_interval=update_interval,
+            update_interval=DEFAULT_HOURLY_FORECAST_UPDATE_INTERVAL,
         )
 
     async def _is_data_valid(self) -> bool:
@@ -716,7 +737,6 @@ class DailyForecastCoordinator(DataUpdateCoordinator):
         self,
         hass: HomeAssistant,
         entry_data: dict,
-        update_interval: timedelta = DEFAULT_DAILY_FORECAST_UPDATE_INTERVAL,
     ):
         """Inicializa el coordinador para predicciones diarias."""
         self.town_name = entry_data["town_name"]
@@ -734,7 +754,7 @@ class DailyForecastCoordinator(DataUpdateCoordinator):
             hass,
             _LOGGER,
             name=f"{DOMAIN} Daily Forecast Coordinator",
-            update_interval=update_interval,
+            update_interval=DEFAULT_DAILY_FORECAST_UPDATE_INTERVAL,
         )
 
     async def _is_data_valid(self) -> bool:
@@ -827,7 +847,6 @@ class MeteocatConditionCoordinator(DataUpdateCoordinator):
         self,
         hass: HomeAssistant,
         entry_data: dict,
-        update_interval: timedelta = DEFAULT_CONDITION_SENSOR_UPDATE_INTERVAL,
     ):
         """
         Initialize the Meteocat Condition Coordinator.
@@ -844,7 +863,7 @@ class MeteocatConditionCoordinator(DataUpdateCoordinator):
             hass,
             _LOGGER,
             name=f"{DOMAIN} Condition Coordinator",
-            update_interval=update_interval,
+            update_interval=DEFAULT_CONDITION_SENSOR_UPDATE_INTERVAL,
         )
 
         self._file_path = os.path.join(
@@ -927,7 +946,6 @@ class MeteocatTempForecastCoordinator(DataUpdateCoordinator):
         self,
         hass: HomeAssistant,
         entry_data: dict,
-        update_interval: timedelta = DEFAULT_TEMP_FORECAST_UPDATE_INTERVAL,
     ):
         """Inicializa el coordinador para predicciones diarias."""
         self.town_name = entry_data["town_name"]
@@ -945,7 +963,7 @@ class MeteocatTempForecastCoordinator(DataUpdateCoordinator):
             hass,
             _LOGGER,
             name=f"{DOMAIN} Daily Forecast Coordinator",
-            update_interval=update_interval,
+            update_interval=DEFAULT_TEMP_FORECAST_UPDATE_INTERVAL,
         )
 
     async def _is_data_valid(self) -> bool:
@@ -990,7 +1008,7 @@ class MeteocatTempForecastCoordinator(DataUpdateCoordinator):
                 # Usar datos del día actual si están disponibles
                 today_temp_forecast = self.get_temp_forecast_for_today(data)
                 if today_temp_forecast:
-                    parsed_data = self.parse_forecast(today_temp_forecast)
+                    parsed_data = self.parse_temp_forecast(today_temp_forecast)
                     return parsed_data
             except Exception as e:
                 _LOGGER.warning("Error leyendo archivo de predicción diaria: %s", e)
@@ -1009,7 +1027,7 @@ class MeteocatTempForecastCoordinator(DataUpdateCoordinator):
                 return dia
         return None
 
-    def parse_forecast(self, dia: dict) -> dict:
+    def parse_temp_forecast(self, dia: dict) -> dict:
         """Convierte un día de predicción en un diccionario con los datos necesarios."""
         variables = dia.get("variables", {})
 

package/custom_components/meteocat/manifest.json

@@ -7,6 +7,6 @@
     "iot_class": "cloud_polling",
     "documentation": "https://gitlab.com/figorr/meteocat",
     "loggers": ["meteocatpy"],
-    "requirements": ["meteocatpy==0.0.15", "packaging>=20.3", "wrapt>=1.14.0"],
-    "version": "0.1.41"
+    "requirements": ["meteocatpy==0.0.17", "packaging>=20.3", "wrapt>=1.14.0"],
+    "version": "0.1.43"
 }

package/custom_components/meteocat/sensor.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from datetime import datetime
+from datetime import datetime, timezone
 import logging
 from homeassistant.helpers.entity import (
     DeviceInfo,
@@ -48,6 +48,9 @@ from .const import (
     CONDITION,
     MAX_TEMPERATURE_FORECAST,
     MIN_TEMPERATURE_FORECAST,
+    HOURLY_FORECAST_FILE_STATUS,
+    DAILY_FORECAST_FILE_STATUS,
+    UVI_FILE_STATUS,
     WIND_SPEED_CODE,
     WIND_DIRECTION_CODE,
     TEMPERATURE_CODE,
@@ -68,6 +71,8 @@ from .coordinator import (
     MeteocatUviFileCoordinator,
     MeteocatConditionCoordinator,
     MeteocatTempForecastCoordinator,
+    MeteocatEntityCoordinator,
+    MeteocatUviCoordinator,
 )
 
 _LOGGER = logging.getLogger(__name__)
@@ -229,6 +234,24 @@ SENSOR_TYPES: tuple[MeteocatSensorEntityDescription, ...] = (
         state_class=SensorStateClass.MEASUREMENT,
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
     ),
+    MeteocatSensorEntityDescription(
+        key=HOURLY_FORECAST_FILE_STATUS,
+        translation_key="hourly_forecast_file_status",
+        icon="mdi:clock",
+        entity_category=EntityCategory.DIAGNOSTIC,
+    ),
+    MeteocatSensorEntityDescription(
+        key=DAILY_FORECAST_FILE_STATUS,
+        translation_key="daily_forecast_file_status",
+        icon="mdi:clock",
+        entity_category=EntityCategory.DIAGNOSTIC,
+    ),
+    MeteocatSensorEntityDescription(
+        key=UVI_FILE_STATUS,
+        translation_key="uvi_file_status",
+        icon="mdi:clock",
+        entity_category=EntityCategory.DIAGNOSTIC,
+    )
 )
 
 @callback
@@ -242,12 +265,14 @@ async def async_setup_entry(hass, entry, async_add_entities: AddEntitiesCallback
     static_sensor_coordinator = entry_data.get("static_sensor_coordinator")
     condition_coordinator = entry_data.get("condition_coordinator")
     temp_forecast_coordinator = entry_data.get("temp_forecast_coordinator")
+    entity_coordinator = entry_data.get("entity_coordinator")
+    uvi_coordinator = entry_data.get("uvi_coordinator")
 
     # Sensores generales
     async_add_entities(
         MeteocatSensor(coordinator, description, entry_data)
         for description in SENSOR_TYPES
-        if description.key not in {TOWN_NAME, TOWN_ID, STATION_NAME, STATION_ID, UV_INDEX, CONDITION, MAX_TEMPERATURE_FORECAST, MIN_TEMPERATURE_FORECAST}  # Excluir estáticos y UVI
+        if description.key not in {TOWN_NAME, TOWN_ID, STATION_NAME, STATION_ID, UV_INDEX, CONDITION, MAX_TEMPERATURE_FORECAST, MIN_TEMPERATURE_FORECAST, HOURLY_FORECAST_FILE_STATUS, DAILY_FORECAST_FILE_STATUS, UVI_FILE_STATUS}  # Excluir estáticos y UVI
     )
 
     # Sensores estáticos
@@ -278,6 +303,27 @@ async def async_setup_entry(hass, entry, async_add_entities: AddEntitiesCallback
         if description.key in {MAX_TEMPERATURE_FORECAST, MIN_TEMPERATURE_FORECAST}
     )
 
+    # Sensores de estado de los archivos de previsión horaria
+    async_add_entities(
+        MeteocatHourlyForecastStatusSensor(entity_coordinator, description, entry_data)
+        for description in SENSOR_TYPES
+        if description.key == HOURLY_FORECAST_FILE_STATUS
+    )
+
+    # Sensores de estado de los archivos de previsión diaria
+    async_add_entities(
+        MeteocatDailyForecastStatusSensor(entity_coordinator, description, entry_data)
+        for description in SENSOR_TYPES
+        if description.key == DAILY_FORECAST_FILE_STATUS
+    )
+
+    # Sensores de estado de los archivos de uvi
+    async_add_entities(
+        MeteocatUviStatusSensor(uvi_coordinator, description, entry_data)
+        for description in SENSOR_TYPES
+        if description.key == UVI_FILE_STATUS
+    )
+
 class MeteocatStaticSensor(CoordinatorEntity[MeteocatStaticSensorCoordinator], SensorEntity):
     """Representation of a static Meteocat sensor."""
     STATIC_KEYS = {TOWN_NAME, TOWN_ID, STATION_NAME, STATION_ID}
@@ -718,3 +764,116 @@ class MeteocatTempForecast(CoordinatorEntity[MeteocatTempForecastCoordinator], S
             manufacturer="Meteocat",
             model="Meteocat API",
         )
+
+class MeteocatHourlyForecastStatusSensor(CoordinatorEntity[MeteocatEntityCoordinator], SensorEntity):
+
+    _attr_has_entity_name = True  # Activa el uso de nombres basados en el dispositivo
+
+    def __init__(self, entity_coordinator, description, entry_data):
+        super().__init__(entity_coordinator)
+        self.entity_description = description
+        self._town_name = entry_data["town_name"]
+        self._town_id = entry_data["town_id"]
+        self._station_id = entry_data["station_id"]
+
+        # Unique ID for the entity
+        self._attr_unique_id = f"sensor.{DOMAIN}_{self._station_id}_hourly_status"
+
+        # Assign entity_category if defined in the description
+        self._attr_entity_category = getattr(description, "entity_category", None)
+
+    @property
+    def native_value(self):
+        hourly_data = self.coordinator.data.get("hourly")
+        if hourly_data and "dies" in hourly_data:
+            first_date = datetime.fromisoformat(hourly_data["dies"][0]["data"].rstrip("Z")).date()
+            today = datetime.now(timezone.utc).date()
+            days_difference = (today - first_date).days
+            _LOGGER.debug(f"Diferencia de días para predicciones horarias: {days_difference}")
+            return "updated" if days_difference <= 1 else "obsolete"
+        return "unknown"
+    
+    @property
+    def device_info(self) -> DeviceInfo:
+        """Return the device info."""
+        return DeviceInfo(
+            identifiers={(DOMAIN, self._town_id)},
+            name="Meteocat " + self._station_id + " " + self._town_name,
+            manufacturer="Meteocat",
+            model="Meteocat API",
+        )
+
+class MeteocatDailyForecastStatusSensor(CoordinatorEntity[MeteocatEntityCoordinator], SensorEntity):
+
+    _attr_has_entity_name = True  # Activa el uso de nombres basados en el dispositivo
+
+    def __init__(self, entity_coordinator, description, entry_data):
+        super().__init__(entity_coordinator)
+        self.entity_description = description
+        self._town_name = entry_data["town_name"]
+        self._town_id = entry_data["town_id"]
+        self._station_id = entry_data["station_id"]
+
+        # Unique ID for the entity
+        self._attr_unique_id = f"sensor.{DOMAIN}_{self._station_id}_daily_status"
+
+        # Assign entity_category if defined in the description
+        self._attr_entity_category = getattr(description, "entity_category", None)
+
+    @property
+    def native_value(self):
+        daily_data = self.coordinator.data.get("daily")
+        if daily_data and "dies" in daily_data:
+            first_date = datetime.fromisoformat(daily_data["dies"][0]["data"].rstrip("Z")).date()
+            today = datetime.now(timezone.utc).date()
+            days_difference = (today - first_date).days
+            _LOGGER.debug(f"Diferencia de días para predicciones diarias: {days_difference}")
+            return "updated" if days_difference <= 1 else "obsolete"
+        return "unknown"
+    
+    @property
+    def device_info(self) -> DeviceInfo:
+        """Return the device info."""
+        return DeviceInfo(
+            identifiers={(DOMAIN, self._town_id)},
+            name="Meteocat " + self._station_id + " " + self._town_name,
+            manufacturer="Meteocat",
+            model="Meteocat API",
+        )
+
+class MeteocatUviStatusSensor(CoordinatorEntity[MeteocatUviCoordinator], SensorEntity):
+
+    _attr_has_entity_name = True  # Activa el uso de nombres basados en el dispositivo
+
+    def __init__(self, uvi_coordinator, description, entry_data):
+        super().__init__(uvi_coordinator)
+        self.entity_description = description
+        self._town_name = entry_data["town_name"]
+        self._town_id = entry_data["town_id"]
+        self._station_id = entry_data["station_id"]
+
+        # Unique ID for the entity
+        self._attr_unique_id = f"sensor.{DOMAIN}_{self._station_id}_uvi_status"
+
+        # Assign entity_category if defined in the description
+        self._attr_entity_category = getattr(description, "entity_category", None)
+
+    @property
+    def native_value(self):
+        if self.coordinator.data:
+            first_date = datetime.strptime(self.coordinator.data[0].get("date"), "%Y-%m-%d").date()
+            today = datetime.now(timezone.utc).date()
+            days_difference = (today - first_date).days
+            _LOGGER.debug(f"Diferencia de días para UVI: {days_difference}")
+            return "updated" if days_difference <= 1 else "obsolete"
+        return "unknown"
+    
+    @property
+    def device_info(self) -> DeviceInfo:
+        """Return the device info."""
+        return DeviceInfo(
+            identifiers={(DOMAIN, self._town_id)},
+            name="Meteocat " + self._station_id + " " + self._town_name,
+            manufacturer="Meteocat",
+            model="Meteocat API",
+        )

package/custom_components/meteocat/strings.json

@@ -133,8 +133,16 @@
       },
       "min_temperature_forecast": {
         "name": "Min Temperature Today"
+      },
+      "hourly_forecast_file_status": {
+        "name": "Hourly File"
+      },
+      "daily_forecast_file_status": {
+        "name": "Daily File"
+      },
+      "uvi_file_status": {
+        "name": "Uvi File"
       }
     }
   }
 }
- 

package/custom_components/meteocat/translations/ca.json

@@ -133,6 +133,15 @@
       },
       "min_temperature_forecast": {
         "name": "Temperatura Min Avui"
+      },
+      "hourly_forecast_file_status": {
+        "name": "Arxiu Horari"
+      },
+      "daily_forecast_file_status": {
+        "name": "Arxiu Diari"
+      },
+      "uvi_file_status": {
+        "name": "Arxiu UVI"
       }
     }
   }

package/custom_components/meteocat/translations/en.json

@@ -133,6 +133,15 @@
       },
       "min_temperature_forecast": {
         "name": "Min Temperature Today"
+      },
+      "hourly_forecast_file_status": {
+        "name": "Hourly File"
+      },
+      "daily_forecast_file_status": {
+        "name": "Daily File"
+      },
+      "uvi_file_status": {
+        "name": "Uvi File"
       }
     }
   }

package/custom_components/meteocat/translations/es.json

@@ -133,6 +133,15 @@
       },
       "min_temperature_forecast": {
         "name": "Temperatura Min Hoy"
+      },
+      "hourly_forecast_file_status": {
+        "name": "Archivo Horario"
+      },
+      "daily_forecast_file_status": {
+        "name": "Archivo Diario"
+      },
+      "uvi_file_status": {
+        "name": "Archivo UVI"
       }
     }
   }

package/custom_components/meteocat/version.py

@@ -1,2 +1,2 @@
 # version.py
-__version__ = "0.1.41"
+__version__ = "0.1.43"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "meteocat",
-  "version": "0.1.41",
+  "version": "0.1.43",
   "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 = "0.1.41"
+version = "0.1.43"
 description = "Script para obtener datos meteorológicos de la API de Meteocat"
 authors = ["figorr <jdcuartero@yahoo.es>"]
 license = "Apache-2.0"