meteocat 0.1.39 → 0.1.41

package/CHANGELOG.md

@@ -1,3 +1,25 @@
+## [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)
+
+
+### Bug Fixes
+
+* 0.1.40 ([011f139](https://github.com/figorr/meteocat/commit/011f1391874a78d16c1ad1eebbd8f84e6b053b5b))
+* fix hourly forecasts ([bc1aa17](https://github.com/figorr/meteocat/commit/bc1aa178222a7158590b32af442427def4187e38))
+
 ## [0.1.39](https://github.com/figorr/meteocat/compare/v0.1.38...v0.1.39) (2024-12-25)
 
 

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.39"
+__version__ = "0.1.41"
 
 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."""
@@ -291,9 +292,9 @@ 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"):
+             # 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:
                 return None
 
             return data
@@ -489,7 +490,10 @@ class MeteocatEntityCoordinator(DataUpdateCoordinator):
 
             # 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()
+
+            # Verificar si la antigüedad es mayor a un día
+            return (today - first_date).days <= 1
         except Exception as e:
             _LOGGER.warning("Error validando datos en %s: %s", file_path, e)
             return False
@@ -602,7 +606,7 @@ class HourlyForecastCoordinator(DataUpdateCoordinator):
         )
 
     async def _is_data_valid(self) -> bool:
-        """Verifica si los datos en el archivo JSON son válidos y actuales."""
+        """Verifica si los datos horarios en el archivo JSON son válidos y actuales."""
         if not os.path.exists(self.file_path):
             return False
 
@@ -611,18 +615,23 @@ class HourlyForecastCoordinator(DataUpdateCoordinator):
                 content = await f.read()
                 data = json.loads(content)
 
-            if not data or "dies" not in data or not data["dies"]:
+            if not data or "dies" not in data:
                 return False
 
-            # Validar que los datos sean para la fecha actual
-            first_date = datetime.fromisoformat(data["dies"][0]["data"].rstrip("Z")).date()
-            return first_date == datetime.now(timezone.utc).date()
+            now = datetime.now(timezone.utc)
+            for dia in data["dies"]:
+                for forecast in dia.get("variables", {}).get("estatCel", {}).get("valors", []):
+                    forecast_time = datetime.fromisoformat(forecast["data"].rstrip("Z")).replace(tzinfo=timezone.utc)
+                    if forecast_time >= now:
+                        return True
+
+            return False
         except Exception as e:
             _LOGGER.warning("Error validando datos horarios en %s: %s", self.file_path, e)
             return False
 
     async def _async_update_data(self) -> dict:
-        """Lee los datos de predicción horaria desde el archivo local."""
+        """Lee los datos horarios desde el archivo local."""
         if await self._is_data_valid():
             try:
                 async with aiofiles.open(self.file_path, "r", encoding="utf-8") as f:
@@ -633,41 +642,71 @@ class HourlyForecastCoordinator(DataUpdateCoordinator):
 
         return {}
 
-    async def async_forecast_hourly(self) -> list[Forecast] | None:
-        """Devuelve una lista de objetos Forecast para las próximas horas."""
+    def parse_hourly_forecast(self, dia: dict, forecast_time: datetime) -> dict:
+        """Convierte una hora de predicción en un diccionario con los datos necesarios."""
+        variables = dia.get("variables", {})
+        condition_code = next(
+            (item["valor"] for item in variables.get("estatCel", {}).get("valors", []) if
+             datetime.fromisoformat(item["data"].rstrip("Z")).replace(tzinfo=timezone.utc) == forecast_time),
+            -1,
+        )
+        
+        # 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(),
+            "temperature": self._get_variable_value(dia, "temp", forecast_time),
+            "precipitation": self._get_variable_value(dia, "precipitacio", forecast_time),
+            "condition": condition,
+            "wind_speed": self._get_variable_value(dia, "velVent", forecast_time),
+            "wind_bearing": self._get_variable_value(dia, "dirVent", forecast_time),
+            "humidity": self._get_variable_value(dia, "humitat", forecast_time),
+        }
+
+    def get_all_hourly_forecasts(self) -> list[dict]:
+        """Obtiene una lista de predicciones horarias procesadas."""
         if not self.data or "dies" not in self.data:
-            return None
+            return []
 
         forecasts = []
         now = datetime.now(timezone.utc)
-
         for dia in self.data["dies"]:
             for forecast in dia.get("variables", {}).get("estatCel", {}).get("valors", []):
                 forecast_time = datetime.fromisoformat(forecast["data"].rstrip("Z")).replace(tzinfo=timezone.utc)
                 if forecast_time >= now:
-                    # Usar la función para obtener la condición meteorológica
-                    condition = get_condition_from_code(int(forecast["valor"]))
-
-                    forecast_data = {
-                        "datetime": forecast_time,
-                        "temperature": self._get_variable_value(dia, "temp", forecast_time),
-                        "precipitation": self._get_variable_value(dia, "precipitacio", forecast_time),
-                        "condition": condition,  # Se usa la condición traducida
-                        "wind_speed": self._get_variable_value(dia, "velVent", forecast_time),
-                        "wind_bearing": self._get_variable_value(dia, "dirVent", forecast_time),
-                        "humidity": self._get_variable_value(dia, "humitat", forecast_time),
-                    }
-                    forecasts.append(Forecast(**forecast_data))
-
-        return forecasts if forecasts else None
+                    forecasts.append(self.parse_hourly_forecast(dia, forecast_time))
+        return forecasts
 
     def _get_variable_value(self, dia, variable_name, target_time):
         """Devuelve el valor de una variable específica para una hora determinada."""
         variable = dia.get("variables", {}).get(variable_name, {})
-        for valor in variable.get("valors", []):
-            data_hora = datetime.fromisoformat(valor["data"].rstrip("Z"))
-            if data_hora == target_time:
-                return valor["valor"]
+        if not variable:
+            _LOGGER.warning("Variable '%s' no encontrada en los datos.", variable_name)
+            return None
+
+        # Obtener lista de valores, soportando tanto 'valors' como 'valor'
+        valores = variable.get("valors") or variable.get("valor")
+        if not valores:
+            _LOGGER.warning("No se encontraron valores para la variable '%s'.", variable_name)
+            return None
+
+        for valor in valores:
+            try:
+                data_hora = datetime.fromisoformat(valor["data"].rstrip("Z")).replace(tzinfo=timezone.utc)
+                if data_hora == target_time:
+                    return float(valor["valor"])
+            except (KeyError, ValueError) as e:
+                _LOGGER.warning("Error procesando '%s' para %s: %s", variable_name, valor, e)
+                continue
+
+        _LOGGER.info("No se encontró un valor válido para '%s' en %s.", variable_name, target_time)
         return None
     
 class DailyForecastCoordinator(DataUpdateCoordinator):
@@ -815,6 +854,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()
@@ -862,6 +903,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
 
@@ -873,3 +920,102 @@ 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,
+        update_interval: timedelta = DEFAULT_TEMP_FORECAST_UPDATE_INTERVAL,
+    ):
+        """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=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_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_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

@@ -8,5 +8,5 @@
     "documentation": "https://gitlab.com/figorr/meteocat",
     "loggers": ["meteocatpy"],
     "requirements": ["meteocatpy==0.0.15", "packaging>=20.3", "wrapt>=1.14.0"],
-    "version": "0.1.39"
+    "version": "0.1.41"
 }

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.39"
+__version__ = "0.1.41"

package/custom_components/meteocat/weather.py

@@ -11,13 +11,11 @@ from homeassistant.components.weather import (
 )
 from homeassistant.core import callback
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
-from homeassistant.components.weather import Forecast
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.const import (
     DEGREE,
     PERCENTAGE,
     UnitOfPrecipitationDepth,
-    UnitOfVolumetricFlux,
     UnitOfPressure,
     UnitOfSpeed,
     UnitOfTemperature,
@@ -26,10 +24,20 @@ from homeassistant.const import (
 from .const import (
     DOMAIN,
     ATTRIBUTION,
+    WIND_SPEED_CODE,
+    WIND_DIRECTION_CODE,
+    TEMPERATURE_CODE,
+    HUMIDITY_CODE,
+    PRESSURE_CODE,
+    PRECIPITATION_CODE,
+    WIND_GUST_CODE,
 )
 from .coordinator import (
     HourlyForecastCoordinator,
     DailyForecastCoordinator,
+    MeteocatSensorCoordinator,
+    MeteocatUviFileCoordinator,
+    MeteocatConditionCoordinator,
 )
 
 _LOGGER = logging.getLogger(__name__)
@@ -41,16 +49,28 @@ async def async_setup_entry(hass, entry, async_add_entities: AddEntitiesCallback
 
     hourly_forecast_coordinator = entry_data.get("hourly_forecast_coordinator")
     daily_forecast_coordinator = entry_data.get("daily_forecast_coordinator")
+    sensor_coordinator = entry_data.get("sensor_coordinator")
+    uvi_file_coordinator = entry_data.get("uvi_file_coordinator")
+    condition_coordinator = entry_data.get("condition_coordinator")
 
     async_add_entities([
-        MeteocatWeatherEntity(hourly_forecast_coordinator, daily_forecast_coordinator, entry_data)
+        MeteocatWeatherEntity(
+            hourly_forecast_coordinator,
+            daily_forecast_coordinator,
+            sensor_coordinator,
+            uvi_file_coordinator,
+            condition_coordinator,
+            entry_data
+        )
     ])
 
 class MeteocatWeatherEntity(CoordinatorEntity, WeatherEntity):
     """Representation of a Meteocat Weather Entity."""
+
     _attr_attribution = ATTRIBUTION
     _attr_has_entity_name = True
     _attr_native_precipitation_unit = UnitOfPrecipitationDepth.MILLIMETERS
+    _attr_native_precipitation_probability_unit = PERCENTAGE
     _attr_native_pressure_unit = UnitOfPressure.HPA
     _attr_native_temperature_unit = UnitOfTemperature.CELSIUS
     _attr_native_wind_speed_unit = UnitOfSpeed.KILOMETERS_PER_HOUR
@@ -63,12 +83,18 @@ class MeteocatWeatherEntity(CoordinatorEntity, WeatherEntity):
         self,
         hourly_forecast_coordinator: HourlyForecastCoordinator,
         daily_forecast_coordinator: DailyForecastCoordinator,
+        sensor_coordinator: MeteocatSensorCoordinator,
+        uvi_file_coordinator: MeteocatUviFileCoordinator,
+        condition_coordinator: MeteocatConditionCoordinator,
         entry_data: dict,
     ) -> None:
         """Initialize the weather entity."""
-        super().__init__(hourly_forecast_coordinator)
+        super().__init__(daily_forecast_coordinator)
         self._hourly_forecast_coordinator = hourly_forecast_coordinator
         self._daily_forecast_coordinator = daily_forecast_coordinator
+        self._sensor_coordinator = sensor_coordinator
+        self._uvi_file_coordinator = uvi_file_coordinator
+        self._condition_coordinator = condition_coordinator
         self._town_name = entry_data["town_name"]
         self._town_id = entry_data["town_id"]
         self._station_id = entry_data["station_id"]
@@ -86,73 +112,90 @@ class MeteocatWeatherEntity(CoordinatorEntity, WeatherEntity):
     @property
     def condition(self) -> Optional[str]:
         """Return the current weather condition."""
-        forecast_today = self._daily_forecast_coordinator.get_forecast_for_today()
-        if forecast_today:
-            return forecast_today.get("condition")
+        condition_data = self._condition_coordinator.data or {}
+        return condition_data.get("condition")
+
+    def _get_latest_sensor_value(self, code: str) -> Optional[float]:
+        """Helper method to retrieve the latest sensor value."""
+        sensor_code = code
+        if not sensor_code:
+            return None
+
+        stations = self._sensor_coordinator.data or []
+        for station in stations:
+            variables = station.get("variables", [])
+            variable_data = next(
+                (var for var in variables if var.get("codi") == sensor_code),
+                None,
+            )
+            if variable_data:
+                lectures = variable_data.get("lectures", [])
+                if lectures:
+                    return lectures[-1].get("valor")
         return None
 
     @property
-    def temperature(self) -> Optional[float]:
-        """Return the current temperature."""
-        forecast_today = self._daily_forecast_coordinator.get_forecast_for_today()
-        if forecast_today:
-            return (forecast_today.get("temperature_max") + forecast_today.get("temperature_min")) / 2
-        return None
+    def native_temperature(self) -> Optional[float]:
+        return self._get_latest_sensor_value(TEMPERATURE_CODE)
+
+    @property
+    def humidity(self) -> Optional[float]:
+        return self._get_latest_sensor_value(HUMIDITY_CODE)
+
+    @property
+    def native_pressure(self) -> Optional[float]:
+        return self._get_latest_sensor_value(PRESSURE_CODE)
 
     @property
-    def forecast(self) -> list[Forecast]:
+    def native_wind_speed(self) -> Optional[float]:
+        return self._get_latest_sensor_value(WIND_SPEED_CODE)
+
+    @property
+    def native_wind_gust_speed(self) -> Optional[float]:
+        return self._get_latest_sensor_value(WIND_GUST_CODE)
+
+    @property
+    def uv_index(self) -> Optional[float]:
+        """Return the UV index."""
+        uvi_data = self._uvi_file_coordinator.data or {}
+        return uvi_data.get("uvi")
+
+    async def async_forecast_daily(self) -> list[Forecast] | None:
         """Return the daily forecast."""
+        await self._daily_forecast_coordinator.async_request_refresh()
         daily_forecasts = self._daily_forecast_coordinator.get_all_daily_forecasts()
+        if not daily_forecasts:
+            return None
+
         return [
             Forecast(
                 datetime=forecast["date"],
                 temperature=forecast["temperature_max"],
                 templow=forecast["temperature_min"],
-                precipitation=forecast["precipitation"],
+                precipitation_probability=forecast["precipitation"],
                 condition=forecast["condition"],
             )
             for forecast in daily_forecasts
         ]
-
+    
     async def async_forecast_hourly(self) -> list[Forecast] | None:
         """Return the hourly forecast."""
-        hourly_forecasts = await self._hourly_forecast_coordinator.async_forecast_hourly()
+        await self._hourly_forecast_coordinator.async_request_refresh()
+        hourly_forecasts = self._hourly_forecast_coordinator.get_all_hourly_forecasts()
         if not hourly_forecasts:
             return None
 
         return [
             Forecast(
-                datetime=forecast.datetime,
-                temperature=forecast.temperature,
-                precipitation=forecast.precipitation,
-                condition=forecast.condition,
-                wind_speed=forecast.wind_speed,
-                wind_bearing=forecast.wind_bearing,
-                humidity=forecast.humidity,
-            )
-            for forecast in hourly_forecasts
-        ]
-    
-    async def async_forecast_daily(self) -> list[Forecast] | None:
-        """Return the daily forecast."""
-        # Asegúrate de que los datos estén actualizados antes de procesarlos
-        await self._daily_forecast_coordinator.async_request_refresh()
-
-        # Obtén las predicciones diarias procesadas desde el coordinador
-        daily_forecasts = self._daily_forecast_coordinator.get_all_daily_forecasts()
-        if not daily_forecasts:
-            return None
-
-        # Convierte las predicciones a la estructura Forecast de Home Assistant
-        return [
-            Forecast(
-                datetime=forecast["date"],
-                temperature=forecast["temperature_max"],
-                templow=forecast["temperature_min"],
+                datetime=forecast["datetime"],
+                temperature=forecast["temperature"],
                 precipitation=forecast["precipitation"],
                 condition=forecast["condition"],
+                wind_speed=forecast["wind_speed"],
+                wind_bearing=forecast["wind_bearing"],
+                humidity=forecast["humidity"],
             )
-            for forecast in daily_forecasts
+            for forecast in hourly_forecasts
         ]
 
     async def async_update(self) -> None:

package/package.json

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