meteocat 2.2.2 → 2.2.4

package/CHANGELOG.md

@@ -1,3 +1,21 @@
+## [2.2.4](https://github.com/figorr/meteocat/compare/v2.2.3...v2.2.4) (2025-02-09)
+
+
+### Bug Fixes
+
+* 2.2.4 ([59183ea](https://github.com/figorr/meteocat/commit/59183ea082f6d963e46d3f8a51e0867b3f32060d))
+* fix valid lightning data for download from API ([4e4a8ae](https://github.com/figorr/meteocat/commit/4e4a8ae110b72b6e6ff560921f88ea7fb4640a29))
+
+## [2.2.3](https://github.com/figorr/meteocat/compare/v2.2.2...v2.2.3) (2025-02-08)
+
+
+### Bug Fixes
+
+* 2.2.3 ([ce224a0](https://github.com/figorr/meteocat/commit/ce224a097e7c879c46985ff3a16143de1b822006))
+* bump meteocatpy to 1.0.1 ([7119065](https://github.com/figorr/meteocat/commit/711906534fca5c61a9a3ab968a3572e70f05929e))
+* new lightning sensors ([8528f57](https://github.com/figorr/meteocat/commit/8528f57d688f7fc21f66715ffeac086895afd1aa))
+* update README ([10c86e5](https://github.com/figorr/meteocat/commit/10c86e5e373c661cf23524421c756374711d89fe))
+
 ## [2.2.2](https://github.com/figorr/meteocat/compare/v2.2.1...v2.2.2) (2025-02-04)
 
 

package/README.md

@@ -56,7 +56,7 @@ Once you pick the town you will be prompted to pick a station from the list. The
 
 ![Meteocat custom component station picker dialog](images/pick_station.png)
 
-Then you will be asked to set the XEMA and PREDICTIONS limits from the API.
+Then you will be asked to set the API limits from your plan.
 
 ![Meteocat custom component api limits setting dialog](images/api_limits.png)
 

package/custom_components/meteocat/__init__.py

@@ -24,6 +24,8 @@ from .coordinator import (
     MeteocatAlertsRegionCoordinator,
     MeteocatQuotesCoordinator,
     MeteocatQuotesFileCoordinator,
+    MeteocatLightningCoordinator,
+    MeteocatLightningFileCoordinator,
 )
 
 from .const import DOMAIN, PLATFORMS
@@ -31,7 +33,7 @@ from .const import DOMAIN, PLATFORMS
 _LOGGER = logging.getLogger(__name__)
 
 # Versión
-__version__ = "2.2.2"
+__version__ = "2.2.4"
 
 # Definir el esquema de configuración CONFIG_SCHEMA
 CONFIG_SCHEMA = vol.Schema(
@@ -137,6 +139,12 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
         quotes_file_coordinator = MeteocatQuotesFileCoordinator(hass=hass, entry_data=entry_data)
         await quotes_file_coordinator.async_config_entry_first_refresh()
 
+        lightning_coordinator = MeteocatLightningCoordinator(hass=hass, entry_data=entry_data)
+        await lightning_coordinator.async_config_entry_first_refresh()
+
+        lightning_file_coordinator = MeteocatLightningFileCoordinator(hass=hass, entry_data=entry_data)
+        await lightning_file_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
@@ -157,6 +165,8 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
         "alerts_region_coordinator": alerts_region_coordinator,
         "quotes_coordinator": quotes_coordinator,
         "quotes_file_coordinator": quotes_file_coordinator,
+        "lightning_coordinator": lightning_coordinator,
+        "lightning_file_coordinator": lightning_file_coordinator,
         **entry_data,
     }
 
@@ -223,9 +233,12 @@ async def async_remove_entry(hass: HomeAssistant, entry: ConfigEntry) -> None:
     alerts_file = files_folder / "alerts.json"
     alerts_region_file = files_folder / f"alerts_{region_id}.json"
 
-    # Archivos JSON de cuotas
+    # Archivo JSON de cuotas
     quotes_file = files_folder / f"quotes.json"
 
+    # Archivo JSON de rayos
+    lightning_file = files_folder / f"lightning_{region_id}.json"
+
     # Validar la ruta base
     if not custom_components_path.exists():
         _LOGGER.warning(f"La ruta {custom_components_path} no existe. No se realizará la limpieza.")
@@ -241,5 +254,6 @@ async def async_remove_entry(hass: HomeAssistant, entry: ConfigEntry) -> None:
     safe_remove(alerts_file)
     safe_remove(quotes_file)
     safe_remove(alerts_region_file)
+    safe_remove(lightning_file)
     safe_remove(assets_folder, is_folder=True)
     safe_remove(files_folder, is_folder=True)

package/custom_components/meteocat/config_flow.py

@@ -75,6 +75,7 @@ class MeteocatConfigFlow(ConfigFlow, domain=DOMAIN):
         self.variable_id: str | None = None
         self.station_id: str | None = None
         self.station_name: str | None = None
+        self.region_id: str | None = None
         self._cache = {}
 
     async def fetch_and_save_quotes(self, api_key):
@@ -159,6 +160,29 @@ class MeteocatConfigFlow(ConfigFlow, domain=DOMAIN):
                 await file.write(json.dumps(initial_data, ensure_ascii=False, indent=4))
             
             _LOGGER.info("Archivo alerts.json creado en %s", alerts_file)
+    
+    async def create_lightning_file(self):
+        """Crea el archivo lightning_{self.region_id}.json si no existe."""
+        lightning_dir = os.path.join(
+            self.hass.config.path(),
+            "custom_components",
+            "meteocat",
+            "files"
+        )
+        os.makedirs(lightning_dir, exist_ok=True)
+        lightning_file = os.path.join(lightning_dir, f"lightning_{self.region_id}.json")
+
+        if not os.path.exists(lightning_file):
+            initial_data = {
+                "actualitzat": {
+                    "dataUpdate": "1970-01-01T00:00:00+00:00"
+                },
+                "dades": []
+            }
+            async with aiofiles.open(lightning_file, "w", encoding="utf-8") as file:
+                await file.write(json.dumps(initial_data, ensure_ascii=False, indent=4))
+            
+            _LOGGER.info("Archivo %s creado", lightning_file)
 
     async def async_step_user(
         self, user_input: dict[str, Any] | None = None
@@ -307,6 +331,10 @@ class MeteocatConfigFlow(ConfigFlow, domain=DOMAIN):
                     self.province_id = station_metadata.get("provincia", {}).get("codi", "")
                     self.province_name = station_metadata.get("provincia", {}).get("nom", "")
                     self.station_status = station_metadata.get("estats", [{}])[0].get("codi", "")
+
+                    # Crear el archivo lightning después de obtener region_id
+                    await self.create_lightning_file()
+                    
                     return await self.async_step_set_api_limits()
                 except Exception as ex:
                     _LOGGER.error("Error al obtener los metadatos de la estación: %s", ex)

package/custom_components/meteocat/const.py

@@ -41,6 +41,7 @@ QUOTA_PREDICCIO = "quota_prediccio"
 QUOTA_BASIC = "quota_basic"
 QUOTA_XEMA = "quota_xema"
 QUOTA_QUERIES = "quota_queries"
+LIGHTNING_FILE_STATUS = "lightning_file_status"
 
 from homeassistant.const import Platform
 
@@ -54,6 +55,9 @@ DEFAULT_VALIDITY_HOURS = 5  # Hora a partir de la cual la API tiene la informaci
 DEFAULT_VALIDITY_MINUTES = 0  # Minutos a partir de los cuales la API tiene la información actualizada de predicciones disponible para descarga
 DEFAULT_ALERT_VALIDITY_TIME = 120  # Minutos a partir de los cuales las alertas están obsoletas y se se debe proceder a una nueva llamada a la API
 DEFAULT_QUOTES_VALIDITY_TIME = 240 # Minutos a partir de los cuales los datos de cuotas están obsoletos y se se debe proceder a una nueva llamada a la API
+DEFAULT_LIGHTNING_VALIDITY_TIME = 240 # Minutos a partir de los cuales los datos de rayos están obsoletos y se se debe proceder a una nueva llamada a la API
+DEFAULT_LIGHTNING_VALIDITY_HOURS = 2  # Hora a partir de la cual la API tiene la información actualizada de rayos disponible para descarga
+DEFAULT_LIGHTNING_VALIDITY_MINUTES = 0  # Minutos a partir de los cuales la API tiene la información actualizada de rayos disponible para descarga
 
 # Multiplicadores para la duración de validez basada en limit_prediccio
 ALERT_VALIDITY_MULTIPLIER_100 = 12  # para limit_prediccio <= 100
@@ -81,6 +85,8 @@ 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
+LIGHTNING_REGION = "lightning_region"  # Rayos de la comarca
+LIGHTNING_TOWN = "lightning_town"  # Rayos de la población
 
 # Definición de códigos para variables
 WIND_SPEED_CODE = 30

package/custom_components/meteocat/coordinator.py

@@ -20,6 +20,7 @@ from meteocatpy.uvi import MeteocatUviData
 from meteocatpy.forecast import MeteocatForecast
 from meteocatpy.alerts import MeteocatAlerts
 from meteocatpy.quotes import MeteocatQuotes
+from meteocatpy.lightning import MeteocatLightning
 
 from meteocatpy.exceptions import (
     BadRequestError,
@@ -41,7 +42,10 @@ from .const import (
     ALERT_VALIDITY_MULTIPLIER_100,
     ALERT_VALIDITY_MULTIPLIER_200,
     ALERT_VALIDITY_MULTIPLIER_500,
-    ALERT_VALIDITY_MULTIPLIER_DEFAULT
+    ALERT_VALIDITY_MULTIPLIER_DEFAULT,
+    DEFAULT_LIGHTNING_VALIDITY_TIME,
+    DEFAULT_LIGHTNING_VALIDITY_HOURS,
+    DEFAULT_LIGHTNING_VALIDITY_MINUTES
 )
 
 _LOGGER = logging.getLogger(__name__)
@@ -60,6 +64,8 @@ DEFAULT_ALERTS_UPDATE_INTERVAL = timedelta(minutes=10)
 DEFAULT_ALERTS_REGION_UPDATE_INTERVAL = timedelta(minutes=5)
 DEFAULT_QUOTES_UPDATE_INTERVAL = timedelta(minutes=10)
 DEFAULT_QUOTES_FILE_UPDATE_INTERVAL = timedelta(minutes=5)
+DEFAULT_LIGHTNING_UPDATE_INTERVAL = timedelta(minutes=10)
+DEFAULT_LIGHTNING_FILE_UPDATE_INTERVAL = timedelta(minutes=5)
 
 # Definir la zona horaria local
 TIMEZONE = ZoneInfo("Europe/Madrid")
@@ -278,6 +284,8 @@ class MeteocatStaticSensorCoordinator(DataUpdateCoordinator):
         self.town_id = entry_data["town_id"]  # ID del municipio
         self.station_name = entry_data["station_name"]  # Nombre de la estación
         self.station_id = entry_data["station_id"]  # ID de la estación
+        self.region_name = entry_data["region_name"]  # Nombre de la región
+        self.region_id = entry_data["region_id"]  # ID de la región
 
         super().__init__(
             hass,
@@ -293,17 +301,21 @@ class MeteocatStaticSensorCoordinator(DataUpdateCoordinator):
         Since static sensors use entry_data, this method simply logs the process.
         """
         _LOGGER.debug(
-            "Updating static sensor data for town: %s (ID: %s), station: %s (ID: %s)",
+            "Updating static sensor data for town: %s (ID: %s), station: %s (ID: %s), region: %s (ID: %s)",
             self.town_name,
             self.town_id,
             self.station_name,
             self.station_id,
+            self.region_name,
+            self.region_id,
         )
         return {
             "town_name": self.town_name,
             "town_id": self.town_id,
             "station_name": self.station_name,
             "station_id": self.station_id,
+            "region_name": self.region_name,
+            "region_id": self.region_id,
         }
 
 class MeteocatUviCoordinator(DataUpdateCoordinator):
@@ -1721,6 +1733,11 @@ class MeteocatQuotesCoordinator(DataUpdateCoordinator):
                 normalized_nom = normalize_name(plan["nom"])
                 new_name = next((v for k, v in plan_mapping.items() if normalized_nom.startswith(k)), plan["nom"])
 
+                # Si el plan es "Quota", actualizamos las consultas realizadas y restantes
+                if new_name == "Quota":
+                    plan["consultesRealitzades"] += 1
+                    plan["consultesRestants"] = max(0, plan["consultesRestants"] - 1)
+
                 modified_plans.append({
                     "nom": new_name,
                     "periode": plan["periode"],
@@ -1853,3 +1870,209 @@ class MeteocatQuotesFileCoordinator(DataUpdateCoordinator):
                 }
         _LOGGER.warning("Plan %s no encontrado en quotes.json.", plan_name)
         return {}
+
+class MeteocatLightningCoordinator(DataUpdateCoordinator):
+    """Coordinator para manejar la actualización de los datos de rayos de la API de Meteocat."""
+
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        entry_data: dict,
+    ):
+        """
+        Inicializa el coordinador de rayos de Meteocat.
+        
+        Args:
+            hass (HomeAssistant): Instancia de Home Assistant.
+            entry_data (dict): Datos de configuración obtenidos de core.config_entries.
+        """
+        self.api_key = entry_data["api_key"]  # API Key de la configuración
+        self.region_id = entry_data["region_id"]  # Región de la configuración
+        self.meteocat_lightning = MeteocatLightning(self.api_key)
+
+        self.lightning_file = os.path.join(
+            hass.config.path(),
+            "custom_components",
+            "meteocat",
+            "files",
+            f"lightning_{self.region_id}.json",
+        )
+
+        super().__init__(
+            hass,
+            _LOGGER,
+            name=f"{DOMAIN} Lightning Coordinator",
+            update_interval=DEFAULT_LIGHTNING_UPDATE_INTERVAL,
+        )
+
+    async def _async_update_data(self) -> Dict:
+        """Actualiza los datos de rayos desde la API de Meteocat o usa datos en caché según la antigüedad."""
+        existing_data = await load_json_from_file(self.lightning_file) or {}
+
+        # Definir la duración de validez de los datos
+        current_time = datetime.now(timezone.utc).time()
+        validity_start_time = time(DEFAULT_LIGHTNING_VALIDITY_HOURS, DEFAULT_LIGHTNING_VALIDITY_MINUTES)
+        validity_duration = timedelta(minutes=DEFAULT_LIGHTNING_VALIDITY_TIME)
+
+        if not existing_data:
+            return await self._fetch_and_save_new_data()
+        else:
+            last_update = datetime.fromisoformat(existing_data['actualitzat']['dataUpdate'])
+            now = datetime.now(timezone.utc).astimezone(TIMEZONE)
+            
+            if now - last_update >= validity_duration and current_time >= validity_start_time:
+                return await self._fetch_and_save_new_data()
+            else:
+                _LOGGER.debug("Usando datos existentes de rayos: %s", existing_data)
+                return {"actualizado": existing_data['actualitzat']['dataUpdate']}
+
+    async def _fetch_and_save_new_data(self):
+        """Obtiene nuevos datos de la API y los guarda en el archivo JSON."""
+        try:
+            data = await asyncio.wait_for(
+                self.meteocat_lightning.get_lightning_data(self.region_id),
+                timeout=30  # Tiempo límite de 30 segundos
+            )
+            _LOGGER.debug("Datos de rayos actualizados exitosamente: %s", data)
+
+            # Verificar que `data` sea una lista (como la API de Meteocat devuelve)
+            if not isinstance(data, list):
+                _LOGGER.error("Formato inválido: Se esperaba una lista, pero se obtuvo %s", type(data).__name__)
+                raise ValueError("Formato de datos inválido")
+
+            # Estructurar los datos en el formato correcto
+            current_time = datetime.now(timezone.utc).astimezone(TIMEZONE).isoformat()
+            data_with_timestamp = {
+                "actualitzat": {
+                    "dataUpdate": current_time
+                },
+                "dades": data  # Siempre será una lista
+            }
+
+            # Guardar los datos en un archivo JSON
+            await save_json_to_file(data_with_timestamp, self.lightning_file)
+
+            # Actualizar cuotas usando la función externa
+            await _update_quotes(self.hass, "XDDE")  # Asegúrate de usar el nombre correcto del plan aquí
+
+            return {"actualizado": data_with_timestamp['actualitzat']['dataUpdate']}
+
+        except asyncio.TimeoutError as err:
+            _LOGGER.warning("Tiempo de espera agotado al obtener los datos de rayos de la API de Meteocat.")
+            raise ConfigEntryNotReady from err
+        except Exception as err:
+            _LOGGER.exception("Error inesperado al obtener los datos de rayos de la API de Meteocat: %s", err)
+
+        # Intentar cargar datos en caché si la API falla
+        cached_data = await load_json_from_file(self.lightning_file)
+        if cached_data:
+            _LOGGER.warning("Usando datos en caché para los datos de rayos de la API de Meteocat.")
+            return cached_data
+
+        _LOGGER.error("No se pudo obtener datos actualizados ni cargar datos en caché.")
+        return None
+
+class MeteocatLightningFileCoordinator(DataUpdateCoordinator):
+    """Coordinator para manejar la actualización de los datos de rayos desde lightning_{region_id}.json."""
+
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        entry_data: dict,
+    ):
+        """
+        Inicializa el coordinador de rayos desde archivo.
+
+        Args:
+            hass (HomeAssistant): Instancia de Home Assistant.
+            entry_data (dict): Datos de configuración de la entrada.
+        """
+        self.region_id = entry_data["region_id"]
+        self.town_id = entry_data["town_id"]
+
+        self.lightning_file = os.path.join(
+            hass.config.path(),
+            "custom_components",
+            "meteocat",
+            "files",
+            f"lightning_{self.region_id}.json",
+        )
+
+        super().__init__(
+            hass,
+            _LOGGER,
+            name="Meteocat Lightning File Coordinator",
+            update_interval=DEFAULT_LIGHTNING_FILE_UPDATE_INTERVAL,
+        )
+
+    async def _async_update_data(self) -> Dict[str, Any]:
+        """Carga los datos de rayos desde el archivo JSON y procesa la información."""
+        existing_data = await load_json_from_file(self.lightning_file)
+
+        if not existing_data:
+            _LOGGER.warning("No se encontraron datos en %s.", self.lightning_file)
+            return {
+                "actualizado": datetime.now(ZoneInfo("Europe/Madrid")).isoformat(),
+                "region": self._reset_data(),
+                "town": self._reset_data()
+            }
+
+        # Convertir la cadena de fecha a un objeto datetime y ajustar a la zona horaria local
+        update_date = datetime.fromisoformat(existing_data.get("actualitzat", {}).get("dataUpdate", ""))
+        update_date = update_date.astimezone(ZoneInfo("Europe/Madrid"))
+        now = datetime.now(ZoneInfo("Europe/Madrid"))
+
+        if update_date.date() != now.date():  # Si la fecha no es la de hoy
+            _LOGGER.info("Los datos de rayos son de un día diferente. Reiniciando valores a cero.")
+            region_data = town_data = self._reset_data()
+            update_date = datetime.now(ZoneInfo("Europe/Madrid")).isoformat()  # Usar la fecha actual
+        else:
+            region_data = self._process_region_data(existing_data.get("dades", []))
+            town_data = self._process_town_data(existing_data.get("dades", []))
+
+        return {
+            "actualizado": update_date,
+            "region": region_data,
+            "town": town_data
+        }
+
+    def _process_region_data(self, data_list):
+        """Suma los tipos de descargas para toda la región."""
+        region_counts = {
+            "cc": 0, 
+            "cg-": 0, 
+            "cg+": 0
+        }
+        for town in data_list:
+            for discharge in town.get("descarregues", []):
+                if discharge["tipus"] in region_counts:
+                    region_counts[discharge["tipus"]] += discharge["recompte"]
+        
+        region_counts["total"] = sum(region_counts.values())
+        return region_counts
+
+    def _process_town_data(self, data_list):
+        """Encuentra y suma los tipos de descargas para un municipio específico."""
+        town_counts = {
+            "cc": 0, 
+            "cg-": 0, 
+            "cg+": 0
+        }
+        for town in data_list:
+            if town["codi"] == self.town_id:
+                for discharge in town.get("descarregues", []):
+                    if discharge["tipus"] in town_counts:
+                        town_counts[discharge["tipus"]] += discharge["recompte"]
+                break  # Solo necesitamos datos de un municipio
+        
+        town_counts["total"] = sum(town_counts.values())
+        return town_counts
+
+    def _reset_data(self):
+        """Resetea los datos a cero."""
+        return {
+            "cc": 0,
+            "cg-": 0,
+            "cg+": 0,
+            "total": 0
+        }

package/custom_components/meteocat/manifest.json

@@ -8,6 +8,6 @@
     "iot_class": "cloud_polling",
     "issue_tracker": "https://github.com/figorr/meteocat/issues",
     "loggers": ["meteocatpy"],
-    "requirements": ["meteocatpy==1.0.0", "packaging>=20.3", "wrapt>=1.14.0"],
-    "version": "2.2.2"
+    "requirements": ["meteocatpy==1.0.1", "packaging>=20.3", "wrapt>=1.14.0"],
+    "version": "2.2.4"
 }