meteocat 3.1.0 → 3.2.0

package/CHANGELOG.md

@@ -1,3 +1,37 @@
+# [3.2.0](https://github.com/figorr/meteocat/compare/v3.1.0...v3.2.0) (2025-11-07)
+
+
+### Bug Fixes
+
+* add validation date for moon coordinator ([8644f56](https://github.com/figorr/meteocat/commit/8644f56d8f8b6b607ba8809499afbfb81eb70b28))
+* adjust moon update interval ([ea51d90](https://github.com/figorr/meteocat/commit/ea51d905a232ab947607333ea4abaf449cd2e786))
+* fix friendly time translation ([9081a34](https://github.com/figorr/meteocat/commit/9081a343fd1562cb001f8a4b69948be3e26cbe00))
+* fix reset data moon file coordinator ([f3cf22f](https://github.com/figorr/meteocat/commit/f3cf22f1fb1d1a19d6ee9fefd2be304850be1180))
+* more accurate moon calculation ([dcee6e0](https://github.com/figorr/meteocat/commit/dcee6e0040d1cf77860fc7cbd06a5518145d3a72))
+
+
+### Features
+
+* add new moon day data ([77edf68](https://github.com/figorr/meteocat/commit/77edf681af037f00748b2b3cf2d281655d225718))
+* add new moon day data ([d2be96e](https://github.com/figorr/meteocat/commit/d2be96ec7f4f9d48c1f018ba2c642f29558d05fe))
+* add translations for lunation attribute ([10e3409](https://github.com/figorr/meteocat/commit/10e3409f82fa6530f0edf81c5e8406d019aeeaf1))
+* bump solarmoonpy to v1.0.0 ([65c2a04](https://github.com/figorr/meteocat/commit/65c2a0495250bac284c060b575256f95f4fb0be0))
+* bump solarmoonpy to v1.0.1 ([aa86747](https://github.com/figorr/meteocat/commit/aa86747ed41d69a80ac009b75b596746762548fe))
+* bump solarmoonpy to v1.0.3 ([246bd83](https://github.com/figorr/meteocat/commit/246bd835589978940efc11722b79e420f838ecab))
+* include latitude, longitude and altitude as new required variables ([5ef864c](https://github.com/figorr/meteocat/commit/5ef864ca38fa17ed05b36a19a96b8c7182f66be7))
+* new latitude, longitude and altitude update options setup ([1aeb968](https://github.com/figorr/meteocat/commit/1aeb9682c8e65b3cb0b29a7b7467edcc455304c9))
+* new lunation attribute for moon and moon phase name code ([60c7129](https://github.com/figorr/meteocat/commit/60c7129757916908baf26439819458ea3a173ad4))
+* new lunation attribute for moon sensor ([9bb32ff](https://github.com/figorr/meteocat/commit/9bb32ff03bd7eba291a1ee1aa578e2838dcf9bd5))
+* new lunation data and moon phase name rework ([0616401](https://github.com/figorr/meteocat/commit/0616401243334c21736d0877e5e50e435279e002))
+* new moon day attribute ([86ec6e3](https://github.com/figorr/meteocat/commit/86ec6e311fc098174027f17d3502e8be740d7e86))
+* new moon sensors ([7c7c1d3](https://github.com/figorr/meteocat/commit/7c7c1d38393a40fd2e69eeba2c24bb185ae349ef))
+* new solarmoonpy requirement for sun and moon events calculation ([1d25a62](https://github.com/figorr/meteocat/commit/1d25a6252cf568e1242f654c389aeada2b5d73f6))
+* new sun and moon coordinators ([af2290e](https://github.com/figorr/meteocat/commit/af2290e7384a9ad5416afdf4d6767ad69099813c))
+* new sun and moon files ([b489d7a](https://github.com/figorr/meteocat/commit/b489d7a9abc5af747fc50a2e0d7b0d661408b824))
+* new sun and moon sensors ([91265f3](https://github.com/figorr/meteocat/commit/91265f3c6cbd512b3706c29d466f9bb01df6d45e))
+* translation for new moon day attribute ([162859e](https://github.com/figorr/meteocat/commit/162859e2822374b81835cb1af07325dceaf5a55e))
+* translations for the new moon and sun sensors ([91a33b6](https://github.com/figorr/meteocat/commit/91a33b6b52e34ed69eed4eb5fbfaf9dffd20df57))
+
 # [3.1.0](https://github.com/figorr/meteocat/compare/v3.0.0...v3.1.0) (2025-09-27)
 
 

package/README.md

@@ -135,6 +135,9 @@ You will see three available options:
   If for any reason some files in the `assets` folder (`towns.json`, `stations.json`, `variables.json`, `symbols.json`, or `stations_<town_id>.json`) are missing or outdated, you can regenerate them directly from the options menu.  
   > ℹ️ If the Meteocat API is not available at that moment, the integration will still start, and you can retry regeneration later.
 
+- **Update coordinates and elevation**  
+  Change the default station coordinates and elevation that were set during the first setup. So you can use your location coordinates and elevation for more accurate sun and moon data.
+
 ### Accessing the Options Menu
 
 You can access the Options Menu in two ways, both inside the integration:
@@ -168,7 +171,7 @@ Meteocat integration has its own weather card.
 
 To install the card, please follow the instructions from its own repository, [🎫 Meteocat Card](https://github.com/figorr/meteocat-card).
 
-![Meteocat Card](images/daily_forecast_2_alerts.png)
+![Meteocat Card](images/daily_forecast_no_alerts.png)
 
 # Documentation
 

package/custom_components/meteocat/__init__.py

@@ -24,7 +24,7 @@ from .const import DOMAIN, PLATFORMS
 _LOGGER = logging.getLogger(__name__)
 
 # Versión
-__version__ = "3.1.0"
+__version__ = "3.2.0"
 
 # Definir el esquema de configuración CONFIG_SCHEMA
 CONFIG_SCHEMA = vol.Schema(
@@ -44,6 +44,7 @@ CONFIG_SCHEMA = vol.Schema(
                 vol.Optional("region_id"): cv.string,
                 vol.Required("latitude"): cv.latitude,
                 vol.Required("longitude"): cv.longitude,
+                vol.Required("altitude"): vol.Coerce(float),
             }
         )
     },
@@ -120,7 +121,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     required_fields = [
         "api_key", "town_name", "town_id", "variable_name",
         "variable_id", "station_name", "station_id", "province_name",
-        "province_id", "region_name", "region_id", "latitude", "longitude"
+        "province_id", "region_name", "region_id", "latitude", "longitude", "altitude"
     ]
     missing_fields = [field for field in required_fields if field not in entry_data]
     if missing_fields:
@@ -156,6 +157,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
         f"Provincia '{entry_data['province_name']}' (ID: {entry_data['province_id']}), "
         f"Comarca '{entry_data['region_name']}' (ID: {entry_data['region_id']}), "
         f"Coordenadas: ({entry_data['latitude']}, {entry_data['longitude']})."
+        f"Altitud: ({entry_data['altitude']})."
     )
 
     # Lista de coordinadores con sus clases
@@ -177,6 +179,8 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
         ("lightning_file_coordinator", "MeteocatLightningFileCoordinator"),
         ("sun_coordinator", "MeteocatSunCoordinator"),
         ("sun_file_coordinator", "MeteocatSunFileCoordinator"),
+        ("moon_coordinator", "MeteocatMoonCoordinator"),
+        ("moon_file_coordinator", "MeteocatMoonFileCoordinator"),
     ]
 
     hass.data.setdefault(DOMAIN, {})
@@ -261,6 +265,7 @@ async def async_remove_entry(hass: HomeAssistant, entry: ConfigEntry) -> None:
                 files_folder / f"forecast_{town_id.lower()}_hourly_data.json",
                 files_folder / f"forecast_{town_id.lower()}_daily_data.json",
                 files_folder / f"sun_{town_id.lower()}_data.json",
+                files_folder / f"moon_{town_id.lower()}_data.json",
             ])
 
     # 3. Archivos de comarca (region_id)
@@ -290,4 +295,4 @@ async def async_remove_entry(hass: HomeAssistant, entry: ConfigEntry) -> None:
 
         # Intentar eliminar carpetas vacías
         for folder in [assets_folder, files_folder, base_folder]:
-            safe_remove(folder, is_folder=True)
+            safe_remove(folder, is_folder=True)

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,15 +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 astral import LocationInfo
-from astral.sun import sun
+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
@@ -90,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."""
@@ -186,49 +198,214 @@ class MeteocatConfigFlow(ConfigFlow, domain=DOMAIN):
                 )
 
     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:
+        """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}_data.json"
+        sun_file = files_dir / f"sun_{town_id.lower()}_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
-                )
+        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],
+            }
 
-                # Calcular sunrise y sunset para el día actual
+            # 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)
-                sun_data = sun(location.observer, date=current_time.date(), tzinfo=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 los datos para el archivo
-                sun_data_formatted = {
+                # Formatear datos para guardar
+                moon_data_formatted = {
                     "actualitzat": {"dataUpdate": current_time.isoformat()},
+                    "last_lunar_update_date": today.isoformat(),
                     "dades": [
                         {
-                            "sunrise": sun_data["sunrise"].isoformat(),
-                            "sunset": sun_data["sunset"].isoformat(),
-                            "date": current_time.date().isoformat()
+                            "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(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)
+                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 al crear sun_%s_data.json: %s", town_id, 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
@@ -366,9 +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 y sun
+                    # 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)

package/custom_components/meteocat/const.py

@@ -42,20 +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
@@ -68,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