meteocat 0.1.40 → 0.1.42

package/CHANGELOG.md

@@ -1,3 +1,26 @@
+## [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)
+
+
+### Bug Fixes
+
+* 0.1.41 ([ba2c800](https://github.com/figorr/meteocat/commit/ba2c80048cc2da6efe5f950a5d8fb958a53a7ef6))
+* add new Max and Min Today Temperature sensors ([6cc726d](https://github.com/figorr/meteocat/commit/6cc726d127432ddc13a54638157f1f9566967ed4))
+* add Today temp max and min translations ([8e1d31e](https://github.com/figorr/meteocat/commit/8e1d31e78c1d5df61c37635a19d95b6339f0b0a5))
+* add Today temp max and min translations ([041c3ab](https://github.com/figorr/meteocat/commit/041c3ab877b269f3b3d3359792ecf13b14969466))
+* add Today temp max and min translations ([be25fc4](https://github.com/figorr/meteocat/commit/be25fc43bef58e1cecc2afaff8e0b8d3288399fb))
+* add Today temp max and min translations ([e236182](https://github.com/figorr/meteocat/commit/e236182dfe29b15c3eb06d6a8fd3e02712837858))
+* fix condition when is night ([fb64e0b](https://github.com/figorr/meteocat/commit/fb64e0b754eb5a39afe9135a0be842d5e8bdeae0))
+* fix sunset and sunrise events for night flag ([4770e56](https://github.com/figorr/meteocat/commit/4770e5633707933c0bdd2aae0f74ada363da86bb))
+
 ## [0.1.40](https://github.com/figorr/meteocat/compare/v0.1.39...v0.1.40) (2024-12-26)
 
 

package/custom_components/meteocat/__init__.py

@@ -17,6 +17,7 @@ from .coordinator import (
     HourlyForecastCoordinator,
     DailyForecastCoordinator,
     MeteocatConditionCoordinator,
+    MeteocatTempForecastCoordinator,
 )
 
 from .const import DOMAIN, PLATFORMS
@@ -24,7 +25,7 @@ from .const import DOMAIN, PLATFORMS
 _LOGGER = logging.getLogger(__name__)
 
 # Versión
-__version__ = "0.1.40"
+__version__ = "0.1.42"
 
 def safe_remove(path: Path, is_folder: bool = False):
     """Elimina de forma segura un archivo o carpeta si existe."""
@@ -91,6 +92,9 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
         condition_coordinator = MeteocatConditionCoordinator(hass=hass, entry_data=entry_data)
         await condition_coordinator.async_config_entry_first_refresh()
 
+        temp_forecast_coordinator = MeteocatTempForecastCoordinator(hass=hass, entry_data=entry_data)
+        await temp_forecast_coordinator.async_config_entry_first_refresh()
+
     except Exception as err:  # Capturar todos los errores
         _LOGGER.exception(f"Error al inicializar los coordinadores: {err}")
         return False
@@ -106,6 +110,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
         "hourly_forecast_coordinator": hourly_forecast_coordinator,
         "daily_forecast_coordinator": daily_forecast_coordinator,
         "condition_coordinator": condition_coordinator,
+        "temp_forecast_coordinator": temp_forecast_coordinator,
         **entry_data,
     }
 

package/custom_components/meteocat/condition.py

@@ -3,7 +3,9 @@ from __future__ import annotations
 from datetime import datetime
 from .const import CONDITION_MAPPING
 from .helpers import is_night
+import logging
 
+_LOGGER = logging.getLogger(__name__)
 
 def get_condition_from_statcel(
     codi_estatcel, current_time: datetime, hass, is_hourly: bool = True
@@ -17,6 +19,13 @@ def get_condition_from_statcel(
     :param is_hourly: Indica si los datos son de predicción horaria (True) o diaria (False).
     :return: Diccionario con la condición y el icono.
     """
+    
+    _LOGGER.debug(
+        "Entrando en get_condition_from_statcel con codi_estatcel: %s, is_hourly: %s",
+        codi_estatcel,
+        is_hourly,
+    )
+
     # Asegurarse de que codi_estatcel sea una lista válida
     if codi_estatcel is None:
         codi_estatcel = []
@@ -31,7 +40,19 @@ def get_condition_from_statcel(
         if any(code in codes for code in codi_estatcel):
             # Ajustar para condiciones nocturnas si aplica
             if condition == "sunny" and is_night_flag:
+                _LOGGER.debug(
+                    "Códigos EstatCel: %s, Es Noche: %s, Condición Devuelta: clear-night",
+                    codi_estatcel,
+                    is_night_flag,
+                )
                 return {"condition": "clear-night", "icon": None}
+            
+            _LOGGER.debug(
+                "Códigos EstatCel: %s, Es Noche: %s, Condición Devuelta: %s",
+                codi_estatcel,
+                is_night_flag,
+                condition,
+            )
             return {"condition": condition, "icon": None}
 
     # Si no coincide ningún código, devolver condición desconocida

package/custom_components/meteocat/const.py

@@ -32,6 +32,8 @@ FEELS_LIKE = "feels_like"  # Sensación térmica
 WIND_GUST = "wind_gust"  # Racha de viento
 STATION_TIMESTAMP = "station_timestamp"  # Código de tiempo de la estación
 CONDITION = "condition"  # Estado del cielo
+MAX_TEMPERATURE_FORECAST = "max_temperature_forecast"  # Temperatura máxima prevista
+MIN_TEMPERATURE_FORECAST = "min_temperature_forecast"  # Temperatura mínima prevista
 
 # Definición de códigos para variables
 WIND_SPEED_CODE = 30

package/custom_components/meteocat/coordinator.py

@@ -36,12 +36,13 @@ _LOGGER = logging.getLogger(__name__)
 # Valores predeterminados para los intervalos de actualización
 DEFAULT_SENSOR_UPDATE_INTERVAL = timedelta(minutes=90)
 DEFAULT_STATIC_SENSOR_UPDATE_INTERVAL = timedelta(hours=24)
-DEFAULT_ENTITY_UPDATE_INTERVAL = timedelta(hours=48)
+DEFAULT_ENTITY_UPDATE_INTERVAL = timedelta(minutes=60)
 DEFAULT_HOURLY_FORECAST_UPDATE_INTERVAL = timedelta(minutes=5)
 DEFAULT_DAILY_FORECAST_UPDATE_INTERVAL = timedelta(minutes=15)
-DEFAULT_UVI_UPDATE_INTERVAL = timedelta(hours=48)
+DEFAULT_UVI_UPDATE_INTERVAL = timedelta(minutes=60)
 DEFAULT_UVI_SENSOR_UPDATE_INTERVAL = timedelta(minutes=5)
 DEFAULT_CONDITION_SENSOR_UPDATE_INTERVAL = timedelta(minutes=5)
+DEFAULT_TEMP_FORECAST_UPDATE_INTERVAL = timedelta(minutes=5)
 
 async def save_json_to_file(data: dict, output_file: str) -> None:
     """Guarda datos JSON en un archivo de forma asíncrona."""
@@ -83,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.
@@ -102,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:
@@ -128,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:
@@ -181,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."""
@@ -196,7 +196,6 @@ class MeteocatStaticSensorCoordinator(DataUpdateCoordinator):
         self,
         hass: HomeAssistant,
         entry_data: dict,
-        update_interval: timedelta = DEFAULT_STATIC_SENSOR_UPDATE_INTERVAL,
     ):
         """
         Initialize the MeteocatStaticSensorCoordinator.
@@ -215,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):
@@ -239,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.
@@ -258,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",
@@ -270,16 +268,16 @@ 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):
                 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)
 
@@ -291,18 +289,33 @@ class MeteocatUviCoordinator(DataUpdateCoordinator):
             if not isinstance(uvi_data, list) or not uvi_data:
                 return None
 
-            # Validar la fecha del primer elemento
-            first_date = uvi_data[0].get("date")
-            if first_date != datetime.now(timezone.utc).strftime("%Y-%m-%d"):
-                return None
+             # Validar la fecha del primer elemento superior a 1 día
+            first_date = datetime.strptime(uvi_data[0].get("date"), "%Y-%m-%d").date()
+            today = datetime.now(timezone.utc).date()
+
+            # Log detallado
+            _LOGGER.info(
+                "Validando datos UVI en %s: Fecha de hoy: %s, Fecha del primer elemento: %s",
+                self.uvi_file,
+                today,
+                first_date,
+            )
 
+            # 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()
@@ -315,7 +328,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:
@@ -323,7 +336,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:
@@ -356,12 +369,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."""
@@ -370,7 +385,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.
@@ -386,7 +400,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"),
@@ -448,7 +462,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.
@@ -467,32 +480,64 @@ 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
-
+            if "dies" not in data or not data["dies"]:
+                _LOGGER.warning("El archivo %s no contiene datos válidos.", file_path)
+                return None
             # Obtener la fecha del primer día
             first_date = datetime.fromisoformat(data["dies"][0]["data"].rstrip("Z")).date()
-            return first_date == datetime.now(timezone.utc).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
+            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."""
@@ -500,44 +545,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
@@ -564,10 +590,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."""
@@ -580,7 +615,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"]
@@ -598,7 +632,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:
@@ -646,7 +680,15 @@ class HourlyForecastCoordinator(DataUpdateCoordinator):
              datetime.fromisoformat(item["data"].rstrip("Z")).replace(tzinfo=timezone.utc) == forecast_time),
             -1,
         )
-        condition = get_condition_from_code(int(condition_code))
+        
+        # Determinar la condición usando `get_condition_from_statcel`
+        condition_data = get_condition_from_statcel(
+            codi_estatcel=condition_code,
+            current_time=forecast_time,
+            hass=self.hass,
+            is_hourly=True
+        )
+        condition = condition_data["condition"]
 
         return {
             "datetime": forecast_time.isoformat(),
@@ -704,7 +746,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"]
@@ -722,7 +763,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:
@@ -815,7 +856,6 @@ class MeteocatConditionCoordinator(DataUpdateCoordinator):
         self,
         hass: HomeAssistant,
         entry_data: dict,
-        update_interval: timedelta = DEFAULT_CONDITION_SENSOR_UPDATE_INTERVAL,
     ):
         """
         Initialize the Meteocat Condition Coordinator.
@@ -832,7 +872,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(
@@ -842,6 +882,8 @@ class MeteocatConditionCoordinator(DataUpdateCoordinator):
 
     async def _async_update_data(self):
         """Read and process condition data for the current hour from the file asynchronously."""
+        _LOGGER.debug("Iniciando actualización de datos desde el archivo: %s", self._file_path)
+
         try:
             async with aiofiles.open(self._file_path, "r", encoding="utf-8") as file:
                 raw_data = await file.read()
@@ -889,6 +931,12 @@ class MeteocatConditionCoordinator(DataUpdateCoordinator):
                             "hour": current_hour,
                             "date": current_date,
                         })
+                        _LOGGER.debug(
+                            "Hora actual: %s, Código estatCel: %s, Condición procesada: %s",
+                            current_datetime,
+                            codi_estatcel,
+                            condition,
+                        )
                         return condition
                 break  # Sale del bucle una vez encontrada la fecha actual
 
@@ -900,3 +948,101 @@ class MeteocatConditionCoordinator(DataUpdateCoordinator):
         )
         return {"condition": "unknown", "hour": current_hour, "icon": None, "date": current_date}
 
+class MeteocatTempForecastCoordinator(DataUpdateCoordinator):
+    """Coordinator para manejar las predicciones diarias desde archivos locales."""
+
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        entry_data: dict,
+    ):
+        """Inicializa el coordinador para predicciones diarias."""
+        self.town_name = entry_data["town_name"]
+        self.town_id = entry_data["town_id"]
+        self.station_name = entry_data["station_name"]
+        self.station_id = entry_data["station_id"]
+        self.file_path = os.path.join(
+            hass.config.path(),
+            "custom_components",
+            "meteocat",
+            "files",
+            f"forecast_{self.town_id.lower()}_daily_data.json",
+        )
+        super().__init__(
+            hass,
+            _LOGGER,
+            name=f"{DOMAIN} Daily Forecast Coordinator",
+            update_interval=DEFAULT_TEMP_FORECAST_UPDATE_INTERVAL,
+        )
+
+    async def _is_data_valid(self) -> bool:
+        """Verifica si hay datos válidos y actuales en el archivo JSON."""
+        if not os.path.exists(self.file_path):
+            return False
+
+        try:
+            async with aiofiles.open(self.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
+
+            today = datetime.now(timezone.utc).date()
+            for dia in data["dies"]:
+                forecast_date = datetime.fromisoformat(dia["data"].rstrip("Z")).date()
+                if forecast_date >= today:
+                    return True
+
+            return False
+        except Exception as e:
+            _LOGGER.warning("Error validando datos diarios en %s: %s", self.file_path, e)
+            return False
+
+    async def _async_update_data(self) -> dict:
+        """Lee y filtra los datos de predicción diaria desde el archivo local."""
+        if await self._is_data_valid():
+            try:
+                async with aiofiles.open(self.file_path, "r", encoding="utf-8") as f:
+                    content = await f.read()
+                    data = json.loads(content)
+
+                # Filtrar días pasados
+                today = datetime.now(timezone.utc).date()
+                data["dies"] = [
+                    dia for dia in data["dies"]
+                    if datetime.fromisoformat(dia["data"].rstrip("Z")).date() >= today
+                ]
+
+                # 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_temp_forecast(today_temp_forecast)
+                    return parsed_data
+            except Exception as e:
+                _LOGGER.warning("Error leyendo archivo de predicción diaria: %s", e)
+
+        return {}
+
+    def get_temp_forecast_for_today(self, data: dict) -> dict | None:
+        """Obtiene los datos diarios para el día actual."""
+        if not data or "dies" not in data or not data["dies"]:
+            return None
+
+        today = datetime.now(timezone.utc).date()
+        for dia in data["dies"]:
+            forecast_date = datetime.fromisoformat(dia["data"].rstrip("Z")).date()
+            if forecast_date == today:
+                return dia
+        return None
+
+    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", {})
+
+        temp_forecast_data = {
+            "date": datetime.fromisoformat(dia["data"].rstrip("Z")).date(),
+            "max_temp_forecast": float(variables.get("tmax", {}).get("valor", 0.0)),
+            "min_temp_forecast": float(variables.get("tmin", {}).get("valor", 0.0)),
+        }
+        return temp_forecast_data

package/custom_components/meteocat/helpers.py

@@ -1,41 +1,51 @@
 from __future__ import annotations
 
 import logging
-from datetime import datetime, timedelta
-from homeassistant.core import HomeAssistant
-from homeassistant.util.dt import as_local, as_utc
-from homeassistant.helpers.sun import get_astral_event_next
+from datetime import datetime
+from homeassistant.util.dt import as_local, as_utc, start_of_local_day
+from homeassistant.helpers.sun import get_astral_event_date
 
 _LOGGER = logging.getLogger(__name__)
 
-def get_sun_times(hass: HomeAssistant, current_time: datetime | None = None):
-    """Get the sunrise and sunset times."""
-    # Usa la hora actual si no se proporciona una hora específica
+def get_sun_times(hass, current_time=None):
+    """Obtén las horas de amanecer y atardecer para el día actual."""
     if current_time is None:
         current_time = datetime.now()
 
-    # Asegúrate de que current_time es aware (UTC con offset)
+    # Asegúrate de que current_time es aware (UTC)
     current_time = as_utc(current_time)
+    today = start_of_local_day(as_local(current_time))
 
-    # Obtén los tiempos de amanecer y atardecer desde el helper
-    sunrise = get_astral_event_next(hass, "sunrise", utc_point_in_time=current_time)
-    sunset = get_astral_event_next(hass, "sunset", utc_point_in_time=current_time)
+    # Obtén los eventos de amanecer y atardecer del día actual
+    sunrise = get_astral_event_date(hass, "sunrise", today)
+    sunset = get_astral_event_date(hass, "sunset", today)
+
+    _LOGGER.debug(
+        "Sunrise: %s, Sunset: %s, Current Time: %s",
+        sunrise,
+        sunset,
+        as_local(current_time),
+    )
 
-    # Asegúrate de que no sean None y conviértelos a la zona horaria local
     if sunrise and sunset:
-        return as_local(sunrise), as_local(sunset)
+        return sunrise, sunset
 
-    # Lanza un error si no se pudieron determinar los eventos
-    raise ValueError("Sunrise or sunset data is unavailable.")
+    raise ValueError("No se pudieron determinar los datos de amanecer y atardecer.")
 
-def is_night(current_time: datetime, hass: HomeAssistant) -> bool:
-    """Determine if it is currently night based on sunrise and sunset times."""
-    # Convierte current_time a UTC si no tiene información de zona horaria
+def is_night(current_time, hass):
+    """Determina si actualmente es de noche."""
+    # Asegúrate de que current_time es aware (UTC)
     if current_time.tzinfo is None:
         current_time = as_utc(current_time)
 
-    # Obtén los tiempos de amanecer y atardecer
     sunrise, sunset = get_sun_times(hass, current_time)
 
-    # Compara las horas
+    _LOGGER.debug(
+        "Hora actual: %s, Amanecer: %s, Atardecer: %s",
+        as_local(current_time),
+        as_local(sunrise),
+        as_local(sunset),
+    )
+
+    # Es de noche si es antes del amanecer o después del atardecer
     return current_time < sunrise or current_time > sunset

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.40"
+    "requirements": ["meteocatpy==0.0.16", "packaging>=20.3", "wrapt>=1.14.0"],
+    "version": "0.1.42"
 }

package/custom_components/meteocat/sensor.py

@@ -46,6 +46,8 @@ from .const import (
     WIND_GUST,
     STATION_TIMESTAMP,
     CONDITION,
+    MAX_TEMPERATURE_FORECAST,
+    MIN_TEMPERATURE_FORECAST,
     WIND_SPEED_CODE,
     WIND_DIRECTION_CODE,
     TEMPERATURE_CODE,
@@ -65,6 +67,7 @@ from .coordinator import (
     MeteocatStaticSensorCoordinator,
     MeteocatUviFileCoordinator,
     MeteocatConditionCoordinator,
+    MeteocatTempForecastCoordinator,
 )
 
 _LOGGER = logging.getLogger(__name__)
@@ -209,7 +212,23 @@ SENSOR_TYPES: tuple[MeteocatSensorEntityDescription, ...] = (
         key=CONDITION,
         translation_key="condition",
         icon="mdi:weather-partly-cloudy",
-    )
+    ),
+     MeteocatSensorEntityDescription(
+        key=MAX_TEMPERATURE_FORECAST,
+        translation_key="max_temperature_forecast",
+        icon="mdi:thermometer-plus",
+        device_class=SensorDeviceClass.TEMPERATURE,
+        state_class=SensorStateClass.MEASUREMENT,
+        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
+    ),
+    MeteocatSensorEntityDescription(
+        key=MIN_TEMPERATURE_FORECAST,
+        translation_key="min_temperature_forecast",
+        icon="mdi:thermometer-minus",
+        device_class=SensorDeviceClass.TEMPERATURE,
+        state_class=SensorStateClass.MEASUREMENT,
+        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
+    ),
 )
 
 @callback
@@ -222,12 +241,13 @@ async def async_setup_entry(hass, entry, async_add_entities: AddEntitiesCallback
     uvi_file_coordinator = entry_data.get("uvi_file_coordinator")
     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")
 
     # 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}  # 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}  # Excluir estáticos y UVI
     )
 
     # Sensores estáticos
@@ -251,6 +271,13 @@ async def async_setup_entry(hass, entry, async_add_entities: AddEntitiesCallback
         if description.key == CONDITION  # Incluir CONDITION en el coordinador CONDITION COORDINATOR
     )
 
+    # Sensores temperatura previsión
+    async_add_entities(
+        MeteocatTempForecast(temp_forecast_coordinator, description, entry_data)
+        for description in SENSOR_TYPES
+        if description.key in {MAX_TEMPERATURE_FORECAST, MIN_TEMPERATURE_FORECAST}
+    )
+
 class MeteocatStaticSensor(CoordinatorEntity[MeteocatStaticSensorCoordinator], SensorEntity):
     """Representation of a static Meteocat sensor."""
     STATIC_KEYS = {TOWN_NAME, TOWN_ID, STATION_NAME, STATION_ID}
@@ -543,7 +570,7 @@ class MeteocatSensor(CoordinatorEntity[MeteocatSensorCoordinator], SensorEntity)
                         return value
                     
         # Lógica específica para el sensor de timestamp
-        if self.entity_description.key == "station_timestamp":
+        if self.entity_description.key == STATION_TIMESTAMP:
             stations = self.coordinator.data or []
             for station in stations:
                 variables = station.get("variables", [])
@@ -563,7 +590,7 @@ class MeteocatSensor(CoordinatorEntity[MeteocatSensorCoordinator], SensorEntity)
                                 return None
 
         # Nuevo sensor para la precipitación acumulada
-        if self.entity_description.key == "precipitation_accumulated":
+        if self.entity_description.key == PRECIPITATION_ACCUMULATED:
             stations = self.coordinator.data or []
             total_precipitation = 0.0  # Usa float para permitir acumulación de decimales
 
@@ -644,3 +671,50 @@ class MeteocatSensor(CoordinatorEntity[MeteocatSensorCoordinator], SensorEntity)
             manufacturer="Meteocat",
             model="Meteocat API",
         )
+
+class MeteocatTempForecast(CoordinatorEntity[MeteocatTempForecastCoordinator], SensorEntity):
+    """Representation of a Meteocat UV Index sensor."""
+
+    _attr_has_entity_name = True  # Activa el uso de nombres basados en el dispositivo
+
+    def __init__(self, temp_forecast_coordinator, description, entry_data):
+        """Initialize the UV Index sensor."""
+        super().__init__(temp_forecast_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._town_id}_{self.entity_description.key}"
+
+        # Asigna entity_category desde description (si está definido)
+        self._attr_entity_category = getattr(description, "entity_category", None)
+        
+        # Log para depuración
+        _LOGGER.debug(
+            "Inicializando sensor: %s, Unique ID: %s",
+            self.entity_description.name,
+            self._attr_unique_id,
+        )
+
+    @property
+    def native_value(self):
+        """Return the Max and Min Temp Forecast value."""
+        temp_forecast_data = self.coordinator.data or {}
+        
+        if self.entity_description.key == MAX_TEMPERATURE_FORECAST:
+            return temp_forecast_data.get("max_temp_forecast", None)
+        if self.entity_description.key == MIN_TEMPERATURE_FORECAST:
+            return temp_forecast_data.get("min_temp_forecast", None)
+        return None
+
+    @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

@@ -127,6 +127,12 @@
             "name": "Hour"
           }
         }
+      },
+      "max_temperature_forecast": {
+        "name": "Max Temperature Today"
+      },
+      "min_temperature_forecast": {
+        "name": "Min Temperature Today"
       }
     }
   }

package/custom_components/meteocat/translations/ca.json

@@ -127,7 +127,14 @@
             "name": "Hora"
           }
         }
+      },
+      "max_temperature_forecast": {
+        "name": "Temperatura Max Avui"
+      },
+      "min_temperature_forecast": {
+        "name": "Temperatura Min Avui"
       }
     }
   }
-}   
+}
+  

package/custom_components/meteocat/translations/en.json

@@ -127,8 +127,14 @@
             "name": "Hour"
           }
         }
+      },
+      "max_temperature_forecast": {
+        "name": "Max Temperature Today"
+      },
+      "min_temperature_forecast": {
+        "name": "Min Temperature Today"
       }
     }
   }
 }
-  
+ 

package/custom_components/meteocat/translations/es.json

@@ -127,6 +127,12 @@
             "name": "Hora"
           }
         }
+      },
+      "max_temperature_forecast": {
+        "name": "Temperatura Max Hoy"
+      },
+      "min_temperature_forecast": {
+        "name": "Temperatura Min Hoy"
       }
     }
   }

package/custom_components/meteocat/version.py

@@ -1,2 +1,2 @@
 # version.py
-__version__ = "0.1.40"
+__version__ = "0.1.42"

package/package.json

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