meteocat 2.2.7 → 2.3.0

package/custom_components/meteocat/__init__.py

@@ -3,6 +3,9 @@ from __future__ import annotations
 import logging
 import voluptuous as vol
 from pathlib import Path
+import aiofiles
+import json
+
 from homeassistant import core
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
@@ -10,6 +13,7 @@ from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.entity_platform import async_get_platforms
 from homeassistant.helpers import config_validation as cv
 
+from .helpers import get_storage_dir
 from .coordinator import (
     MeteocatSensorCoordinator,
     MeteocatStaticSensorCoordinator,
@@ -28,12 +32,16 @@ from .coordinator import (
     MeteocatLightningFileCoordinator,
 )
 
+from meteocatpy.town import MeteocatTown
+from meteocatpy.symbols import MeteocatSymbols
+from meteocatpy.variables import MeteocatVariables
+from meteocatpy.townstations import MeteocatTownStations
 from .const import DOMAIN, PLATFORMS
 
 _LOGGER = logging.getLogger(__name__)
 
 # Versión
-__version__ = "2.2.7"
+__version__ = ""
 
 # Definir el esquema de configuración CONFIG_SCHEMA
 CONFIG_SCHEMA = vol.Schema(
@@ -44,6 +52,7 @@ CONFIG_SCHEMA = vol.Schema(
                 vol.Required("town_name"): cv.string,
                 vol.Required("town_id"): cv.string,
                 vol.Optional("variable_name", default="temperature"): cv.string,
+                vol.Required("variable_id"): cv.string,
                 vol.Optional("station_name"): cv.string,
                 vol.Optional("station_id"): cv.string,
                 vol.Optional("province_name"): cv.string,
@@ -56,17 +65,55 @@ CONFIG_SCHEMA = vol.Schema(
     extra=vol.ALLOW_EXTRA,
 )
 
-def safe_remove(path: Path, is_folder: bool = False):
-    """Elimina de forma segura un archivo o carpeta si existe."""
+def safe_remove(path: Path, is_folder: bool = False) -> None:
+    """Elimina un archivo o carpeta vacía de forma segura."""
     try:
-        if is_folder and path.exists() and not any(path.iterdir()):
-            path.rmdir()
-            _LOGGER.info(f"Carpeta {path.name} eliminada correctamente.")
-        elif not is_folder and path.exists():
-            path.unlink()
-            _LOGGER.info(f"Archivo {path.name} eliminado correctamente.")
-    except OSError as e:
-        _LOGGER.error(f"Error al intentar eliminar {path.name}: {e}")
+        if is_folder:
+            if path.exists() and path.is_dir():
+                path.rmdir()  # Solo elimina si está vacía
+                _LOGGER.info("Carpeta eliminada: %s", path)
+        else:
+            if path.exists():
+                path.unlink()
+                _LOGGER.info("Archivo eliminado: %s", path)
+    except Exception as e:
+        _LOGGER.error("Error eliminando %s: %s", path, e)
+
+async def ensure_assets_exist(hass, api_key, town_id=None, variable_id=None):
+    """Comprueba y crea los assets básicos si faltan."""
+    assets_dir = get_storage_dir(hass, "assets")
+    assets_dir.mkdir(parents=True, exist_ok=True)
+
+    # Lista de assets: (nombre_archivo, fetch_func, clave_json, args)
+    assets = [
+        ("towns.json", MeteocatTown(api_key).get_municipis, "towns", []),
+        ("stations.json", MeteocatTownStations(api_key).stations_service.get_stations, "stations", []),
+        ("variables.json", MeteocatVariables(api_key).get_variables, "variables", []),
+        ("symbols.json", MeteocatSymbols(api_key).fetch_symbols, "symbols", []),
+    ]
+
+    # Si tenemos town_id y variable_id, agregamos stations_<town_id>.json
+    if town_id and variable_id:
+        assets.append(
+            (f"stations_{town_id}.json", MeteocatTownStations(api_key).get_town_stations, "town_stations", [town_id, variable_id])
+        )
+
+    for filename, fetch_func, key, args in assets:
+        file_path = assets_dir / filename
+        if not file_path.exists():
+            _LOGGER.debug("Intentando descargar datos para %s desde la API con args: %s", key, args)
+            try:
+                data = await fetch_func(*args)
+            except Exception as ex:
+                _LOGGER.warning(
+                    "No se pudieron obtener los datos para %s. Intenta regenerarlo más adelante desde las opciones de la integración. Detalle: %s",
+                    key,
+                    ex,
+                )
+                data = []
+            async with aiofiles.open(file_path, "w", encoding="utf-8") as file:
+                await file.write(json.dumps({key: data}, ensure_ascii=False, indent=4))
+            _LOGGER.info("Archivo creado: %s", file_path)
 
 async def async_setup(hass: core.HomeAssistant, config: dict) -> bool:
     """Configuración inicial del componente Meteocat."""
@@ -89,6 +136,14 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     if missing_fields:
         _LOGGER.error(f"Faltan los siguientes campos en la configuración: {missing_fields}")
         return False
+    
+    # Crear los assets básicos si faltan
+    await ensure_assets_exist(
+        hass,
+        api_key=entry_data["api_key"],
+        town_id=entry_data.get("town_id"),
+        variable_id=entry_data.get("variable_id"),
+    )
 
     _LOGGER.debug(
         f"Datos de configuración: Municipio '{entry_data['town_name']}' (ID: {entry_data['town_id']}), "
@@ -99,78 +154,39 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     )
 
     # Inicializar coordinadores
-    try:
-        sensor_coordinator = MeteocatSensorCoordinator(hass=hass, entry_data=entry_data)
-        await sensor_coordinator.async_config_entry_first_refresh()
-        
-        static_sensor_coordinator = MeteocatStaticSensorCoordinator(hass=hass, entry_data=entry_data)
-        await sensor_coordinator.async_config_entry_first_refresh()
-
-        entity_coordinator = MeteocatEntityCoordinator(hass=hass, entry_data=entry_data)
-        await entity_coordinator.async_config_entry_first_refresh()
-
-        uvi_coordinator = MeteocatUviCoordinator(hass=hass, entry_data=entry_data)
-        await uvi_coordinator.async_config_entry_first_refresh()
-
-        uvi_file_coordinator = MeteocatUviFileCoordinator(hass=hass, entry_data=entry_data)
-        await uvi_file_coordinator.async_config_entry_first_refresh()
-
-        hourly_forecast_coordinator = HourlyForecastCoordinator(hass=hass, entry_data=entry_data)
-        await hourly_forecast_coordinator.async_config_entry_first_refresh()
-        
-        daily_forecast_coordinator = DailyForecastCoordinator(hass=hass, entry_data=entry_data)
-        await daily_forecast_coordinator.async_config_entry_first_refresh()
-
-        condition_coordinator = MeteocatConditionCoordinator(hass=hass, entry_data=entry_data)
-        await condition_coordinator.async_config_entry_first_refresh()
-
-        temp_forecast_coordinator = MeteocatTempForecastCoordinator(hass=hass, entry_data=entry_data)
-        await temp_forecast_coordinator.async_config_entry_first_refresh()
-
-        alerts_coordinator = MeteocatAlertsCoordinator(hass=hass, entry_data=entry_data)
-        await alerts_coordinator.async_config_entry_first_refresh()
-
-        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()
+    coordinators = [
+        ("sensor_coordinator", MeteocatSensorCoordinator),
+        ("static_sensor_coordinator", MeteocatStaticSensorCoordinator),
+        ("entity_coordinator", MeteocatEntityCoordinator),
+        ("uvi_coordinator", MeteocatUviCoordinator),
+        ("uvi_file_coordinator", MeteocatUviFileCoordinator),
+        ("hourly_forecast_coordinator", HourlyForecastCoordinator),
+        ("daily_forecast_coordinator", DailyForecastCoordinator),
+        ("condition_coordinator", MeteocatConditionCoordinator),
+        ("temp_forecast_coordinator", MeteocatTempForecastCoordinator),
+        ("alerts_coordinator", MeteocatAlertsCoordinator),
+        ("alerts_region_coordinator", MeteocatAlertsRegionCoordinator),
+        ("quotes_coordinator", MeteocatQuotesCoordinator),
+        ("quotes_file_coordinator", MeteocatQuotesFileCoordinator),
+        ("lightning_coordinator", MeteocatLightningCoordinator),
+        ("lightning_file_coordinator", MeteocatLightningFileCoordinator),
+    ]
 
-        lightning_coordinator = MeteocatLightningCoordinator(hass=hass, entry_data=entry_data)
-        await lightning_coordinator.async_config_entry_first_refresh()
+    hass.data.setdefault(DOMAIN, {})
+    hass.data[DOMAIN][entry.entry_id] = {}
 
-        lightning_file_coordinator = MeteocatLightningFileCoordinator(hass=hass, entry_data=entry_data)
-        await lightning_file_coordinator.async_config_entry_first_refresh()
+    try:
+        for key, cls in coordinators:
+            coordinator = cls(hass=hass, entry_data=entry_data)
+            await coordinator.async_config_entry_first_refresh()
+            hass.data[DOMAIN][entry.entry_id][key] = coordinator
 
-    except Exception as err:  # Capturar todos los errores
-        _LOGGER.exception(f"Error al inicializar los coordinadores: {err}")
+    except Exception as err:
+        _LOGGER.exception("Error al inicializar los coordinadores: %s", err)
         return False
 
-    # Guardar coordinadores y datos en hass.data
-    hass.data.setdefault(DOMAIN, {})
-    hass.data[DOMAIN][entry.entry_id] = {
-        "sensor_coordinator": sensor_coordinator,
-        "static_sensor_coordinator": static_sensor_coordinator,
-        "entity_coordinator": entity_coordinator,
-        "uvi_coordinator":  uvi_coordinator,
-        "uvi_file_coordinator": uvi_file_coordinator,
-        "hourly_forecast_coordinator": hourly_forecast_coordinator,
-        "daily_forecast_coordinator": daily_forecast_coordinator,
-        "condition_coordinator": condition_coordinator,
-        "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,
-    }
-
-    # Configurar plataformas
+    hass.data[DOMAIN][entry.entry_id].update(entry_data)
+
     _LOGGER.debug(f"Cargando plataformas: {PLATFORMS}")
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
 
@@ -192,48 +208,76 @@ async def async_remove_entry(hass: HomeAssistant, entry: ConfigEntry) -> None:
     """Limpia cualquier dato adicional al desinstalar la integración."""
     _LOGGER.info(f"Eliminando datos residuales de la integración: {entry.entry_id}")
 
-    # Definir las rutas base
-    custom_components_path = Path(hass.config.path("custom_components")) / DOMAIN
-    assets_folder = custom_components_path / "assets"
-    files_folder = custom_components_path / "files"
-
-    # Archivos comunes
-    symbols_file = assets_folder / "symbols.json"
-    variables_file = assets_folder / "variables.json"
-    alerts_file = files_folder / "alerts.json"
-    quotes_file = files_folder / "quotes.json"
+    # Rutas persistentes en /config/meteocat_files
+    base_folder = get_storage_dir(hass)
+    assets_folder = get_storage_dir(hass, "assets")
+    files_folder = get_storage_dir(hass, "files")
+
+    # Archivos comunes (solo se eliminan si no queda ninguna entrada)
+    common_files = [
+        assets_folder / "towns.json",
+        assets_folder / "symbols.json",
+        assets_folder / "variables.json",
+        assets_folder / "stations.json",
+        files_folder / "alerts.json",
+        files_folder / "quotes.json",
+    ]
 
-    # Archivos específicos de cada entry
+    # Identificadores de la entrada eliminada
     station_id = entry.data.get("station_id")
     town_id = entry.data.get("town_id")
     region_id = entry.data.get("region_id")
 
-    if not custom_components_path.exists():
-        _LOGGER.warning(f"La ruta {custom_components_path} no existe. No se realizará la limpieza.")
-        return
+    specific_files = []
 
-    # Eliminar archivos específicos de la entrada
+    # 1. Archivos de estación
     if station_id:
-        safe_remove(files_folder / f"station_{station_id.lower()}_data.json")
+        other_entries_with_station = [
+            e for e in hass.config_entries.async_entries(DOMAIN)
+            if e.entry_id != entry.entry_id and e.data.get("station_id") == station_id
+        ]
+        if not other_entries_with_station:
+            specific_files.append(files_folder / f"station_{station_id.lower()}_data.json")
+
+    # 2. Archivos de municipio
     if town_id:
-        safe_remove(files_folder / f"uvi_{town_id.lower()}_data.json")
-        safe_remove(files_folder / f"forecast_{town_id.lower()}_hourly_data.json")
-        safe_remove(files_folder / f"forecast_{town_id.lower()}_daily_data.json")
+        other_entries_with_town = [
+            e for e in hass.config_entries.async_entries(DOMAIN)
+            if e.entry_id != entry.entry_id and e.data.get("town_id") == town_id
+        ]
+        if not other_entries_with_town:
+            specific_files.extend([
+                assets_folder / f"stations_{town_id.lower()}.json",
+                files_folder / f"uvi_{town_id.lower()}_data.json",
+                files_folder / f"forecast_{town_id.lower()}_hourly_data.json",
+                files_folder / f"forecast_{town_id.lower()}_daily_data.json",
+            ])
+
+    # 3. Archivos de comarca (region_id)
     if region_id:
-        safe_remove(files_folder / f"alerts_{region_id}.json")
-        safe_remove(files_folder / f"lightning_{region_id}.json")
-
-    # Siempre eliminables
-    safe_remove(symbols_file)
-    safe_remove(variables_file)
-
-    # 🔑 Solo eliminar los archivos comunes si ya no quedan otras entradas
+        other_entries_with_region = [
+            e for e in hass.config_entries.async_entries(DOMAIN)
+            if e.entry_id != entry.entry_id and e.data.get("region_id") == region_id
+        ]
+        if not other_entries_with_region:
+            specific_files.extend([
+                files_folder / f"alerts_{region_id}.json",
+                files_folder / f"lightning_{region_id}.json",
+            ])
+
+    # Eliminar archivos específicos (solo si ya no los necesita nadie más)
+    for f in specific_files:
+        safe_remove(f)
+
+    # Comprobar si quedan entradas activas de la integración
     remaining_entries = [
         e for e in hass.config_entries.async_entries(DOMAIN)
         if e.entry_id != entry.entry_id
     ]
-    if not remaining_entries:  # significa que estamos borrando la última
-        safe_remove(alerts_file)
-        safe_remove(quotes_file)
-        safe_remove(assets_folder, is_folder=True)
-        safe_remove(files_folder, is_folder=True)
+    if not remaining_entries:
+        for f in common_files:
+            safe_remove(f)
+
+        # Intentar eliminar carpetas vacías
+        for folder in [assets_folder, files_folder, base_folder]:
+            safe_remove(folder, is_folder=True)