meteocat 2.1.0 → 2.2.3

package/CHANGELOG.md

@@ -1,3 +1,21 @@
+## [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)
+
+
+### Bug Fixes
+
+* 2.2.2 ([3667e5d](https://github.com/figorr/meteocat/commit/3667e5d65069ee0079ebbaebeab6c929be8b9630))
+* fix version 2.2.1 ([359cc7f](https://github.com/figorr/meteocat/commit/359cc7f7a9f1f025890bedc5177785016e9968d1))
+
 # [2.1.0](https://github.com/figorr/meteocat/compare/v2.0.3...v2.1.0) (2025-01-27)
 
 

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

@@ -22,6 +22,10 @@ from .coordinator import (
     MeteocatTempForecastCoordinator,
     MeteocatAlertsCoordinator,
     MeteocatAlertsRegionCoordinator,
+    MeteocatQuotesCoordinator,
+    MeteocatQuotesFileCoordinator,
+    MeteocatLightningCoordinator,
+    MeteocatLightningFileCoordinator,
 )
 
 from .const import DOMAIN, PLATFORMS
@@ -29,7 +33,7 @@ from .const import DOMAIN, PLATFORMS
 _LOGGER = logging.getLogger(__name__)
 
 # Versión
-__version__ = "2.1.0"
+__version__ = "2.2.3"
 
 # Definir el esquema de configuración CONFIG_SCHEMA
 CONFIG_SCHEMA = vol.Schema(
@@ -129,6 +133,18 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
         alerts_region_coordinator = MeteocatAlertsRegionCoordinator(hass=hass, entry_data=entry_data)
         await alerts_region_coordinator.async_config_entry_first_refresh()
 
+        quotes_coordinator = MeteocatQuotesCoordinator(hass=hass, entry_data=entry_data)
+        await quotes_coordinator.async_config_entry_first_refresh()
+
+        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
@@ -147,6 +163,10 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
         "temp_forecast_coordinator": temp_forecast_coordinator,
         "alerts_coordinator": alerts_coordinator,
         "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,
     }
 
@@ -213,6 +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"
 
+    # 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.")
@@ -226,6 +252,8 @@ async def async_remove_entry(hass: HomeAssistant, entry: ConfigEntry) -> None:
     safe_remove(forecast_hourly_data_file)
     safe_remove(forecast_daily_data_file)
     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

@@ -1,14 +1,18 @@
 from __future__ import annotations
 
 import os
+import asyncio
 import json
 import logging
 from pathlib import Path
 from typing import Any
+from datetime import datetime, timezone
+from zoneinfo import ZoneInfo
 
 import voluptuous as vol
 from aiohttp import ClientError
 import aiofiles
+import unicodedata
 
 from homeassistant.config_entries import ConfigEntry, ConfigFlow, ConfigFlowResult
 from homeassistant.core import callback
@@ -34,7 +38,10 @@ from .const import (
     PROVINCE_NAME,
     STATION_STATUS,
     LIMIT_XEMA,
-	LIMIT_PREDICCIO
+	LIMIT_PREDICCIO,
+    LIMIT_XDDE,
+    LIMIT_BASIC,
+    LIMIT_QUOTA
 )
     
 from .options_flow import MeteocatOptionsFlowHandler
@@ -43,11 +50,19 @@ from meteocatpy.symbols import MeteocatSymbols
 from meteocatpy.variables import MeteocatVariables
 from meteocatpy.townstations import MeteocatTownStations
 from meteocatpy.infostation import MeteocatInfoStation
+from meteocatpy.quotes import MeteocatQuotes
 
 from meteocatpy.exceptions import BadRequestError, ForbiddenError, TooManyRequestsError, InternalServerError, UnknownAPIError
 
 _LOGGER = logging.getLogger(__name__)
 
+TIMEZONE = ZoneInfo("Europe/Madrid")
+
+def normalize_name(name):
+    """Normaliza el nombre eliminando acentos y convirtiendo a minúsculas."""
+    name = unicodedata.normalize("NFKD", name).encode("ASCII", "ignore").decode("utf-8")
+    return name.lower()
+
 class MeteocatConfigFlow(ConfigFlow, domain=DOMAIN):
     """Flujo de configuración para Meteocat."""
 
@@ -60,8 +75,115 @@ 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):
+        """Obtiene las cuotas de la API de Meteocat y las guarda en quotes.json."""
+        meteocat_quotes = MeteocatQuotes(api_key)
+        quotes_dir = os.path.join(
+            self.hass.config.path(),
+            "custom_components",
+            "meteocat",
+            "files"
+        )
+        os.makedirs(quotes_dir, exist_ok=True)
+        quotes_file = os.path.join(quotes_dir, "quotes.json")
+
+        try:
+            data = await asyncio.wait_for(
+                meteocat_quotes.get_quotes(),
+                timeout=30
+            )
+            
+            # Modificar los nombres de los planes con normalización
+            plan_mapping = {
+                "xdde_": "XDDE",
+                "prediccio_": "Prediccio",
+                "referencia basic": "Basic",
+                "xema_": "XEMA",
+                "quota": "Quota"
+            }
+
+            modified_plans = []
+            for plan in data["plans"]:
+                normalized_nom = normalize_name(plan["nom"])
+                new_name = next((v for k, v in plan_mapping.items() if normalized_nom.startswith(k)), plan["nom"])
+
+                modified_plans.append({
+                    "nom": new_name,
+                    "periode": plan["periode"],
+                    "maxConsultes": plan["maxConsultes"],
+                    "consultesRestants": plan["consultesRestants"],
+                    "consultesRealitzades": plan["consultesRealitzades"]
+                })
+
+            # Añadir la clave 'actualitzat' con la fecha y hora actual de la zona horaria local
+            current_time = datetime.now(timezone.utc).astimezone(TIMEZONE).isoformat()
+            data_with_timestamp = {
+                "actualitzat": {
+                    "dataUpdate": current_time
+                },
+                "client": data["client"],
+                "plans": modified_plans
+            }
+
+            # Guardar los datos en el archivo JSON
+            async with aiofiles.open(quotes_file, "w", encoding="utf-8") as file:
+                await file.write(json.dumps(data_with_timestamp, ensure_ascii=False, indent=4))
+            
+            _LOGGER.info("Cuotas guardadas exitosamente en %s", quotes_file)
+
+        except Exception as ex:
+            _LOGGER.error("Error al obtener o guardar las cuotas: %s", ex)
+            raise HomeAssistantError("No se pudieron obtener las cuotas de la API")
+    
+    async def create_alerts_file(self):
+        """Crea el archivo alerts.json si no existe."""
+        alerts_dir = os.path.join(
+            self.hass.config.path(),
+            "custom_components",
+            "meteocat",
+            "files"
+        )
+        os.makedirs(alerts_dir, exist_ok=True)
+        alerts_file = os.path.join(alerts_dir, "alerts.json")
+
+        if not os.path.exists(alerts_file):
+            initial_data = {
+                "actualitzat": {
+                    "dataUpdate": "1970-01-01T00:00:00+00:00"
+                },
+                "dades": []
+            }
+            async with aiofiles.open(alerts_file, "w", encoding="utf-8") as file:
+                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
     ) -> ConfigFlowResult:
@@ -75,6 +197,10 @@ class MeteocatConfigFlow(ConfigFlow, domain=DOMAIN):
 
             try:
                 self.municipis = await town_client.get_municipis()
+                # Aquí obtenemos y guardamos las cuotas
+                await self.fetch_and_save_quotes(self.api_key)
+                # Aquí creamos el archivo alerts.json si no existe
+                await self.create_alerts_file()
             except (BadRequestError, ForbiddenError, TooManyRequestsError, InternalServerError, UnknownAPIError) as ex:
                 _LOGGER.error("Error al conectar con la API de Meteocat: %s", ex)
                 errors["base"] = "cannot_connect"
@@ -205,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)
@@ -231,6 +361,9 @@ class MeteocatConfigFlow(ConfigFlow, domain=DOMAIN):
         if user_input is not None:
             self.limit_xema = user_input.get(LIMIT_XEMA, 750)
             self.limit_prediccio = user_input.get(LIMIT_PREDICCIO, 100)
+            self.limit_xdde = user_input.get(LIMIT_XDDE, 250)
+            self.limit_quota = user_input.get(LIMIT_QUOTA, 300)
+            self.limit_basic = user_input.get(LIMIT_BASIC, 300)
             return self.async_create_entry(
                 title=self.selected_municipi["nom"],
                 data={
@@ -252,6 +385,9 @@ class MeteocatConfigFlow(ConfigFlow, domain=DOMAIN):
                     STATION_STATUS: str(self.station_status),
                     LIMIT_XEMA: self.limit_xema,
                     LIMIT_PREDICCIO: self.limit_prediccio,
+                    LIMIT_XDDE: self.limit_xdde,
+                    LIMIT_QUOTA: self.limit_quota,
+                    LIMIT_BASIC: self.limit_basic,
                 },
             )
 
@@ -259,6 +395,9 @@ class MeteocatConfigFlow(ConfigFlow, domain=DOMAIN):
             {
                 vol.Required(LIMIT_XEMA, default=750): cv.positive_int,
                 vol.Required(LIMIT_PREDICCIO, default=100): cv.positive_int,
+                vol.Required(LIMIT_XDDE, default=250): cv.positive_int,
+                vol.Required(LIMIT_QUOTA, default=300): cv.positive_int,
+                vol.Required(LIMIT_BASIC, default=2000): cv.positive_int,
             }
         )
 

package/custom_components/meteocat/const.py

@@ -18,6 +18,9 @@ PROVINCE_ID = "province_id"
 PROVINCE_NAME = "province_name"
 LIMIT_XEMA = "limit_xema"
 LIMIT_PREDICCIO = "limit_prediccio"
+LIMIT_XDDE = "limit_xdde"
+LIMIT_BASIC = "limit_basic"
+LIMIT_QUOTA = "limit_quota"
 STATION_STATUS = "station_status"
 HOURLY_FORECAST_FILE_STATUS = "hourly_forecast_file_status"
 DAILY_FORECAST_FILE_STATUS = "daily_forecast_file_status"
@@ -32,6 +35,13 @@ ALERT_COLD = "alert_cold"
 ALERT_WARM = "alert_warm"
 ALERT_WARM_NIGHT = "alert_warm_night"
 ALERT_SNOW = "alert_snow"
+QUOTA_FILE_STATUS = "quota_file_status"
+QUOTA_XDDE = "quota_xdde"
+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
 
@@ -44,6 +54,8 @@ DEFAULT_VALIDITY_DAYS = 1  # Número de días a partir de los cuales se consider
 DEFAULT_VALIDITY_HOURS = 5  # Hora a partir de la cual la API tiene la información actualizada de predicciones disponible para descarga
 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
 
 # Multiplicadores para la duración de validez basada en limit_prediccio
 ALERT_VALIDITY_MULTIPLIER_100 = 12  # para limit_prediccio <= 100
@@ -71,6 +83,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