meteocat 0.1.23 → 0.1.25

package/custom_components/meteocat/coordinator.py

@@ -1,171 +1,195 @@
-from __future__ import annotations
-
-import logging
-from datetime import timedelta
-from typing import Dict
-
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
-from homeassistant.exceptions import ConfigEntryNotReady
-
-from meteocatpy.data import MeteocatStationData
-from meteocatpy.forecast import MeteocatForecast
-from meteocatpy.exceptions import (
-    BadRequestError,
-    ForbiddenError,
-    TooManyRequestsError,
-    InternalServerError,
-    UnknownAPIError,
-)
-
-from .const import DOMAIN
-
-_LOGGER = logging.getLogger(__name__)
-
-# Valores predeterminados para los intervalos de actualización
-DEFAULT_SENSOR_UPDATE_INTERVAL = timedelta(minutes=90)
-DEFAULT_ENTITY_UPDATE_INTERVAL = timedelta(hours=12)
-
-
-class MeteocatSensorCoordinator(DataUpdateCoordinator):
-    """Coordinator para manejar la actualización de datos de los sensores."""
-
-    def __init__(
-        self,
-        hass: HomeAssistant,
-        entry_data: dict,
-        update_interval: timedelta = DEFAULT_SENSOR_UPDATE_INTERVAL,
-    ):
-        """
-        Inicializa el coordinador de sensores de Meteocat.
-
-        Args:
-            hass (HomeAssistant): Instancia de Home Assistant.
-            entry_data (dict): Datos de configuración obtenidos de core.config_entries.
-            update_interval (timedelta): Intervalo de actualización.
-        """
-        self.api_key = entry_data["api_key"]  # Usamos la API key de la configuración
-        self.town_name = entry_data["town_name"]  # Usamos el nombre del municipio
-        self.town_id = entry_data["town_id"]  # Usamos el ID del municipio
-        self.station_name = entry_data["station_name"]  # Usamos el nombre de la estación
-        self.station_id = entry_data["station_id"]  # Usamos el ID de la estación
-        self.variable_name = entry_data["variable_name"]  # Usamos el nombre de la variable
-        self.variable_id = entry_data["variable_id"]  # Usamos el ID de la variable
-        self.meteocat_station_data = MeteocatStationData(self.api_key)
-
-        super().__init__(
-            hass,
-            _LOGGER,
-            name=f"{DOMAIN} Sensor Coordinator",
-            update_interval=update_interval,
-        )
-
-    async def _async_update_data(self) -> Dict:
-        """Actualiza los datos de los sensores desde la API de Meteocat."""
-        try:
-            data = await self.meteocat_station_data.get_station_data_with_variables(self.station_id)
-            _LOGGER.debug("Datos de sensores actualizados exitosamente: %s", data)
-            return data
-        except ForbiddenError as err:
-            _LOGGER.error(
-                "Acceso denegado al obtener datos de sensores (Station ID: %s): %s",
-                self.station_id,
-                err,
-            )
-            raise ConfigEntryNotReady from err
-        except TooManyRequestsError as err:
-            _LOGGER.warning(
-                "Límite de solicitudes alcanzado al obtener datos de sensores (Station ID: %s): %s",
-                self.station_id,
-                err,
-            )
-            raise ConfigEntryNotReady from err
-        except (BadRequestError, InternalServerError, UnknownAPIError) as err:
-            _LOGGER.error(
-                "Error al obtener datos de sensores (Station ID: %s): %s",
-                self.station_id,
-                err,
-            )
-            raise
-        except Exception as err:
-            _LOGGER.exception(
-                "Error inesperado al obtener datos de sensores (Station ID: %s): %s",
-                self.station_id,
-                err,
-            )
-            raise
-
-
-class MeteocatEntityCoordinator(DataUpdateCoordinator):
-    """Coordinator para manejar la actualización de datos de las entidades de predicción."""
-
-    def __init__(
-        self,
-        hass: HomeAssistant,
-        entry_data: dict,
-        update_interval: timedelta = DEFAULT_ENTITY_UPDATE_INTERVAL,
-    ):
-        """
-        Inicializa el coordinador de datos para entidades de predicción.
-
-        Args:
-            hass (HomeAssistant): Instancia de Home Assistant.
-            entry_data (dict): Datos de configuración obtenidos de core.config_entries.
-            update_interval (timedelta): Intervalo de actualización.
-        """
-        self.api_key = entry_data["api_key"]
-        self.town_name = entry_data["town_name"]
-        self.town_id = entry_data["town_id"]
-        self.station_name = entry_data["station_name"]
-        self.station_id = entry_data["station_id"]
-        self.variable_name = entry_data["variable_name"]
-        self.variable_id = entry_data["variable_id"]
-        self.meteocat_forecast = MeteocatForecast(self.api_key)
-
-        super().__init__(
-            hass,
-            _LOGGER,
-            name=f"{DOMAIN} Entity Coordinator",
-            update_interval=update_interval,
-        )
-
-    async def _async_update_data(self) -> Dict:
-        """Actualiza los datos de las entidades de predicción desde la API de Meteocat."""
-        try:
-            hourly_forecast = await self.meteocat_forecast.get_prediccion_horaria(self.town_id)
-            daily_forecast = await self.meteocat_forecast.get_prediccion_diaria(self.town_id)
-            _LOGGER.debug(
-                "Datos de predicción actualizados exitosamente (Town ID: %s)", self.town_id
-            )
-            return {
-                "hourly_forecast": hourly_forecast,
-                "daily_forecast": daily_forecast,
-            }
-        except ForbiddenError as err:
-            _LOGGER.error(
-                "Acceso denegado al obtener datos de predicción (Town ID: %s): %s",
-                self.town_id,
-                err,
-            )
-            raise ConfigEntryNotReady from err
-        except TooManyRequestsError as err:
-            _LOGGER.warning(
-                "Límite de solicitudes alcanzado al obtener datos de predicción (Town ID: %s): %s",
-                self.town_id,
-                err,
-            )
-            raise ConfigEntryNotReady from err
-        except (BadRequestError, InternalServerError, UnknownAPIError) as err:
-            _LOGGER.error(
-                "Error al obtener datos de predicción (Town ID: %s): %s",
-                self.town_id,
-                err,
-            )
-            raise
-        except Exception as err:
-            _LOGGER.exception(
-                "Error inesperado al obtener datos de predicción (Town ID: %s): %s",
-                self.town_id,
-                err,
-            )
-            raise
+from __future__ import annotations
+
+import os
+import json
+import logging
+from datetime import timedelta
+from typing import Dict
+
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
+from homeassistant.exceptions import ConfigEntryNotReady
+
+from meteocatpy.data import MeteocatStationData
+from meteocatpy.forecast import MeteocatForecast
+from meteocatpy.exceptions import (
+    BadRequestError,
+    ForbiddenError,
+    TooManyRequestsError,
+    InternalServerError,
+    UnknownAPIError,
+)
+
+from .const import DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+
+# Valores predeterminados para los intervalos de actualización
+DEFAULT_SENSOR_UPDATE_INTERVAL = timedelta(minutes=90)
+DEFAULT_ENTITY_UPDATE_INTERVAL = timedelta(hours=12)
+
+def save_json_to_file(data: dict, filename="station_data.json"):
+    """Guardar datos JSON en un archivo para análisis."""
+    try:
+        # Crear la carpeta 'files' si no existe
+        output_folder = os.path.join(os.path.dirname(__file__), "files")
+        os.makedirs(output_folder, exist_ok=True)
+
+        # Ruta completa del archivo
+        output_file = os.path.join(output_folder, filename)
+
+        # Guardar los datos en el archivo
+        with open(output_file, "w", encoding="utf-8") as f:
+            json.dump(data, f, ensure_ascii=False, indent=4)
+
+        _LOGGER.info(f"Archivo JSON guardado en: {output_file}")
+    except Exception as e:
+        _LOGGER.error(f"Error al guardar el archivo JSON: {e}")
+
+class MeteocatSensorCoordinator(DataUpdateCoordinator):
+    """Coordinator para manejar la actualización de datos de los sensores."""
+
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        entry_data: dict,
+        update_interval: timedelta = DEFAULT_SENSOR_UPDATE_INTERVAL,
+    ):
+        """
+        Inicializa el coordinador de sensores de Meteocat.
+
+        Args:
+            hass (HomeAssistant): Instancia de Home Assistant.
+            entry_data (dict): Datos de configuración obtenidos de core.config_entries.
+            update_interval (timedelta): Intervalo de actualización.
+        """
+        self.api_key = entry_data["api_key"]  # Usamos la API key de la configuración
+        self.town_name = entry_data["town_name"]  # Usamos el nombre del municipio
+        self.town_id = entry_data["town_id"]  # Usamos el ID del municipio
+        self.station_name = entry_data["station_name"]  # Usamos el nombre de la estación
+        self.station_id = entry_data["station_id"]  # Usamos el ID de la estación
+        self.variable_name = entry_data["variable_name"]  # Usamos el nombre de la variable
+        self.variable_id = entry_data["variable_id"]  # Usamos el ID de la variable
+        self.meteocat_station_data = MeteocatStationData(self.api_key)
+
+        super().__init__(
+            hass,
+            _LOGGER,
+            name=f"{DOMAIN} Sensor Coordinator",
+            update_interval=update_interval,
+        )
+
+    async def _async_update_data(self) -> Dict:
+        """Actualiza los datos de los sensores desde la API de Meteocat."""
+        try:
+            # Obtener datos desde la API
+            data = await self.meteocat_station_data.get_station_data(self.station_id)
+            _LOGGER.debug("Datos de sensores actualizados exitosamente: %s", data)
+
+            # Guardar los datos en un archivo JSON
+            save_json_to_file(data)
+
+            return data
+        except ForbiddenError as err:
+            _LOGGER.error(
+                "Acceso denegado al obtener datos de sensores (Station ID: %s): %s",
+                self.station_id,
+                err,
+            )
+            raise ConfigEntryNotReady from err
+        except TooManyRequestsError as err:
+            _LOGGER.warning(
+                "Límite de solicitudes alcanzado al obtener datos de sensores (Station ID: %s): %s",
+                self.station_id,
+                err,
+            )
+            raise ConfigEntryNotReady from err
+        except (BadRequestError, InternalServerError, UnknownAPIError) as err:
+            _LOGGER.error(
+                "Error al obtener datos de sensores (Station ID: %s): %s",
+                self.station_id,
+                err,
+            )
+            raise
+        except Exception as err:
+            _LOGGER.exception(
+                "Error inesperado al obtener datos de sensores (Station ID: %s): %s",
+                self.station_id,
+                err,
+            )
+            raise
+
+
+class MeteocatEntityCoordinator(DataUpdateCoordinator):
+    """Coordinator para manejar la actualización de datos de las entidades de predicción."""
+
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        entry_data: dict,
+        update_interval: timedelta = DEFAULT_ENTITY_UPDATE_INTERVAL,
+    ):
+        """
+        Inicializa el coordinador de datos para entidades de predicción.
+
+        Args:
+            hass (HomeAssistant): Instancia de Home Assistant.
+            entry_data (dict): Datos de configuración obtenidos de core.config_entries.
+            update_interval (timedelta): Intervalo de actualización.
+        """
+        self.api_key = entry_data["api_key"]
+        self.town_name = entry_data["town_name"]
+        self.town_id = entry_data["town_id"]
+        self.station_name = entry_data["station_name"]
+        self.station_id = entry_data["station_id"]
+        self.variable_name = entry_data["variable_name"]
+        self.variable_id = entry_data["variable_id"]
+        self.meteocat_forecast = MeteocatForecast(self.api_key)
+
+        super().__init__(
+            hass,
+            _LOGGER,
+            name=f"{DOMAIN} Entity Coordinator",
+            update_interval=update_interval,
+        )
+
+    async def _async_update_data(self) -> Dict:
+        """Actualiza los datos de las entidades de predicción desde la API de Meteocat."""
+        try:
+            hourly_forecast = await self.meteocat_forecast.get_prediccion_horaria(self.town_id)
+            daily_forecast = await self.meteocat_forecast.get_prediccion_diaria(self.town_id)
+            _LOGGER.debug(
+                "Datos de predicción actualizados exitosamente (Town ID: %s)", self.town_id
+            )
+            return {
+                "hourly_forecast": hourly_forecast,
+                "daily_forecast": daily_forecast,
+            }
+        except ForbiddenError as err:
+            _LOGGER.error(
+                "Acceso denegado al obtener datos de predicción (Town ID: %s): %s",
+                self.town_id,
+                err,
+            )
+            raise ConfigEntryNotReady from err
+        except TooManyRequestsError as err:
+            _LOGGER.warning(
+                "Límite de solicitudes alcanzado al obtener datos de predicción (Town ID: %s): %s",
+                self.town_id,
+                err,
+            )
+            raise ConfigEntryNotReady from err
+        except (BadRequestError, InternalServerError, UnknownAPIError) as err:
+            _LOGGER.error(
+                "Error al obtener datos de predicción (Town ID: %s): %s",
+                self.town_id,
+                err,
+            )
+            raise
+        except Exception as err:
+            _LOGGER.exception(
+                "Error inesperado al obtener datos de predicción (Town ID: %s): %s",
+                self.town_id,
+                err,
+            )
+            raise

package/custom_components/meteocat/entity.py

@@ -1,98 +1,98 @@
-from __future__ import annotations
-
-import asyncio
-import logging
-from homeassistant.components.weather import WeatherEntity
-from homeassistant.const import (
-    DEGREE,
-    PERCENTAGE,
-    UnitOfPressure,
-    UnitOfSpeed,
-    UnitOfTemperature,
-    UnitOfVolumetricFlux,
-)
-
-from .const import (
-    DOMAIN,
-    CONF_API_KEY,
-    TOWN_ID,
-    TEMPERATURE,
-    HUMIDITY,
-    WIND_SPEED,
-    WIND_DIRECTION,
-)
-from .condition import get_condition_from_statcel
-from .coordinator import MeteocatEntityCoordinator
-
-
-_LOGGER = logging.getLogger(__name__)
-
-async def async_setup_entry(hass, config_entry, async_add_entities):
-    """Configura el componente weather basado en una entrada de configuración."""
-    api_key = config_entry.data[CONF_API_KEY]
-    town_id = config_entry.data[TOWN_ID]
-
-    # Crear el coordinador
-    coordinator = MeteocatEntityCoordinator(hass, api_key, town_id)
-    # Asegurarse de que el coordinador esté actualizado antes de agregar la entidad
-    await coordinator.async_refresh()
-
-    async_add_entities([MeteocatWeatherEntity(coordinator)], True)
-
-class MeteocatWeatherEntity(WeatherEntity):
-    """Entidad de clima para la integración Meteocat."""
-
-    def __init__(self, coordinator: MeteocatEntityCoordinator):
-        """Inicializa la entidad MeteocatWeather."""
-        self._coordinator = coordinator
-        self._attr_temperature_unit = UnitOfTemperature.CELSIUS
-        self._data = {}
-
-    async def async_update(self):
-        """Actualiza los datos meteorológicos."""
-        try:
-            # Usamos el coordinador para obtener los datos actualizados
-            if self._coordinator.data:
-                hourly_forecast = self._coordinator.data["hourly_forecast"]
-                current_forecast = hourly_forecast["variables"]
-                codi_estatcel = current_forecast.get("estatCel", {}).get("valor")
-                is_night = current_forecast.get("is_night", False)
-                self._data = {
-                    "temperature": current_forecast.get(TEMPERATURE, {}).get("valor"),
-                    "humidity": current_forecast.get(HUMIDITY, {}).get("valor"),
-                    "wind_speed": current_forecast.get(WIND_SPEED, {}).get("valor"),
-                    "wind_bearing": current_forecast.get(WIND_DIRECTION, {}).get("valor"),
-                    "condition": get_condition_from_statcel(codi_estatcel, is_night)["condition"],
-                }
-        except Exception as err:
-            _LOGGER.error("Error al actualizar la predicción de Meteocat: %s", err)
-
-    @property
-    def name(self):
-        """Retorna el nombre de la entidad."""
-        return f"Clima {self._coordinator._town_id}"
-
-    @property
-    def temperature(self):
-        """Retorna la temperatura actual."""
-        return self._data.get("temperature")
-
-    @property
-    def humidity(self):
-        """Retorna la humedad relativa actual."""
-        return self._data.get("humidity")
-
-    @property
-    def wind_speed(self):
-        """Retorna la velocidad del viento."""
-        return self._data.get("wind_speed")
-
-    @property
-    def wind_bearing(self):
-        """Retorna la dirección del viento."""
-        return self._data.get("wind_bearing")
-
-    @property
-    def condition(self):
-        """Retorna la condición climática."""
-        return self._data.get("condition")
+from __future__ import annotations
+
+import asyncio
+import logging
+from homeassistant.components.weather import WeatherEntity
+from homeassistant.const import (
+    DEGREE,
+    PERCENTAGE,
+    UnitOfPressure,
+    UnitOfSpeed,
+    UnitOfTemperature,
+    UnitOfVolumetricFlux,
+)
+
+from .const import (
+    DOMAIN,
+    CONF_API_KEY,
+    TOWN_ID,
+    TEMPERATURE,
+    HUMIDITY,
+    WIND_SPEED,
+    WIND_DIRECTION,
+)
+from .condition import get_condition_from_statcel
+from .coordinator import MeteocatEntityCoordinator
+
+
+_LOGGER = logging.getLogger(__name__)
+
+async def async_setup_entry(hass, config_entry, async_add_entities):
+    """Configura el componente weather basado en una entrada de configuración."""
+    api_key = config_entry.data[CONF_API_KEY]
+    town_id = config_entry.data[TOWN_ID]
+
+    # Crear el coordinador
+    coordinator = MeteocatEntityCoordinator(hass, api_key, town_id)
+    # Asegurarse de que el coordinador esté actualizado antes de agregar la entidad
+    await coordinator.async_refresh()
+
+    async_add_entities([MeteocatWeatherEntity(coordinator)], True)
+
+class MeteocatWeatherEntity(WeatherEntity):
+    """Entidad de clima para la integración Meteocat."""
+
+    def __init__(self, coordinator: MeteocatEntityCoordinator):
+        """Inicializa la entidad MeteocatWeather."""
+        self._coordinator = coordinator
+        self._attr_temperature_unit = UnitOfTemperature.CELSIUS
+        self._data = {}
+
+    async def async_update(self):
+        """Actualiza los datos meteorológicos."""
+        try:
+            # Usamos el coordinador para obtener los datos actualizados
+            if self._coordinator.data:
+                hourly_forecast = self._coordinator.data["hourly_forecast"]
+                current_forecast = hourly_forecast["variables"]
+                codi_estatcel = current_forecast.get("estatCel", {}).get("valor")
+                is_night = current_forecast.get("is_night", False)
+                self._data = {
+                    "temperature": current_forecast.get(TEMPERATURE, {}).get("valor"),
+                    "humidity": current_forecast.get(HUMIDITY, {}).get("valor"),
+                    "wind_speed": current_forecast.get(WIND_SPEED, {}).get("valor"),
+                    "wind_bearing": current_forecast.get(WIND_DIRECTION, {}).get("valor"),
+                    "condition": get_condition_from_statcel(codi_estatcel, is_night)["condition"],
+                }
+        except Exception as err:
+            _LOGGER.error("Error al actualizar la predicción de Meteocat: %s", err)
+
+    @property
+    def name(self):
+        """Retorna el nombre de la entidad."""
+        return f"Clima {self._coordinator._town_id}"
+
+    @property
+    def temperature(self):
+        """Retorna la temperatura actual."""
+        return self._data.get("temperature")
+
+    @property
+    def humidity(self):
+        """Retorna la humedad relativa actual."""
+        return self._data.get("humidity")
+
+    @property
+    def wind_speed(self):
+        """Retorna la velocidad del viento."""
+        return self._data.get("wind_speed")
+
+    @property
+    def wind_bearing(self):
+        """Retorna la dirección del viento."""
+        return self._data.get("wind_bearing")
+
+    @property
+    def condition(self):
+        """Retorna la condición climática."""
+        return self._data.get("condition")

package/custom_components/meteocat/helpers.py

@@ -1,42 +1,42 @@
-from __future__ import annotations
-
-from datetime import datetime, time
-from homeassistant.helpers import entity_registry
-
-def get_sun_times(hass) -> tuple:
-    """
-    Obtiene las horas de amanecer y atardecer desde la integración sun.
-
-    :param hass: Instancia de Home Assistant.
-    :return: Tupla con las horas de amanecer y atardecer (datetime).
-    """
-    sun_entity = hass.states.get("sun.sun")
-    if sun_entity:
-        sunrise = sun_entity.attributes.get("next_rising")
-        sunset = sun_entity.attributes.get("next_setting")
-        if sunrise and sunset:
-            return (
-                hass.util.dt.as_local(hass.util.dt.parse_datetime(sunrise)),
-                hass.util.dt.as_local(hass.util.dt.parse_datetime(sunset)),
-            )
-    raise ValueError("No se pudo obtener las horas de amanecer y atardecer de sun.sun")
-
-
-def is_night(current_time: datetime, hass) -> bool:
-    """
-    Determina si la hora actual está fuera del rango entre el amanecer y el atardecer.
-
-    :param current_time: Hora actual como objeto datetime.
-    :param hass: Instancia de Home Assistant.
-    :return: True si es de noche, False si es de día.
-    """
-    # Obtener las horas de amanecer y atardecer de la integración sun
-    sunrise, sunset = get_sun_times(hass)
-
-    # Convertimos a objetos time para comparar solo las horas
-    current_time_only = current_time.time()
-    sunrise_time_only = sunrise.time()
-    sunset_time_only = sunset.time()
-
-    # Devuelve True si la hora está fuera del rango del día
-    return current_time_only < sunrise_time_only or current_time_only > sunset_time_only
+from __future__ import annotations
+
+from datetime import datetime, time
+from homeassistant.helpers import entity_registry
+
+def get_sun_times(hass) -> tuple:
+    """
+    Obtiene las horas de amanecer y atardecer desde la integración sun.
+
+    :param hass: Instancia de Home Assistant.
+    :return: Tupla con las horas de amanecer y atardecer (datetime).
+    """
+    sun_entity = hass.states.get("sun.sun")
+    if sun_entity:
+        sunrise = sun_entity.attributes.get("next_rising")
+        sunset = sun_entity.attributes.get("next_setting")
+        if sunrise and sunset:
+            return (
+                hass.util.dt.as_local(hass.util.dt.parse_datetime(sunrise)),
+                hass.util.dt.as_local(hass.util.dt.parse_datetime(sunset)),
+            )
+    raise ValueError("No se pudo obtener las horas de amanecer y atardecer de sun.sun")
+
+
+def is_night(current_time: datetime, hass) -> bool:
+    """
+    Determina si la hora actual está fuera del rango entre el amanecer y el atardecer.
+
+    :param current_time: Hora actual como objeto datetime.
+    :param hass: Instancia de Home Assistant.
+    :return: True si es de noche, False si es de día.
+    """
+    # Obtener las horas de amanecer y atardecer de la integración sun
+    sunrise, sunset = get_sun_times(hass)
+
+    # Convertimos a objetos time para comparar solo las horas
+    current_time_only = current_time.time()
+    sunrise_time_only = sunrise.time()
+    sunset_time_only = sunset.time()
+
+    # Devuelve True si la hora está fuera del rango del día
+    return current_time_only < sunrise_time_only or current_time_only > sunset_time_only