meteocat 3.0.0 → 3.2.0

package/custom_components/meteocat/helpers.py

@@ -4,8 +4,8 @@ import logging
 from datetime import datetime
 from pathlib import Path
 from homeassistant.core import HomeAssistant
-from homeassistant.util.dt import as_local, as_utc, start_of_local_day
-from homeassistant.helpers.sun import get_astral_event_date
+from homeassistant.util import dt as dt_util
+from solarmoonpy.location import Location
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -19,45 +19,40 @@ def get_storage_dir(hass: HomeAssistant, subdir: str | None = None) -> Path:
     return base_dir
 
 # Cálculo de amanecer y atardecer para definir cuando es de noche
-def get_sun_times(hass, current_time=None):
-    """Obtén las horas de amanecer y atardecer para el día actual."""
-    if current_time is None:
-        current_time = datetime.now()
+def get_sun_times(location: Location, current_time: datetime | None = None) -> tuple[datetime, datetime]:
+    """Obtiene las horas de amanecer y atardecer para una ubicación usando solarmoonpy."""
+    now = dt_util.as_local(current_time or dt_util.now())
+    today = now.date()
+    sunrise = location.sunrise(date=today, local=True)
+    sunset = location.sunset(date=today, local=True)
 
-    # Asegúrate de que current_time es aware (UTC)
-    current_time = as_utc(current_time)
-    today = start_of_local_day(as_local(current_time))
-
-    # Obtén los eventos de amanecer y atardecer del día actual
-    sunrise = get_astral_event_date(hass, "sunrise", today)
-    sunset = get_astral_event_date(hass, "sunset", today)
+    if not sunrise or not sunset:
+        raise ValueError("No se pudieron calcular amanecer o atardecer.")
 
     _LOGGER.debug(
-        "Sunrise: %s, Sunset: %s, Current Time: %s",
-        sunrise,
-        sunset,
-        as_local(current_time),
+        "[solarmoonpy] Amanecer: %s, Atardecer: %s, Hora actual: %s",
+        sunrise, sunset, now
     )
+    return sunrise, sunset
 
-    if sunrise and sunset:
-        return sunrise, sunset
-
-    raise ValueError("No se pudieron determinar los datos de amanecer y atardecer.")
-
-def is_night(current_time, hass):
-    """Determina si actualmente es de noche."""
-    # Asegúrate de que current_time es aware (UTC)
+def is_night(current_time, location: Location) -> bool:
+    """Determina si actualmente es de noche usando una instancia de Location."""
+    # Asegurarse de que current_time sea aware y en zona local
     if current_time.tzinfo is None:
-        current_time = as_utc(current_time)
-
-    sunrise, sunset = get_sun_times(hass, current_time)
-
+        _LOGGER.warning("current_time sin zona horaria, asumiendo UTC")
+        current_time = dt_util.as_local(dt_util.utc_to_local(current_time))
+    else:
+        current_time = dt_util.as_local(current_time)
+
+    try:
+        sunrise, sunset = get_sun_times(location, current_time)
+    except Exception as e:
+        _LOGGER.warning("Fallo al calcular amanecer/atardecer con solarmoonpy: %s", e)
+        return False  # fallback seguro
+
+    is_night_now = current_time < sunrise or current_time > sunset
     _LOGGER.debug(
-        "Hora actual: %s, Amanecer: %s, Atardecer: %s",
-        as_local(current_time),
-        as_local(sunrise),
-        as_local(sunset),
+        "[solarmoonpy] Hora actual: %s | Amanecer: %s | Atardecer: %s → Noche: %s",
+        current_time, sunrise, sunset, is_night_now
     )
-
-    # Es de noche si es antes del amanecer o después del atardecer
-    return current_time < sunrise or current_time > sunset
+    return is_night_now

package/custom_components/meteocat/manifest.json

@@ -16,9 +16,10 @@
     "meteocatpy"
   ],
   "requirements": [
-    "meteocatpy==1.0.1",
+    "meteocatpy==1.0.2",
+    "solarmoonpy==1.0.8",
     "packaging>=20.3",
     "wrapt>=1.14.0"
   ],
-  "version": "3.0.0"
+  "version": "3.2.0"
 }

package/custom_components/meteocat/options_flow.py

@@ -13,8 +13,12 @@ from .const import (
     LIMIT_PREDICCIO,
     LIMIT_XDDE,
     LIMIT_QUOTA,
-    LIMIT_BASIC
+    LIMIT_BASIC,
+    LATITUDE,
+    LONGITUDE,
+    ALTITUDE,
 )
+
 from meteocatpy.town import MeteocatTown
 from meteocatpy.exceptions import (
     BadRequestError,
@@ -35,6 +39,12 @@ 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
+        self.altitude: float | None = None
 
     async def async_step_init(self, user_input: dict | None = None):
         """Paso inicial del flujo de opciones."""
@@ -45,6 +55,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 +66,8 @@ class MeteocatOptionsFlowHandler(OptionsFlow):
                         options=[
                             "update_api_and_limits",
                             "update_limits_only",
-                            "regenerate_assets"
+                            "regenerate_assets",
+                            "update_coordinates"
                         ],
                         translation_key="option"
                     )
@@ -177,7 +190,62 @@ 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)
+            self.altitude = user_input.get(ALTITUDE)
+
+            # 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"
+            # Validar que la altitud sea positiva
+            elif self.altitude < 0:
+                _LOGGER.error("Altitud inválida: %s. Debe ser >= 0.", self.altitude)
+                errors["base"] = "invalid_altitude"
+            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,
+                        ALTITUDE: self.altitude
+                    },
+                )
+                # 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, altitude=%s.",
+                    self.latitude, self.longitude, self.altitude
+                )
+                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,
+            vol.Required(ALTITUDE, default=self._config_entry.data.get(ALTITUDE)): vol.Coerce(float),
+        })
+        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),
+                "current_altitude": self._config_entry.data.get(ALTITUDE, 0.0)
+            }
+        )
+
     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: