meteocat 3.0.0 → 3.2.0

package/custom_components/meteocat/condition.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from datetime import datetime
+from typing import Any
 from .const import CONDITION_MAPPING
 from .helpers import is_night
 import logging
@@ -8,7 +9,10 @@ import logging
 _LOGGER = logging.getLogger(__name__)
 
 def get_condition_from_statcel(
-    codi_estatcel, current_time: datetime, hass, is_hourly: bool = True
+    codi_estatcel: Any,
+    current_time: datetime,
+    location,
+    is_hourly: bool = True
 ) -> dict:
     """
     Convierte el código 'estatCel' en condición de Home Assistant.
@@ -33,7 +37,7 @@ def get_condition_from_statcel(
         codi_estatcel = [codi_estatcel]
 
     # Determinar si es de noche
-    is_night_flag = is_night(current_time, hass)
+    is_night_flag = is_night(current_time, location)
 
     # Identificar la condición basada en el código
     for condition, codes in CONDITION_MAPPING.items():

package/custom_components/meteocat/config_flow.py

@@ -5,13 +5,25 @@ import json
 import logging
 from pathlib import Path
 from typing import Any
-from datetime import datetime, timezone
+from datetime import date, datetime, timezone, timedelta
 from zoneinfo import ZoneInfo
 
 import voluptuous as vol
 import aiofiles
 import unicodedata
 
+from solarmoonpy.location import Location, LocationInfo
+from solarmoonpy.moon import (
+    moon_phase,
+    moon_day,
+    moon_rise_set,
+    illuminated_percentage,
+    moon_distance,
+    moon_angular_diameter,
+    lunation_number,
+    get_moon_phase_name,
+    get_lunation_duration
+)
 from homeassistant.config_entries import ConfigEntry, ConfigFlow, ConfigFlowResult
 from homeassistant.core import callback
 from homeassistant.exceptions import HomeAssistantError
@@ -39,8 +51,8 @@ from .const import (
     LIMIT_XEMA,
     LIMIT_PREDICCIO,
     LIMIT_XDDE,
-    LIMIT_BASIC,
     LIMIT_QUOTA,
+    LIMIT_BASIC,
 )
 
 from .options_flow import MeteocatOptionsFlowHandler
@@ -88,6 +100,8 @@ class MeteocatConfigFlow(ConfigFlow, domain=DOMAIN):
         self.longitude: float | None = None
         self.altitude: float | None = None
         self.station_status: str | None = None
+        self.location: Location | None = None
+        self.timezone_str: str | None = None
 
     async def fetch_and_save_quotes(self, api_key: str):
         """Obtiene las cuotas de la API de Meteocat y las guarda en quotes.json."""
@@ -172,7 +186,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 +197,216 @@ 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 eventos solares + posición inicial del sol."""
+        if not self.selected_municipi or self.latitude is None or self.longitude is None:
+            _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.lower()}_data.json"
+
+        if sun_file.exists():
+            _LOGGER.debug("El archivo %s ya existe, no se crea de nuevo.", sun_file)
+            return
+
+        try:
+            # ZONA HORARIA DEL HASS
+            self.timezone_str = self.hass.config.time_zone or "Europe/Madrid"
+            tz = ZoneInfo(self.timezone_str)
+
+            # CREAR UBICACIÓN
+            self.location = Location(LocationInfo(
+                name=self.selected_municipi.get("nom", "Municipio"),
+                region="Spain",
+                timezone=self.timezone_str,
+                latitude=self.latitude,
+                longitude=self.longitude,
+                elevation=self.altitude or 0.0,
+            ))
+
+            now = datetime.now(tz)
+            today = now.date()
+            tomorrow = today + timedelta(days=1)
+
+            # EVENTOS HOY Y MAÑANA
+            events_today = self.location.sun_events(date=today, local=True)
+            events_tomorrow = self.location.sun_events(date=tomorrow, local=True)
+
+            # LÓGICA DE EVENTOS (igual que en el coordinador)
+            expected = {}
+            events_list = [
+                "dawn_astronomical", "dawn_nautical", "dawn_civil",
+                "sunrise", "noon", "sunset",
+                "dusk_civil", "dusk_nautical", "dusk_astronomical",
+                "midnight",
+            ]
+
+            for event in events_list:
+                event_time = events_today.get(event)
+                if event_time and now >= event_time:
+                    expected[event] = events_tomorrow.get(event)
+                else:
+                    expected[event] = event_time
+
+            # daylight_duration según sunrise
+            sunrise = expected["sunrise"]
+            expected["daylight_duration"] = (
+                events_tomorrow["daylight_duration"]
+                if sunrise == events_tomorrow["sunrise"]
+                else events_today["daylight_duration"]
+            )
+
+            # POSICIÓN ACTUAL DEL SOL
+            sun_pos = self.location.sun_position(dt=now, local=True)
+
+            # CONSTRUIR DADES 
+            dades_dict = {
+                "dawn_civil": expected["dawn_civil"].isoformat() if expected["dawn_civil"] else None,
+                "dawn_nautical": expected["dawn_nautical"].isoformat() if expected["dawn_nautical"] else None,
+                "dawn_astronomical": expected["dawn_astronomical"].isoformat() if expected["dawn_astronomical"] else None,
+                "sunrise": expected["sunrise"].isoformat() if expected["sunrise"] else None,
+                "noon": expected["noon"].isoformat() if expected["noon"] else None,
+                "sunset": expected["sunset"].isoformat() if expected["sunset"] else None,
+                "dusk_civil": expected["dusk_civil"].isoformat() if expected["dusk_civil"] else None,
+                "dusk_nautical": expected["dusk_nautical"].isoformat() if expected["dusk_nautical"] else None,
+                "dusk_astronomical": expected["dusk_astronomical"].isoformat() if expected["dusk_astronomical"] else None,
+                "midnight": expected["midnight"].isoformat() if expected["midnight"] else None,
+                "daylight_duration": expected["daylight_duration"],
+
+                # CAMPOS DE POSICIÓN SOLAR
+                "sun_elevation": round(sun_pos["elevation"], 2),
+                "sun_azimuth": round(sun_pos["azimuth"], 2),
+                "sun_horizon_position": sun_pos["horizon_position"],
+                "sun_rising": sun_pos["rising"],
+                "sun_position_updated": now.isoformat(),
+            }
+
+            # JSON FINAL
+            data_with_timestamp = {
+                "actualitzat": {"dataUpdate": now.isoformat()},
+                "dades": [dades_dict],
+            }
+
+            # GUARDAR
+            sun_file.parent.mkdir(parents=True, exist_ok=True)
+            async with aiofiles.open(sun_file, "w", encoding="utf-8") as file:
+                await file.write(json.dumps(data_with_timestamp, ensure_ascii=False, indent=4))
+
+            _LOGGER.info(
+                "Archivo sun_%s_data.json creado con eventos + posición solar inicial (elev=%.2f°, az=%.2f°)",
+                town_id, sun_pos["elevation"], sun_pos["azimuth"]
+            )
+
+        except Exception as ex:
+            _LOGGER.error("Error al crear sun_%s_data.json: %s", town_id, ex)
+
+    async def create_moon_file(self):
+        """Crea el archivo moon_{town_id}_data.json con datos iniciales de la fase lunar, moonrise y moonset."""
+        if not self.selected_municipi or not self.latitude or not self.longitude:
+            _LOGGER.warning("No se puede crear moon_{town_id}_data.json: faltan municipio o coordenadas")
+            return
+
+        town_id = self.selected_municipi["codi"]
+        files_dir = get_storage_dir(self.hass, "files")
+        moon_file = files_dir / f"moon_{town_id}_data.json"
+
+        if not moon_file.exists():
+            try:
+                # Fecha actual en UTC
+                current_time = datetime.now(timezone.utc).astimezone(TIMEZONE)
+                today = current_time.date()
+
+                # Inicializar parámetros con valores por defecto
+                phase = None
+                moon_day_today = None
+                lunation = None
+                illuminated = None
+                distance = None
+                angular_diameter = None
+                moon_phase_name = None
+                lunation_duration = None
+
+                # Calcular parámetros con manejo de errores individual
+                try:
+                    phase = round(moon_phase(today), 2)
+                except Exception as ex:
+                    _LOGGER.error("Error al calcular moon_phase: %s", ex)
+
+                try:
+                    moon_day_today = moon_day(today)
+                except Exception as ex:
+                    _LOGGER.error("Error al calcular moon_day: %s", ex)
+
+                try:
+                    lunation = lunation_number(today)
+                except Exception as ex:
+                    _LOGGER.error("Error al calcular lunation_number: %s", ex)
+
+                try:
+                    illuminated = round(illuminated_percentage(today), 2)
+                except Exception as ex:
+                    _LOGGER.error("Error al calcular illuminated_percentage: %s", ex)
+
+                try:
+                    distance = round(moon_distance(today), 0)
+                except Exception as ex:
+                    _LOGGER.error("Error al calcular moon_distance: %s", ex)
+
+                try:
+                    angular_diameter = round(moon_angular_diameter(today), 2)
+                except Exception as ex:
+                    _LOGGER.error("Error al calcular moon_angular_diameter: %s", ex)
+
+                try:
+                    moon_phase_name = get_moon_phase_name(today)
+                except Exception as ex:
+                    _LOGGER.error("Error al calcular moon_phase_name: %s", ex)
+                
+                try:
+                    lunation_duration = get_lunation_duration(today)
+                except Exception as ex:
+                    _LOGGER.error("Error al calcular lunation_duration: %s", ex)
+
+                # Moonrise y moonset aproximados (UTC)
+                try:
+                    rise_utc, set_utc = moon_rise_set(self.latitude, self.longitude, today)
+                    rise_local = rise_utc.astimezone(TIMEZONE).isoformat() if rise_utc else None
+                    set_local = set_utc.astimezone(TIMEZONE).isoformat() if set_utc else None
+                except Exception as ex:
+                    _LOGGER.error("Error al calcular moon_rise_set: %s", ex)
+                    rise_local = None
+                    set_local = None
+
+                # Formatear datos para guardar
+                moon_data_formatted = {
+                    "actualitzat": {"dataUpdate": current_time.isoformat()},
+                    "last_lunar_update_date": today.isoformat(),
+                    "dades": [
+                        {
+                            "moon_day": moon_day_today,
+                            "moon_phase": phase,
+                            "moon_phase_name": moon_phase_name,
+                            "illuminated_percentage": illuminated,
+                            "moon_distance": distance,
+                            "moon_angular_diameter": angular_diameter,
+                            "lunation": lunation,
+                            "lunation_duration": lunation_duration,
+                            "moonrise": rise_local,
+                            "moonset": set_local
+                        }
+                    ]
+                }
+
+                # Guardar el archivo
+                async with aiofiles.open(moon_file, "w", encoding="utf-8") as file:
+                    await file.write(json.dumps(moon_data_formatted, ensure_ascii=False, indent=4))
+                _LOGGER.info("Archivo moon_%s_data.json creado con datos iniciales", town_id)
+
+            except Exception as ex:
+                _LOGGER.error("Error general al crear moon_%s_data.json: %s", town_id, ex)
+
     async def async_step_user(
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
@@ -319,7 +543,10 @@ 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, sol y luna
                     await self.create_alerts_file()
+                    await self.create_sun_file()
+                    await self.create_moon_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 +611,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,17 +42,29 @@ QUOTA_BASIC = "quota_basic"
 QUOTA_XEMA = "quota_xema"
 QUOTA_QUERIES = "quota_queries"
 LIGHTNING_FILE_STATUS = "lightning_file_status"
+SUN = "sun"
+SUNRISE = "sunrise"
+SUNSET = "sunset"
+SUN_FILE_STATUS = "sun_file_status"
+MOON_PHASE = "moon_phase"
+MOON_FILE_STATUS = "moon_file_status"
+MOONRISE = "moonrise"
+MOONSET = "moonset"
 
 from homeassistant.const import Platform
 
-ATTRIBUTION = "Powered by Meteocatpy"
+ATTRIBUTION = "Powered by Meteocatpy & Solarmoonpy"
 PLATFORMS = [Platform.SENSOR, Platform.WEATHER]
 DEFAULT_NAME = "METEOCAT"
 
 # Tiempos para validación de API
 DEFAULT_VALIDITY_DAYS = 1  # Número de días a partir de los cuales se considera que el archivo de información está obsoleto
-DEFAULT_VALIDITY_HOURS = 5  # Hora a partir de la cual la API tiene la información actualizada de predicciones disponible para descarga
+DEFAULT_VALIDITY_HOURS = 6  # 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_UVI_LOW_VALIDITY_HOURS = 5  # Hora a partir de la cual la API tiene la información actualizada de datos UVI disponible para descarga con límite bajo de cuota
+DEFAULT_UVI_LOW_VALIDITY_MINUTES = 0  # Minutos a partir de los cuales la API tiene la información actualizada de datos UVI disponible para descarga con límite bajo de cuota
+DEFAULT_UVI_HIGH_VALIDITY_HOURS = 9  # Hora a partir de la cual la API tiene la información actualizada de datos UVI disponible para descarga con límite alto de cuota
+DEFAULT_UVI_HIGH_VALIDITY_MINUTES = 0  # Minutos a partir de los cuales la API tiene la información actualizada de datos UVI disponible para descarga con límite alto de cuota
 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
@@ -65,6 +77,9 @@ ALERT_VALIDITY_MULTIPLIER_200 = 6   # para 100 < limit_prediccio <= 200
 ALERT_VALIDITY_MULTIPLIER_500 = 3   # para 200 < limit_prediccio <= 500
 ALERT_VALIDITY_MULTIPLIER_DEFAULT = 1  # para limit_prediccio > 500
 
+# CUOTA ALTA PARA FAVORECER ACTUALIZACIONES DIARIAS DE LAS PREDICCIONES
+PREDICCIO_HIGH_QUOTA_LIMIT = 550
+
 # Códigos de sensores de la API
 WIND_SPEED = "wind_speed"  # Velocidad del viento
 WIND_DIRECTION = "wind_direction"  # Dirección del viento