meteocat 2.1.0 → 2.2.3

package/custom_components/meteocat/options_flow.py

@@ -10,7 +10,10 @@ import voluptuous as vol
 from .const import (
     CONF_API_KEY,
     LIMIT_XEMA,
-    LIMIT_PREDICCIO
+    LIMIT_PREDICCIO,
+    LIMIT_XDDE,
+    LIMIT_QUOTA,
+    LIMIT_BASIC
 )
 from meteocatpy.town import MeteocatTown
 from meteocatpy.exceptions import (
@@ -64,6 +67,9 @@ class MeteocatOptionsFlowHandler(OptionsFlow):
             self.api_key = user_input.get(CONF_API_KEY)
             self.limit_xema = user_input.get(LIMIT_XEMA)
             self.limit_prediccio = user_input.get(LIMIT_PREDICCIO)
+            self.limit_xdde = user_input.get(LIMIT_XDDE)
+            self.limit_quota = user_input.get(LIMIT_QUOTA)
+            self.limit_basic = user_input.get(LIMIT_BASIC)
 
             # Validar la nueva API Key utilizando MeteocatTown
             if self.api_key:
@@ -84,7 +90,8 @@ class MeteocatOptionsFlowHandler(OptionsFlow):
                     errors["base"] = "unknown"
 
             # Validar que los límites sean números positivos
-            if not cv.positive_int(self.limit_xema) or not cv.positive_int(self.limit_prediccio):
+            limits_to_validate = [self.limit_xema, self.limit_prediccio, self.limit_xdde, self.limit_quota, self.limit_basic]
+            if not all(cv.positive_int(limit) for limit in limits_to_validate if limit is not None):
                 errors["base"] = "invalid_limit"
 
             if not errors:
@@ -96,6 +103,12 @@ class MeteocatOptionsFlowHandler(OptionsFlow):
                     data_update[LIMIT_XEMA] = self.limit_xema
                 if self.limit_prediccio:
                     data_update[LIMIT_PREDICCIO] = self.limit_prediccio
+                if self.limit_xdde:
+                    data_update[LIMIT_XDDE] = self.limit_xdde
+                if self.limit_quota:
+                    data_update[LIMIT_QUOTA] = self.limit_quota
+                if self.limit_basic:
+                    data_update[LIMIT_BASIC] = self.limit_basic
 
                 self.hass.config_entries.async_update_entry(
                     self._config_entry,
@@ -110,6 +123,9 @@ class MeteocatOptionsFlowHandler(OptionsFlow):
             vol.Required(CONF_API_KEY): str,
             vol.Required(LIMIT_XEMA, default=self._config_entry.data.get(LIMIT_XEMA)): cv.positive_int,
             vol.Required(LIMIT_PREDICCIO, default=self._config_entry.data.get(LIMIT_PREDICCIO)): cv.positive_int,
+            vol.Required(LIMIT_XDDE, default=self._config_entry.data.get(LIMIT_XDDE)): cv.positive_int,
+            vol.Required(LIMIT_QUOTA, default=self._config_entry.data.get(LIMIT_QUOTA)): cv.positive_int,
+            vol.Required(LIMIT_BASIC, default=self._config_entry.data.get(LIMIT_BASIC)): cv.positive_int,
         })
         return self.async_show_form(
             step_id="update_api_and_limits", data_schema=schema, errors=errors
@@ -122,9 +138,13 @@ class MeteocatOptionsFlowHandler(OptionsFlow):
         if user_input is not None:
             self.limit_xema = user_input.get(LIMIT_XEMA)
             self.limit_prediccio = user_input.get(LIMIT_PREDICCIO)
+            self.limit_xdde = user_input.get(LIMIT_XDDE)
+            self.limit_quota = user_input.get(LIMIT_QUOTA)
+            self.limit_basic = user_input.get(LIMIT_BASIC)
 
             # Validar que los límites sean números positivos
-            if not cv.positive_int(self.limit_xema) or not cv.positive_int(self.limit_prediccio):
+            limits_to_validate = [self.limit_xema, self.limit_prediccio, self.limit_xdde, self.limit_quota, self.limit_basic]
+            if not all(cv.positive_int(limit) for limit in limits_to_validate if limit is not None):
                 errors["base"] = "invalid_limit"
 
             if not errors:
@@ -133,7 +153,10 @@ class MeteocatOptionsFlowHandler(OptionsFlow):
                     data={
                         **self._config_entry.data,
                         LIMIT_XEMA: self.limit_xema,
-                        LIMIT_PREDICCIO: self.limit_prediccio
+                        LIMIT_PREDICCIO: self.limit_prediccio,
+                        LIMIT_XDDE: self.limit_xdde,
+                        LIMIT_QUOTA: self.limit_quota,
+                        LIMIT_BASIC: self.limit_basic
                     },
                 )
                 # Recargar la integración para aplicar los cambios dinámicamente
@@ -144,6 +167,9 @@ class MeteocatOptionsFlowHandler(OptionsFlow):
         schema = vol.Schema({
             vol.Required(LIMIT_XEMA, default=self._config_entry.data.get(LIMIT_XEMA)): cv.positive_int,
             vol.Required(LIMIT_PREDICCIO, default=self._config_entry.data.get(LIMIT_PREDICCIO)): cv.positive_int,
+            vol.Required(LIMIT_XDDE, default=self._config_entry.data.get(LIMIT_XDDE)): cv.positive_int,
+            vol.Required(LIMIT_QUOTA, default=self._config_entry.data.get(LIMIT_QUOTA)): cv.positive_int,
+            vol.Required(LIMIT_BASIC, default=self._config_entry.data.get(LIMIT_BASIC)): cv.positive_int,
         })
         return self.async_show_form(
             step_id="update_limits_only", data_schema=schema, errors=errors

package/custom_components/meteocat/sensor.py

@@ -39,6 +39,8 @@ from .const import (
     TOWN_ID,
     STATION_NAME,
     STATION_ID,
+    REGION_NAME,
+    REGION_ID,
     WIND_SPEED,
     WIND_DIRECTION,
     WIND_DIRECTION_CARDINAL,
@@ -60,6 +62,12 @@ from .const import (
     HOURLY_FORECAST_FILE_STATUS,
     DAILY_FORECAST_FILE_STATUS,
     UVI_FILE_STATUS,
+    QUOTA_FILE_STATUS,
+    QUOTA_XDDE,
+    QUOTA_PREDICCIO,
+    QUOTA_BASIC,
+    QUOTA_XEMA,
+    QUOTA_QUERIES,
     ALERTS,
     ALERT_FILE_STATUS,
     ALERT_WIND,
@@ -70,6 +78,9 @@ from .const import (
 	ALERT_WARM,
 	ALERT_WARM_NIGHT,
 	ALERT_SNOW,
+    LIGHTNING_FILE_STATUS,
+    LIGHTNING_REGION,
+    LIGHTNING_TOWN,
     WIND_SPEED_CODE,
     WIND_DIRECTION_CODE,
     TEMPERATURE_CODE,
@@ -86,6 +97,12 @@ from .const import (
     DEFAULT_VALIDITY_HOURS,
     DEFAULT_VALIDITY_MINUTES,
     DEFAULT_ALERT_VALIDITY_TIME,
+    DEFAULT_QUOTES_VALIDITY_TIME,
+    ALERT_VALIDITY_MULTIPLIER_100,
+    ALERT_VALIDITY_MULTIPLIER_200,
+    ALERT_VALIDITY_MULTIPLIER_500,
+    ALERT_VALIDITY_MULTIPLIER_DEFAULT,
+    DEFAULT_LIGHTNING_VALIDITY_TIME,
 )
 
 from .coordinator import (
@@ -99,6 +116,10 @@ from .coordinator import (
     MeteocatUviCoordinator,
     MeteocatAlertsCoordinator,
     MeteocatAlertsRegionCoordinator,
+    MeteocatQuotesCoordinator,
+    MeteocatQuotesFileCoordinator,
+    MeteocatLightningCoordinator,
+    MeteocatLightningFileCoordinator,
 )
 
 # Definir la zona horaria local
@@ -224,6 +245,16 @@ SENSOR_TYPES: tuple[MeteocatSensorEntityDescription, ...] = (
         state_class=SensorStateClass.MEASUREMENT,
         native_unit_of_measurement=UnitOfSpeed.KILOMETERS_PER_HOUR,
     ),
+    MeteocatSensorEntityDescription(
+        key=LIGHTNING_REGION,
+        translation_key="lightning_region",
+        icon="mdi:weather-lightning",
+    ),
+    MeteocatSensorEntityDescription(
+        key=LIGHTNING_TOWN,
+        translation_key="lightning_town",
+        icon="mdi:weather-lightning",
+    ),
     # Sensores estáticos
     MeteocatSensorEntityDescription(
         key=TOWN_NAME,
@@ -249,6 +280,18 @@ SENSOR_TYPES: tuple[MeteocatSensorEntityDescription, ...] = (
         icon="mdi:identifier",
         entity_category=EntityCategory.DIAGNOSTIC,
     ),
+    MeteocatSensorEntityDescription(
+        key=REGION_NAME,
+        translation_key="region_name",
+        icon="mdi:broadcast",
+        entity_category=EntityCategory.DIAGNOSTIC,
+    ),
+    MeteocatSensorEntityDescription(
+        key=REGION_ID,
+        translation_key="region_id",
+        icon="mdi:identifier",
+        entity_category=EntityCategory.DIAGNOSTIC,
+    ),
     MeteocatSensorEntityDescription(
         key=STATION_TIMESTAMP,
         translation_key="station_timestamp",
@@ -294,6 +337,18 @@ SENSOR_TYPES: tuple[MeteocatSensorEntityDescription, ...] = (
         icon="mdi:update",
         entity_category=EntityCategory.DIAGNOSTIC,
     ),
+    MeteocatSensorEntityDescription(
+        key=QUOTA_FILE_STATUS,
+        translation_key="quota_file_status",
+        icon="mdi:update",
+        entity_category=EntityCategory.DIAGNOSTIC,
+    ),
+    MeteocatSensorEntityDescription(
+        key=LIGHTNING_FILE_STATUS,
+        translation_key="lightning_file_status",
+        icon="mdi:update",
+        entity_category=EntityCategory.DIAGNOSTIC,
+    ),
     MeteocatSensorEntityDescription(
         key=ALERTS,
         translation_key="alerts",
@@ -344,6 +399,36 @@ SENSOR_TYPES: tuple[MeteocatSensorEntityDescription, ...] = (
         key=ALERT_SNOW,
         translation_key="alert_snow",
         icon="mdi:alert-outline",
+    ),
+    MeteocatSensorEntityDescription(
+        key=QUOTA_XDDE,
+        translation_key="quota_xdde",
+        icon="mdi:counter",
+        entity_category=EntityCategory.DIAGNOSTIC,
+    ),
+    MeteocatSensorEntityDescription(
+        key=QUOTA_PREDICCIO,
+        translation_key="quota_prediccio",
+        icon="mdi:counter",
+        entity_category=EntityCategory.DIAGNOSTIC,
+    ),
+    MeteocatSensorEntityDescription(
+        key=QUOTA_BASIC,
+        translation_key="quota_basic",
+        icon="mdi:counter",
+        entity_category=EntityCategory.DIAGNOSTIC,
+    ),
+    MeteocatSensorEntityDescription(
+        key=QUOTA_XEMA,
+        translation_key="quota_xema",
+        icon="mdi:counter",
+        entity_category=EntityCategory.DIAGNOSTIC,
+    ),
+    MeteocatSensorEntityDescription(
+        key=QUOTA_QUERIES,
+        translation_key="quota_queries",
+        icon="mdi:counter",
+        entity_category=EntityCategory.DIAGNOSTIC,
     )
 )
 
@@ -363,6 +448,10 @@ async def async_setup_entry(hass, entry, async_add_entities: AddEntitiesCallback
     uvi_coordinator = entry_data.get("uvi_coordinator")
     alerts_coordinator = entry_data.get("alerts_coordinator")
     alerts_region_coordinator = entry_data.get("alerts_region_coordinator")
+    quotes_coordinator = entry_data.get("quotes_coordinator")
+    quotes_file_coordinator = entry_data.get("quotes_file_coordinator")
+    lightning_coordinator = entry_data.get("lightning_coordinator")
+    lightning_file_coordinator = entry_data.get("lightning_file_coordinator")
 
     # Sensores generales
     async_add_entities(
@@ -375,7 +464,7 @@ async def async_setup_entry(hass, entry, async_add_entities: AddEntitiesCallback
     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}
+        if description.key in {TOWN_NAME, TOWN_ID, STATION_NAME, STATION_ID, REGION_NAME, REGION_ID}
     )
 
     # Sensor UVI
@@ -448,6 +537,34 @@ async def async_setup_entry(hass, entry, async_add_entities: AddEntitiesCallback
         if description.key in {ALERT_WIND, ALERT_RAIN_INTENSITY, ALERT_RAIN, ALERT_SEA, ALERT_COLD, ALERT_WARM, ALERT_WARM_NIGHT, ALERT_SNOW}
     )
 
+    # Sensores de estado de cuotas
+    async_add_entities(
+        MeteocatQuotaStatusSensor(quotes_coordinator, description, entry_data)
+        for description in SENSOR_TYPES
+        if description.key == QUOTA_FILE_STATUS
+    )
+
+    # Sensores cuotas
+    async_add_entities(
+        MeteocatQuotaSensor(quotes_file_coordinator, description, entry_data)
+        for description in SENSOR_TYPES
+        if description.key in {QUOTA_XDDE, QUOTA_PREDICCIO, QUOTA_BASIC, QUOTA_XEMA, QUOTA_QUERIES}
+    )
+
+    # Sensores de estado de rayos
+    async_add_entities(
+        MeteocatLightningStatusSensor(lightning_coordinator, description, entry_data)
+        for description in SENSOR_TYPES
+        if description.key == LIGHTNING_FILE_STATUS
+    )
+
+    # Sensores de rayos en comarca y municipio
+    async_add_entities(
+        MeteocatLightningSensor(lightning_file_coordinator, description, entry_data)
+        for description in SENSOR_TYPES
+        if description.key in {LIGHTNING_REGION, LIGHTNING_TOWN}
+    )
+
 # Cambiar UTC a la zona horaria local
 def convert_to_local_time(utc_time: str, local_tz: str = "Europe/Madrid") -> datetime | None:
     """
@@ -473,7 +590,7 @@ def convert_to_local_time(utc_time: str, local_tz: str = "Europe/Madrid") -> dat
 
 class MeteocatStaticSensor(CoordinatorEntity[MeteocatStaticSensorCoordinator], SensorEntity):
     """Representation of a static Meteocat sensor."""
-    STATIC_KEYS = {TOWN_NAME, TOWN_ID, STATION_NAME, STATION_ID}
+    STATIC_KEYS = {TOWN_NAME, TOWN_ID, STATION_NAME, STATION_ID, REGION_NAME, REGION_ID}
     
     _attr_has_entity_name = True  # Activa el uso de nombres basados en el dispositivo
 
@@ -485,6 +602,8 @@ class MeteocatStaticSensor(CoordinatorEntity[MeteocatStaticSensorCoordinator], S
         self._town_id = entry_data["town_id"]
         self._station_name = entry_data["station_name"]
         self._station_id = entry_data["station_id"]
+        self._region_name = entry_data["region_name"]
+        self._region_id = entry_data["region_id"]
 
         # Unique ID for the entity
         self._attr_unique_id = f"sensor.{DOMAIN}_{self._station_id}_{self.entity_description.key}"
@@ -513,6 +632,10 @@ class MeteocatStaticSensor(CoordinatorEntity[MeteocatStaticSensorCoordinator], S
                 return self._station_name
             if self.entity_description.key == STATION_ID:
                 return self._station_id
+            if self.entity_description.key == REGION_NAME:
+                return self._region_name
+            if self.entity_description.key == REGION_ID:
+                return self._region_id
     
     @property
     def device_info(self) -> DeviceInfo:
@@ -1136,6 +1259,7 @@ class MeteocatAlertStatusSensor(CoordinatorEntity[MeteocatAlertsCoordinator], Se
         self._town_id = entry_data["town_id"]
         self._station_id = entry_data["station_id"]
         self._region_id = entry_data["region_id"]
+        self._limit_prediccio = entry_data["limit_prediccio"]
 
         # Unique ID for the entity
         self._attr_unique_id = f"sensor.{DOMAIN}_{self._region_id}_alert_status"
@@ -1152,6 +1276,19 @@ class MeteocatAlertStatusSensor(CoordinatorEntity[MeteocatAlertsCoordinator], Se
             except ValueError:
                 _LOGGER.error("Formato de fecha de actualización inválido: %s", data_update)
         return None
+    
+    def _get_validity_duration(self):
+        """Calcula la duración de validez basada en el límite de predicción."""
+        if self._limit_prediccio <= 100:
+            multiplier = ALERT_VALIDITY_MULTIPLIER_100
+        elif 100 < self._limit_prediccio <= 200:
+            multiplier = ALERT_VALIDITY_MULTIPLIER_200
+        elif 200 < self._limit_prediccio <= 500:
+            multiplier = ALERT_VALIDITY_MULTIPLIER_500
+        else:
+            multiplier = ALERT_VALIDITY_MULTIPLIER_DEFAULT
+
+        return timedelta(minutes=DEFAULT_ALERT_VALIDITY_TIME * multiplier)
 
     @property
     def native_value(self):
@@ -1161,11 +1298,11 @@ class MeteocatAlertStatusSensor(CoordinatorEntity[MeteocatAlertsCoordinator], Se
             return "unknown"
 
         current_time = datetime.now(ZoneInfo("UTC"))
+        validity_duration = self._get_validity_duration()
 
         # Comprobar si el archivo de alertas está obsoleto
-        if current_time - data_update >= timedelta(hours=DEFAULT_ALERT_VALIDITY_TIME):
+        if current_time - data_update >= validity_duration:
             return "obsolete"
-
         return "updated"
 
     @property
@@ -1370,3 +1507,282 @@ class MeteocatAlertMeteorSensor(CoordinatorEntity[MeteocatAlertsRegionCoordinato
             manufacturer="Meteocat",
             model="Meteocat API",
         )
+
+class MeteocatQuotaStatusSensor(CoordinatorEntity[MeteocatQuotesCoordinator], SensorEntity):
+    _attr_has_entity_name = True  # Activa el uso de nombres basados en el dispositivo
+
+    def __init__(self, quotes_coordinator, description, entry_data):
+        super().__init__(quotes_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}_quota_status"
+
+        # Assign entity_category if defined in the description
+        self._attr_entity_category = getattr(description, "entity_category", None)
+
+    def _get_data_update(self):
+        """Obtiene la fecha de actualización directamente desde el coordinador."""
+        data_update = self.coordinator.data.get("actualizado")
+        if data_update:
+            try:
+                return datetime.fromisoformat(data_update.rstrip("Z"))
+            except ValueError:
+                _LOGGER.error("Formato de fecha de actualización inválido: %s", data_update)
+        return None
+
+    @property
+    def native_value(self):
+        """Devuelve el estado actual de las alertas basado en la fecha de actualización."""
+        data_update = self._get_data_update()
+        if not data_update:
+            return "unknown"
+
+        current_time = datetime.now(ZoneInfo("UTC"))
+
+        # Comprobar si el archivo de alertas está obsoleto
+        if current_time - data_update >= timedelta(minutes=DEFAULT_QUOTES_VALIDITY_TIME):
+            return "obsolete"
+
+        return "updated"
+
+    @property
+    def extra_state_attributes(self):
+        """Devuelve los atributos adicionales del estado."""
+        attributes = super().extra_state_attributes or {}
+        data_update = self._get_data_update()
+        if data_update:
+            attributes["update_date"] = data_update.isoformat()
+        return attributes
+
+    @property
+    def device_info(self) -> DeviceInfo:
+        """Devuelve la información del dispositivo."""
+        return DeviceInfo(
+            identifiers={(DOMAIN, self._town_id)},
+            name=f"Meteocat {self._station_id} {self._town_name}",
+            manufacturer="Meteocat",
+            model="Meteocat API",
+        )
+
+class MeteocatQuotaSensor(CoordinatorEntity[MeteocatQuotesFileCoordinator], SensorEntity):
+    """Representation of Meteocat Quota sensors."""
+
+    # Mapeo de claves en sensor.py a nombres en quotes.json
+    QUOTA_MAPPING = {
+        "quota_xdde": "XDDE",
+        "quota_prediccio": "Prediccio",
+        "quota_basic": "Basic",
+        "quota_xema": "XEMA",
+        "quota_queries": "Quota",
+    }
+
+    # Mapeo de periodos para facilitar la traducción del estado
+    PERIOD_STATE_MAPPING = {
+        "Setmanal": "weekly",
+        "Mensual": "monthly",
+        "Anual": "annual",
+    }
+
+    _attr_has_entity_name = True  # Activa el uso de nombres basados en el dispositivo
+
+    def __init__(self, quotes_file_coordinator, description, entry_data):
+        super().__init__(quotes_file_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}"
+
+        # Assign entity_category if defined in the description
+        self._attr_entity_category = getattr(description, "entity_category", None)
+    
+    def _get_plan_data(self):
+        """Encuentra los datos del plan correspondiente al sensor actual."""
+        if not self.coordinator.data:
+            return None
+
+        plan_name = self.QUOTA_MAPPING.get(self.entity_description.key)
+
+        if not plan_name:
+            _LOGGER.error(f"No se encontró un mapeo para la clave: {self.entity_description.key}")
+            return None
+
+        for plan in self.coordinator.data.get("plans", []):
+            if plan.get("nom") == plan_name:
+                return plan  # Retorna el plan encontrado
+
+        _LOGGER.warning(f"No se encontró el plan '{plan_name}' en los datos del coordinador.")
+        return None
+
+    @property
+    def native_value(self):
+        """Devuelve el estado de la cuota: 'ok' si no se ha excedido, 'exceeded' si se ha superado."""
+        plan = self._get_plan_data()
+
+        if not plan:
+            return None
+
+        max_consultes = plan.get("maxConsultes")
+        consultes_realitzades = plan.get("consultesRealitzades")
+
+        if max_consultes is None or consultes_realitzades is None or \
+            not isinstance(max_consultes, (int, float)) or not isinstance(consultes_realitzades, (int, float)):
+                _LOGGER.warning(f"Datos inválidos para el plan '{plan.get('nom', 'unknown')}': {plan}")
+                return None
+
+        return "ok" if consultes_realitzades <= max_consultes else "exceeded"
+
+    @property
+    def extra_state_attributes(self):
+        """Devuelve atributos adicionales del estado del sensor."""
+        attributes = super().extra_state_attributes or {}
+        plan = self._get_plan_data()
+
+        if not plan:
+            return {}
+        
+        # Aplicar el mapeo de periodos
+        period = plan.get("periode", "desconocido")
+        translated_period = self.PERIOD_STATE_MAPPING.get(period, period)  # Si no está en el mapping, dejar el original
+
+        attributes.update({
+            "period": translated_period,
+            "max_queries": plan.get("maxConsultes"),
+            "made_queries": plan.get("consultesRealitzades"),
+            "remain_queries": plan.get("consultesRestants"),
+        })
+
+        return attributes
+
+    @property
+    def device_info(self) -> DeviceInfo:
+        """Devuelve la información del dispositivo."""
+        return DeviceInfo(
+            identifiers={(DOMAIN, self._town_id)},
+            name=f"Meteocat {self._station_id} {self._town_name}",
+            manufacturer="Meteocat",
+            model="Meteocat API",
+        )
+
+class MeteocatLightningStatusSensor(CoordinatorEntity[MeteocatLightningCoordinator], SensorEntity):
+    _attr_has_entity_name = True  # Activa el uso de nombres basados en el dispositivo
+
+    def __init__(self, lightning_coordinator, description, entry_data):
+        super().__init__(lightning_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}_lightning_status"
+
+        # Assign entity_category if defined in the description
+        self._attr_entity_category = getattr(description, "entity_category", None)
+
+    def _get_data_update(self):
+        """Obtiene la fecha de actualización directamente desde el coordinador."""
+        data_update = self.coordinator.data.get("actualizado")
+        if data_update:
+            try:
+                return datetime.fromisoformat(data_update.rstrip("Z"))
+            except ValueError:
+                _LOGGER.error("Formato de fecha de actualización inválido: %s", data_update)
+        return None
+
+    @property
+    def native_value(self):
+        """Devuelve el estado actual de las alertas basado en la fecha de actualización."""
+        data_update = self._get_data_update()
+        if not data_update:
+            return "unknown"
+
+        current_time = datetime.now(ZoneInfo("UTC"))
+
+        # Comprobar si el archivo de alertas está obsoleto
+        if current_time - data_update >= timedelta(minutes=DEFAULT_LIGHTNING_VALIDITY_TIME):
+            return "obsolete"
+
+        return "updated"
+
+    @property
+    def extra_state_attributes(self):
+        """Devuelve los atributos adicionales del estado."""
+        attributes = super().extra_state_attributes or {}
+        data_update = self._get_data_update()
+        if data_update:
+            attributes["update_date"] = data_update.isoformat()
+        return attributes
+
+    @property
+    def device_info(self) -> DeviceInfo:
+        """Devuelve la información del dispositivo."""
+        return DeviceInfo(
+            identifiers={(DOMAIN, self._town_id)},
+            name=f"Meteocat {self._station_id} {self._town_name}",
+            manufacturer="Meteocat",
+            model="Meteocat API",
+        )
+
+class MeteocatLightningSensor(CoordinatorEntity[MeteocatLightningFileCoordinator], SensorEntity):
+    """Representation of Meteocat Lightning sensors."""
+
+    _attr_has_entity_name = True  # Activa el uso de nombres basados en el dispositivo
+
+    def __init__(self, lightning_file_coordinator, description, entry_data):
+        super().__init__(lightning_file_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"]
+        self._region_id = entry_data["region_id"]
+
+        # Unique ID for the entity
+        self._attr_unique_id = f"sensor.{DOMAIN}_{self._town_id}_{self.entity_description.key}"
+
+        # Assign entity_category if defined in the description
+        self._attr_entity_category = getattr(description, "entity_category", None)
+
+    @property
+    def native_value(self):
+        """Return the total number of lightning strikes."""
+        if self.entity_description.key == LIGHTNING_REGION:
+            return self.coordinator.data.get("region", {}).get("total", 0)
+        elif self.entity_description.key == LIGHTNING_TOWN:
+            return self.coordinator.data.get("town", {}).get("total", 0)
+        return None
+
+    @property
+    def extra_state_attributes(self):
+        """Return additional attributes for the sensor."""
+        attributes = super().extra_state_attributes or {}
+        if self.entity_description.key == LIGHTNING_REGION:
+            data = self.coordinator.data.get("region", {})
+        elif self.entity_description.key == LIGHTNING_TOWN:
+            data = self.coordinator.data.get("town", {})
+        else:
+            return attributes
+
+        # Agregar atributos específicos
+        attributes.update({
+            "cloud_cloud": data.get("cc", 0),
+            "cloud_ground_neg": data.get("cg-", 0),
+            "cloud_ground_pos": data.get("cg+", 0),
+        })
+        return attributes
+
+    @property
+    def device_info(self) -> DeviceInfo:
+        """Return the device info."""
+        return DeviceInfo(
+            identifiers={(DOMAIN, self._town_id)},
+            name=f"Meteocat {self._station_id} {self._town_name}",
+            manufacturer="Meteocat",
+            model="Meteocat API",
+        )