meteocat 3.0.0 → 3.1.0

package/custom_components/meteocat/config_flow.py

@@ -12,6 +12,8 @@ import voluptuous as vol
 import aiofiles
 import unicodedata
 
+from astral import LocationInfo
+from astral.sun import sun
 from homeassistant.config_entries import ConfigEntry, ConfigFlow, ConfigFlowResult
 from homeassistant.core import callback
 from homeassistant.exceptions import HomeAssistantError
@@ -39,8 +41,8 @@ from .const import (
     LIMIT_XEMA,
     LIMIT_PREDICCIO,
     LIMIT_XDDE,
-    LIMIT_BASIC,
     LIMIT_QUOTA,
+    LIMIT_BASIC,
 )
 
 from .options_flow import MeteocatOptionsFlowHandler
@@ -172,7 +174,7 @@ class MeteocatConfigFlow(ConfigFlow, domain=DOMAIN):
                     "Archivo regional %s creado con plantilla inicial", alerts_region_file
                 )
 
-             # Archivo lightning regional
+            # Archivo lightning regional
             lightning_file = alerts_dir / f"lightning_{self.region_id}.json"
             if not lightning_file.exists():
                 async with aiofiles.open(lightning_file, "w", encoding="utf-8") as file:
@@ -183,6 +185,51 @@ class MeteocatConfigFlow(ConfigFlow, domain=DOMAIN):
                     "Archivo lightning %s creado con plantilla inicial", lightning_file
                 )
 
+    async def create_sun_file(self):
+        """Crea el archivo sun_{town_id}_data.json con datos iniciales de sunrise y sunset."""
+        if not self.selected_municipi or not self.latitude or not self.longitude:
+            _LOGGER.warning("No se puede crear sun_{town_id}_data.json: faltan municipio o coordenadas")
+            return
+
+        town_id = self.selected_municipi["codi"]
+        files_dir = get_storage_dir(self.hass, "files")
+        sun_file = files_dir / f"sun_{town_id}_data.json"
+
+        if not sun_file.exists():
+            try:
+                # Crear objeto LocationInfo con las coordenadas y zona horaria
+                location = LocationInfo(
+                    name=self.selected_municipi["nom"],
+                    region="Catalonia",
+                    timezone="Europe/Madrid",
+                    latitude=self.latitude,
+                    longitude=self.longitude
+                )
+
+                # Calcular sunrise y sunset para el día actual
+                current_time = datetime.now(timezone.utc).astimezone(TIMEZONE)
+                sun_data = sun(location.observer, date=current_time.date(), tzinfo=TIMEZONE)
+
+                # Formatear los datos para el archivo
+                sun_data_formatted = {
+                    "actualitzat": {"dataUpdate": current_time.isoformat()},
+                    "dades": [
+                        {
+                            "sunrise": sun_data["sunrise"].isoformat(),
+                            "sunset": sun_data["sunset"].isoformat(),
+                            "date": current_time.date().isoformat()
+                        }
+                    ]
+                }
+
+                # Guardar el archivo
+                async with aiofiles.open(sun_file, "w", encoding="utf-8") as file:
+                    await file.write(json.dumps(sun_data_formatted, ensure_ascii=False, indent=4))
+                _LOGGER.info("Archivo sun_%s_data.json creado con datos iniciales", town_id)
+
+            except Exception as ex:
+                _LOGGER.error("Error al crear sun_%s_data.json: %s", town_id, ex)
+
     async def async_step_user(
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
@@ -319,7 +366,9 @@ class MeteocatConfigFlow(ConfigFlow, domain=DOMAIN):
                     self.province_name = station_metadata.get("provincia", {}).get("nom", "")
                     self.station_status = station_metadata.get("estats", [{}])[0].get("codi", "")
 
+                    # Crear archivos de alertas y sun
                     await self.create_alerts_file()
+                    await self.create_sun_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)
@@ -384,4 +433,4 @@ class MeteocatConfigFlow(ConfigFlow, domain=DOMAIN):
     @callback
     def async_get_options_flow(config_entry: ConfigEntry) -> MeteocatOptionsFlowHandler:
         """Devuelve el flujo de opciones para esta configuración."""
-        return MeteocatOptionsFlowHandler(config_entry)
+        return MeteocatOptionsFlowHandler(config_entry)

package/custom_components/meteocat/const.py

@@ -42,6 +42,9 @@ QUOTA_BASIC = "quota_basic"
 QUOTA_XEMA = "quota_xema"
 QUOTA_QUERIES = "quota_queries"
 LIGHTNING_FILE_STATUS = "lightning_file_status"
+SUNRISE = "sunrise"
+SUNSET = "sunset"
+SUN_FILE_STATUS = "sun_file_status"
 
 from homeassistant.const import Platform
 

package/custom_components/meteocat/coordinator.py

@@ -6,11 +6,13 @@ import logging
 import asyncio
 import unicodedata
 from pathlib import Path
-from datetime import datetime, timedelta, timezone, time
+from astral.sun import sun
+from astral import LocationInfo
+from datetime import date, datetime, timedelta, timezone, time
 from zoneinfo import ZoneInfo
 from typing import Dict, Any
 
-from homeassistant.core import HomeAssistant
+from homeassistant.core import HomeAssistant, EVENT_HOMEASSISTANT_START
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
 from homeassistant.exceptions import ConfigEntryNotReady
 from homeassistant.components.weather import Forecast
@@ -67,6 +69,8 @@ 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)
+DEFAULT_SUN_UPDATE_INTERVAL = timedelta(minutes=1)
+DEFAULT_SUN_FILE_UPDATE_INTERVAL = timedelta(seconds=30)
 
 # Definir la zona horaria local
 TIMEZONE = ZoneInfo("Europe/Madrid")
@@ -1924,3 +1928,185 @@ class MeteocatLightningFileCoordinator(DataUpdateCoordinator):
             "cg+": 0,
             "total": 0
         }
+
+class MeteocatSunCoordinator(DataUpdateCoordinator):
+    """Coordinator para manejar la actualización de los datos de sol calculados con Astral."""
+
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        entry_data: dict,
+    ):
+        """
+        Inicializa el coordinador de sol de Meteocat.
+        
+        Args:
+            hass (HomeAssistant): Instancia de Home Assistant.
+            entry_data (dict): Datos de configuración obtenidos de core.config_entries.
+        """
+        self.latitude = entry_data.get("latitude")
+        self.longitude = entry_data.get("longitude")
+        self.timezone_str = hass.config.time_zone or "Europe/Madrid"
+        self.town_id = entry_data.get("town_id")
+        
+        self.location = LocationInfo(
+            name=entry_data.get("town_name", "Municipio"),
+            region="Spain",
+            timezone=self.timezone_str,
+            latitude=self.latitude,
+            longitude=self.longitude,
+        )
+
+        # Ruta persistente en /config/meteocat_files/files
+        files_folder = get_storage_dir(hass, "files")
+        self.sun_file = files_folder / f"sun_{self.town_id.lower()}_data.json"
+
+        super().__init__(
+            hass,
+            _LOGGER,
+            name=f"{DOMAIN} Sun Coordinator",
+            update_interval=DEFAULT_SUN_UPDATE_INTERVAL,  # Ej. timedelta(minutes=1)
+        )
+
+    async def _async_update_data(self) -> Dict:
+        """Actualiza los datos de sol calculados o usa datos en caché según si los eventos han pasado."""
+        existing_data = await load_json_from_file(self.sun_file) or {}
+
+        now = datetime.now(tz=ZoneInfo(self.timezone_str))
+
+        if not existing_data or "dades" not in existing_data or not existing_data["dades"]:
+            return await self._calculate_and_save_new_data()
+
+        last_update_str = existing_data.get('actualitzat', {}).get('dataUpdate')
+        if not last_update_str:
+            return await self._calculate_and_save_new_data()
+
+        last_update = datetime.fromisoformat(last_update_str)
+
+        dades = existing_data["dades"][0]
+        saved_sunrise = datetime.fromisoformat(dades["sunrise"])
+        saved_sunset = datetime.fromisoformat(dades["sunset"])
+
+        # Verificar si los datos necesitan actualización
+        if now > saved_sunrise or now > saved_sunset:
+            return await self._calculate_and_save_new_data()
+        else:
+            _LOGGER.debug("Usando datos existentes de sol: %s", existing_data)
+            return {"actualizado": existing_data['actualitzat']['dataUpdate']}
+
+    async def _calculate_and_save_new_data(self):
+        """Calcula nuevos datos de sol y los guarda en el archivo JSON."""
+        try:
+            now = datetime.now(tz=ZoneInfo(self.timezone_str))
+            today = now.date()
+            
+            sun_data_today = sun(self.location.observer, date=today, tzinfo=ZoneInfo(self.timezone_str))
+            sunrise = sun_data_today["sunrise"]
+            sunset = sun_data_today["sunset"]
+            
+            if now > sunset:
+                next_day = today + timedelta(days=1)
+                sun_data_next = sun(self.location.observer, date=next_day, tzinfo=ZoneInfo(self.timezone_str))
+                sunrise = sun_data_next["sunrise"]
+                sunset = sun_data_next["sunset"]
+            elif now > sunrise:
+                next_day = today + timedelta(days=1)
+                sun_data_next = sun(self.location.observer, date=next_day, tzinfo=ZoneInfo(self.timezone_str))
+                sunrise = sun_data_next["sunrise"]
+                # sunset permanece como el de hoy
+            
+            # Estructurar los datos en el formato correcto
+            current_time = now.isoformat()
+            data_with_timestamp = {
+                "actualitzat": {
+                    "dataUpdate": current_time
+                },
+                "dades": [
+                    {
+                        "sunrise": sunrise.isoformat(),
+                        "sunset": sunset.isoformat()
+                    }
+                ]
+            }
+
+            # Guardar los datos en un archivo JSON
+            await save_json_to_file(data_with_timestamp, self.sun_file)
+
+            _LOGGER.debug("Datos de sol actualizados exitosamente: %s", data_with_timestamp)
+
+            return {"actualizado": data_with_timestamp['actualitzat']['dataUpdate']}
+
+        except Exception as err:
+            _LOGGER.exception("Error inesperado al calcular los datos de sol: %s", err)
+
+        # Intentar cargar datos en caché si falla el cálculo (aunque es improbable)
+        cached_data = await load_json_from_file(self.sun_file)
+        if cached_data:
+            _LOGGER.warning("Usando datos en caché para los datos de sol.")
+            return {"actualizado": cached_data['actualitzat']['dataUpdate']}
+
+        _LOGGER.error("No se pudo calcular datos actualizados ni cargar datos en caché.")
+        return None
+
+class MeteocatSunFileCoordinator(DataUpdateCoordinator):
+    """Coordinator para manejar la actualización de los datos de sol desde sun_{town_id}.json."""
+
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        entry_data: dict,
+    ):
+        """
+        Inicializa el coordinador de sol desde archivo.
+
+        Args:
+            hass (HomeAssistant): Instancia de Home Assistant.
+            entry_data (dict): Datos de configuración de la entrada.
+        """
+        self.town_id = entry_data["town_id"]
+        self.timezone_str = hass.config.time_zone or "Europe/Madrid"
+
+        # Ruta persistente en /config/meteocat_files/files
+        files_folder = get_storage_dir(hass, "files")
+        self.sun_file = files_folder / f"sun_{self.town_id.lower()}_data.json"
+
+        super().__init__(
+            hass,
+            _LOGGER,
+            name="Meteocat Sun File Coordinator",
+            update_interval=DEFAULT_SUN_FILE_UPDATE_INTERVAL,  # Ej. timedelta(seconds=30)
+        )
+
+    async def _async_update_data(self) -> Dict[str, Any]:
+        """Carga los datos de sol desde el archivo JSON y procesa la información."""
+        existing_data = await load_json_from_file(self.sun_file)
+
+        if not existing_data or "dades" not in existing_data or not existing_data["dades"]:
+            _LOGGER.warning("No se encontraron datos en %s.", self.sun_file)
+            return self._reset_data()
+
+        update_date_str = existing_data.get("actualitzat", {}).get("dataUpdate", "")
+        update_date = datetime.fromisoformat(update_date_str) if update_date_str else None
+        now = datetime.now(ZoneInfo(self.timezone_str))
+
+        dades = existing_data["dades"][0]
+        saved_sunrise = datetime.fromisoformat(dades["sunrise"])
+        saved_sunset = datetime.fromisoformat(dades["sunset"])
+
+        if saved_sunrise < now and saved_sunset < now:
+            _LOGGER.info("Los datos de sol están caducados. Reiniciando valores.")
+            return self._reset_data()
+        else:
+            return {
+                "actualizado": update_date.isoformat() if update_date else now.isoformat(),
+                "sunrise": dades.get("sunrise"),
+                "sunset": dades.get("sunset")
+            }
+
+    def _reset_data(self):
+        """Resetea los datos a valores nulos."""
+        return {
+            "actualizado": datetime.now(ZoneInfo(self.timezone_str)).isoformat(),
+            "sunrise": None,
+            "sunset": None
+        }

package/custom_components/meteocat/manifest.json

@@ -20,5 +20,5 @@
     "packaging>=20.3",
     "wrapt>=1.14.0"
   ],
-  "version": "3.0.0"
+  "version": "3.1.0"
 }

package/custom_components/meteocat/options_flow.py

@@ -13,8 +13,11 @@ from .const import (
     LIMIT_PREDICCIO,
     LIMIT_XDDE,
     LIMIT_QUOTA,
-    LIMIT_BASIC
+    LIMIT_BASIC,
+    LATITUDE,
+    LONGITUDE,
 )
+
 from meteocatpy.town import MeteocatTown
 from meteocatpy.exceptions import (
     BadRequestError,
@@ -35,6 +38,11 @@ class MeteocatOptionsFlowHandler(OptionsFlow):
         self.api_key: str | None = None
         self.limit_xema: int | None = None
         self.limit_prediccio: int | None = None
+        self.limit_xdde: int | None = None
+        self.limit_quota: int | None = None
+        self.limit_basic: int | None = None
+        self.latitude: float | None = None
+        self.longitude: float | None = None
 
     async def async_step_init(self, user_input: dict | None = None):
         """Paso inicial del flujo de opciones."""
@@ -45,6 +53,8 @@ class MeteocatOptionsFlowHandler(OptionsFlow):
                 return await self.async_step_update_limits_only()
             elif user_input["option"] == "regenerate_assets":
                 return await self.async_step_confirm_regenerate_assets()
+            elif user_input["option"] == "update_coordinates":
+                return await self.async_step_update_coordinates()
         
         return self.async_show_form(
             step_id="init",
@@ -54,7 +64,8 @@ class MeteocatOptionsFlowHandler(OptionsFlow):
                         options=[
                             "update_api_and_limits",
                             "update_limits_only",
-                            "regenerate_assets"
+                            "regenerate_assets",
+                            "update_coordinates"  # Nueva opción
                         ],
                         translation_key="option"
                     )
@@ -177,7 +188,54 @@ class MeteocatOptionsFlowHandler(OptionsFlow):
         return self.async_show_form(
             step_id="update_limits_only", data_schema=schema, errors=errors
         )
-    
+
+    async def async_step_update_coordinates(self, user_input: dict | None = None):
+        """Permite al usuario actualizar las coordenadas (latitude, longitude)."""
+        errors = {}
+
+        if user_input is not None:
+            self.latitude = user_input.get(LATITUDE)
+            self.longitude = user_input.get(LONGITUDE)
+
+            # Validar que las coordenadas estén dentro del rango de Cataluña
+            if not (40.5 <= self.latitude <= 42.5 and 0.1 <= self.longitude <= 3.3):
+                _LOGGER.error(
+                    "Coordenadas fuera del rango de Cataluña (latitude: %s, longitude: %s).",
+                    self.latitude, self.longitude
+                )
+                errors["base"] = "invalid_coordinates"
+            else:
+                # Actualizar la configuración con las nuevas coordenadas
+                self.hass.config_entries.async_update_entry(
+                    self._config_entry,
+                    data={
+                        **self._config_entry.data,
+                        LATITUDE: self.latitude,
+                        LONGITUDE: self.longitude
+                    },
+                )
+                # Recargar la integración para aplicar los cambios
+                await self.hass.config_entries.async_reload(self._config_entry.entry_id)
+                _LOGGER.info(
+                    "Coordenadas actualizadas a latitude: %s, longitude: %s",
+                    self.latitude, self.longitude
+                )
+                return self.async_create_entry(title="", data={})
+
+        schema = vol.Schema({
+            vol.Required(LATITUDE, default=self._config_entry.data.get(LATITUDE)): cv.latitude,
+            vol.Required(LONGITUDE, default=self._config_entry.data.get(LONGITUDE)): cv.longitude,
+        })
+        return self.async_show_form(
+            step_id="update_coordinates",
+            data_schema=schema,
+            errors=errors,
+            description_placeholders={
+                "current_latitude": self._config_entry.data.get(LATITUDE),
+                "current_longitude": self._config_entry.data.get(LONGITUDE)
+            }
+        )
+
     async def async_step_confirm_regenerate_assets(self, user_input: dict | None = None):
         """Confirma si el usuario realmente quiere regenerar los assets."""
         if user_input is not None: