meteocat 0.1.39 → 0.1.40

package/CHANGELOG.md

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

@@ -24,7 +24,7 @@ from .const import DOMAIN, PLATFORMS
 _LOGGER = logging.getLogger(__name__)
 
 # Versión
-__version__ = "0.1.39"
+__version__ = "0.1.40"
 
 def safe_remove(path: Path, is_folder: bool = False):
     """Elimina de forma segura un archivo o carpeta si existe."""

package/custom_components/meteocat/coordinator.py

@@ -602,7 +602,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 +611,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 +638,63 @@ 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,
+        )
+        condition = get_condition_from_code(int(condition_code))
+
+        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):

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.40"
 }

package/custom_components/meteocat/version.py

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

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.40",
   "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.40"
 description = "Script para obtener datos meteorológicos de la API de Meteocat"
 authors = ["figorr <jdcuartero@yahoo.es>"]
 license = "Apache-2.0"