meteocat 0.1.38 → 0.1.39

package/custom_components/meteocat/helpers.py

@@ -1,42 +1,41 @@
 from __future__ import annotations
 
-from datetime import datetime, time
-from homeassistant.helpers import entity_registry
-
-def get_sun_times(hass) -> tuple:
-    """
-    Obtiene las horas de amanecer y atardecer desde la integración sun.
-
-    :param hass: Instancia de Home Assistant.
-    :return: Tupla con las horas de amanecer y atardecer (datetime).
-    """
-    sun_entity = hass.states.get("sun.sun")
-    if sun_entity:
-        sunrise = sun_entity.attributes.get("next_rising")
-        sunset = sun_entity.attributes.get("next_setting")
-        if sunrise and sunset:
-            return (
-                hass.util.dt.as_local(hass.util.dt.parse_datetime(sunrise)),
-                hass.util.dt.as_local(hass.util.dt.parse_datetime(sunset)),
-            )
-    raise ValueError("No se pudo obtener las horas de amanecer y atardecer de sun.sun")
-
-
-def is_night(current_time: datetime, hass) -> bool:
-    """
-    Determina si la hora actual está fuera del rango entre el amanecer y el atardecer.
-
-    :param current_time: Hora actual como objeto datetime.
-    :param hass: Instancia de Home Assistant.
-    :return: True si es de noche, False si es de día.
-    """
-    # Obtener las horas de amanecer y atardecer de la integración sun
-    sunrise, sunset = get_sun_times(hass)
-
-    # Convertimos a objetos time para comparar solo las horas
-    current_time_only = current_time.time()
-    sunrise_time_only = sunrise.time()
-    sunset_time_only = sunset.time()
-
-    # Devuelve True si la hora está fuera del rango del día
-    return current_time_only < sunrise_time_only or current_time_only > sunset_time_only
+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
+
+_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
+    if current_time is None:
+        current_time = datetime.now()
+
+    # Asegúrate de que current_time es aware (UTC con offset)
+    current_time = as_utc(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)
+
+    # 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)
+
+    # Lanza un error si no se pudieron determinar los eventos
+    raise ValueError("Sunrise or sunset data is unavailable.")
+
+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
+    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
+    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.38"
+    "version": "0.1.39"
 }

package/custom_components/meteocat/sensor.py

@@ -45,6 +45,7 @@ from .const import (
     MIN_TEMPERATURE,
     WIND_GUST,
     STATION_TIMESTAMP,
+    CONDITION,
     WIND_SPEED_CODE,
     WIND_DIRECTION_CODE,
     TEMPERATURE_CODE,
@@ -61,7 +62,9 @@ from .const import (
 
 from .coordinator import (
     MeteocatSensorCoordinator,
+    MeteocatStaticSensorCoordinator,
     MeteocatUviFileCoordinator,
+    MeteocatConditionCoordinator,
 )
 
 _LOGGER = logging.getLogger(__name__)
@@ -137,7 +140,7 @@ SENSOR_TYPES: tuple[MeteocatSensorEntityDescription, ...] = (
     MeteocatSensorEntityDescription(
         key=UV_INDEX,
         translation_key="uv_index",
-        icon="mdi:weather-sunny",
+        icon="mdi:weather-sunny-alert",
     ),
     MeteocatSensorEntityDescription(
         key=MAX_TEMPERATURE,
@@ -197,10 +200,15 @@ SENSOR_TYPES: tuple[MeteocatSensorEntityDescription, ...] = (
         entity_category=EntityCategory.DIAGNOSTIC,
     ),
     MeteocatSensorEntityDescription(
-    key=STATION_TIMESTAMP,
-    translation_key="station_timestamp",
-    icon="mdi:calendar-clock",
-    device_class=SensorDeviceClass.TIMESTAMP,
+        key=STATION_TIMESTAMP,
+        translation_key="station_timestamp",
+        icon="mdi:calendar-clock",
+        device_class=SensorDeviceClass.TIMESTAMP,
+    ),
+    MeteocatSensorEntityDescription(
+        key=CONDITION,
+        translation_key="condition",
+        icon="mdi:weather-partly-cloudy",
     )
 )
 
@@ -212,12 +220,21 @@ async def async_setup_entry(hass, entry, async_add_entities: AddEntitiesCallback
     # Coordinadores para sensores
     coordinator = entry_data.get("sensor_coordinator")
     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")
 
     # Sensores generales
     async_add_entities(
         MeteocatSensor(coordinator, description, entry_data)
         for description in SENSOR_TYPES
-        if description.key != UV_INDEX  # Excluir UVI del coordinador general
+        if description.key not in {TOWN_NAME, TOWN_ID, STATION_NAME, STATION_ID, UV_INDEX, CONDITION}  # Excluir estáticos y UVI
+    )
+
+    # Sensores estáticos
+    async_add_entities(
+        MeteocatStaticSensor(static_sensor_coordinator, description, entry_data)
+        for description in SENSOR_TYPES
+        if description.key in {TOWN_NAME, TOWN_ID, STATION_NAME, STATION_ID}
     )
 
     # Sensor UVI
@@ -227,6 +244,66 @@ async def async_setup_entry(hass, entry, async_add_entities: AddEntitiesCallback
         if description.key == UV_INDEX  # Incluir UVI en el coordinador UVI FILE COORDINATOR
     )
 
+    # Sensor CONDITION para estado del cielo
+    async_add_entities(
+        MeteocatConditionSensor(condition_coordinator, description, entry_data)
+        for description in SENSOR_TYPES
+        if description.key == CONDITION  # Incluir CONDITION en el coordinador CONDITION COORDINATOR
+    )
+
+class MeteocatStaticSensor(CoordinatorEntity[MeteocatStaticSensorCoordinator], SensorEntity):
+    """Representation of a static Meteocat sensor."""
+    STATIC_KEYS = {TOWN_NAME, TOWN_ID, STATION_NAME, STATION_ID}
+    
+    _attr_has_entity_name = True  # Activa el uso de nombres basados en el dispositivo
+
+    def __init__(self, static_sensor_coordinator, description, entry_data):
+        """Initialize the static sensor."""
+        super().__init__(static_sensor_coordinator)
+        self.entity_description = description
+        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"]
+
+        # Unique ID for the entity
+        self._attr_unique_id = f"sensor.{DOMAIN}_{self._station_id}_{self.entity_description.key}"
+
+        # Assign entity_category if defined in the description
+        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 state of the sensor."""
+        # Información estática
+        if self.entity_description.key in self.STATIC_KEYS:
+            # Información estática del `entry_data`
+            if self.entity_description.key == TOWN_NAME:
+                return self._town_name
+            if self.entity_description.key == TOWN_ID:
+                return self._town_id
+            if self.entity_description.key == STATION_NAME:
+                return self._station_name
+            if self.entity_description.key == STATION_ID:
+                return self._station_id
+    
+    @property
+    def device_info(self) -> DeviceInfo:
+        """Return the device info."""
+        return DeviceInfo(
+            identifiers={(DOMAIN, self._town_id)},
+            name="Meteocat " + self._station_id + " " + self._town_name,
+            manufacturer="Meteocat",
+            model="Meteocat API",
+        )
+
 class MeteocatUviSensor(CoordinatorEntity[MeteocatUviFileCoordinator], SensorEntity):
     """Representation of a Meteocat UV Index sensor."""
 
@@ -280,9 +357,61 @@ class MeteocatUviSensor(CoordinatorEntity[MeteocatUviFileCoordinator], SensorEnt
             model="Meteocat API",
         )
 
+class MeteocatConditionSensor(CoordinatorEntity[MeteocatConditionCoordinator], 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, condition_coordinator, description, entry_data):
+        """Initialize the UV Index sensor."""
+        super().__init__(condition_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 current UV index value."""
+        if self.entity_description.key == CONDITION:
+            condition_data = self.coordinator.data or {}
+            return condition_data.get("condition", None)
+    
+    @property
+    def extra_state_attributes(self):
+        """Return additional attributes for the sensor."""
+        attributes = super().extra_state_attributes or {}
+        if self.entity_description.key == CONDITION:
+            condition_data = self.coordinator.data or {}
+            # Add the "hour" attribute if it exists
+            attributes["hour"] = condition_data.get("hour", None)
+        return attributes
+    
+    @property
+    def device_info(self) -> DeviceInfo:
+        """Return the device info."""
+        return DeviceInfo(
+            identifiers={(DOMAIN, self._town_id)},
+            name="Meteocat " + self._station_id + " " + self._town_name,
+            manufacturer="Meteocat",
+            model="Meteocat API",
+        )
+
 class MeteocatSensor(CoordinatorEntity[MeteocatSensorCoordinator], SensorEntity):
     """Representation of a Meteocat sensor."""
-    STATIC_KEYS = {TOWN_NAME, TOWN_ID, STATION_NAME, STATION_ID}
 
     CODE_MAPPING = {
         WIND_SPEED: WIND_SPEED_CODE,
@@ -326,19 +455,7 @@ class MeteocatSensor(CoordinatorEntity[MeteocatSensorCoordinator], SensorEntity)
     @property
     def native_value(self):
         """Return the state of the sensor."""
-        # Información estática
-        if self.entity_description.key in self.STATIC_KEYS:
-            # Información estática del `entry_data`
-            if self.entity_description.key == TOWN_NAME:
-                return self._town_name
-            if self.entity_description.key == TOWN_ID:
-                return self._town_id
-            if self.entity_description.key == STATION_NAME:
-                return self._station_name
-            if self.entity_description.key == STATION_ID:
-                return self._station_id
         # Información dinámica
-
         if self.entity_description.key == FEELS_LIKE:
             stations = self.coordinator.data or []
 

package/custom_components/meteocat/strings.json

@@ -107,6 +107,26 @@
       },
       "station_timestamp": {
         "name": "Station Timestamp"
+      },
+      "condition": {
+        "name": "Condition",
+        "state": {
+          "sunny": "Sunny",
+          "clear-night": "Clear Night",
+          "partlycloudy": "Partly Cloudy",
+          "cloudy": "Cloudy",
+          "rainy": "Rainy",
+          "pouring": "Pouring",
+          "lightning-rainy": "Lightning Rainy",
+          "hail": "Hail",
+          "snowy": "Snowy",
+          "snow-rainy": "Snow Rainy"
+        },
+        "state_attributes": {
+          "hour": {
+            "name": "Hour"
+          }
+        }
       }
     }
   }

package/custom_components/meteocat/translations/ca.json

@@ -107,6 +107,26 @@
       },
       "station_timestamp": {
         "name": "Estació Timestamp"
+      },
+      "condition": {
+        "name": "Estat del Cel",
+        "state": {
+          "sunny": "Assolellat",
+          "clear-night": "Nit Clara",
+          "partlycloudy": "Parcialment ennuvolat",
+          "cloudy": "Ennuvolat",
+          "rainy": "Plovent",
+          "pouring": "Tormenta",
+          "lightning-rainy": "Tormenta amb Llamps",
+          "hail": "Calamarsa",
+          "snowy": "Nevant",
+          "snow-rainy": "Neu amb Pluja"
+        },
+        "state_attributes": {
+          "hour": {
+            "name": "Hora"
+          }
+        }
       }
     }
   }

package/custom_components/meteocat/translations/en.json

@@ -107,6 +107,26 @@
       },
       "station_timestamp": {
         "name": "Station Timestamp"
+      },
+      "condition": {
+        "name": "Condition",
+        "state": {
+          "sunny": "Sunny",
+          "clear-night": "Clear Night",
+          "partlycloudy": "Partly Cloudy",
+          "cloudy": "Cloudy",
+          "rainy": "Rainy",
+          "pouring": "Pouring",
+          "lightning-rainy": "Lightning Rainy",
+          "hail": "Hail",
+          "snowy": "Snowy",
+          "snow-rainy": "Snow Rainy"
+        },
+        "state_attributes": {
+          "hour": {
+            "name": "Hour"
+          }
+        }
       }
     }
   }

package/custom_components/meteocat/translations/es.json

@@ -107,6 +107,26 @@
       },
       "station_timestamp": {
         "name": "Estación Timestamp"
+      },
+      "condition": {
+        "name": "Estado del cielo",
+        "state": {
+          "sunny": "Soleado",
+          "clear-night": "Noche Despejada",
+          "partlycloudy": "Parcialmente Nublado",
+          "cloudy": "Nublado",
+          "rainy": "Lluvioso",
+          "pouring": "Tormenta",
+          "lightning-rainy": "Tormenta con Rayos",
+          "hail": "Granizo",
+          "snowy": "Nevando",
+          "snow-rainy": "Nieve con Lluvia"
+        },
+        "state_attributes": {
+          "hour": {
+            "name": "Hora"
+          }
+        }
       }
     }
   }

package/custom_components/meteocat/version.py

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

package/custom_components/meteocat/weather.py

@@ -0,0 +1,171 @@
+from __future__ import annotations
+
+import logging
+from datetime import datetime
+from typing import Optional
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
+from homeassistant.components.weather import (
+    WeatherEntity,
+    WeatherEntityFeature,
+    Forecast,
+)
+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,
+)
+
+from .const import (
+    DOMAIN,
+    ATTRIBUTION,
+)
+from .coordinator import (
+    HourlyForecastCoordinator,
+    DailyForecastCoordinator,
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+@callback
+async def async_setup_entry(hass, entry, async_add_entities: AddEntitiesCallback) -> None:
+    """Set up Meteocat weather entity from a config entry."""
+    entry_data = hass.data[DOMAIN][entry.entry_id]
+
+    hourly_forecast_coordinator = entry_data.get("hourly_forecast_coordinator")
+    daily_forecast_coordinator = entry_data.get("daily_forecast_coordinator")
+
+    async_add_entities([
+        MeteocatWeatherEntity(hourly_forecast_coordinator, daily_forecast_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_pressure_unit = UnitOfPressure.HPA
+    _attr_native_temperature_unit = UnitOfTemperature.CELSIUS
+    _attr_native_wind_speed_unit = UnitOfSpeed.KILOMETERS_PER_HOUR
+    _attr_native_wind_bearing_unit = DEGREE
+    _attr_supported_features = (
+        WeatherEntityFeature.FORECAST_HOURLY | WeatherEntityFeature.FORECAST_DAILY
+    )
+
+    def __init__(
+        self,
+        hourly_forecast_coordinator: HourlyForecastCoordinator,
+        daily_forecast_coordinator: DailyForecastCoordinator,
+        entry_data: dict,
+    ) -> None:
+        """Initialize the weather entity."""
+        super().__init__(hourly_forecast_coordinator)
+        self._hourly_forecast_coordinator = hourly_forecast_coordinator
+        self._daily_forecast_coordinator = daily_forecast_coordinator
+        self._town_name = entry_data["town_name"]
+        self._town_id = entry_data["town_id"]
+        self._station_id = entry_data["station_id"]
+
+    @property
+    def name(self) -> str:
+        """Return the name of the entity."""
+        return f"Weather {self._town_name}"
+
+    @property
+    def unique_id(self) -> str:
+        """Return the unique ID of the entity."""
+        return f"weather.{DOMAIN}_{self._station_id}"
+
+    @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")
+        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
+
+    @property
+    def forecast(self) -> list[Forecast]:
+        """Return the daily forecast."""
+        daily_forecasts = self._daily_forecast_coordinator.get_all_daily_forecasts()
+        return [
+            Forecast(
+                datetime=forecast["date"],
+                temperature=forecast["temperature_max"],
+                templow=forecast["temperature_min"],
+                precipitation=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()
+        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"],
+                precipitation=forecast["precipitation"],
+                condition=forecast["condition"],
+            )
+            for forecast in daily_forecasts
+        ]
+
+    async def async_update(self) -> None:
+        """Update the weather entity."""
+        await self._hourly_forecast_coordinator.async_request_refresh()
+        await self._daily_forecast_coordinator.async_request_refresh()
+
+    @property
+    def device_info(self) -> DeviceInfo:
+        """Return the device info."""
+        return DeviceInfo(
+            identifiers={(DOMAIN, self._town_id)},
+            name=f"Meteocat {self._station_id}",
+            manufacturer="Meteocat",
+            model="Meteocat API",
+        )

package/filetree.txt

@@ -10,6 +10,7 @@
 ├── CHANGELOG.md
 ├── LICENSE
 ├── README.md
+├── conftest.py
 └── custom_components/
     └── meteocat/
         ├── __init__.py
@@ -17,7 +18,6 @@
         ├── config_flow.py
         ├── const.py
         ├── coordinator.py
-        ├── entity.py
         ├── helpers.py
         ├── manifest.json
         ├── options_flow.py
@@ -28,6 +28,7 @@
             ├── en.json
             ├── es.json
         ├── version.py
+        ├── weather.py
 ├── filetree.py
 ├── filetree.txt
 ├── hacs.json

package/package.json

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