meteocat 0.1.19

package/README.md

@@ -0,0 +1,41 @@
+# Meteocat for Home Assistant
+
+[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
+[![Python version compatibility](https://img.shields.io/pypi/pyversions/meteocat)](https://pypi.org/project/meteocat)
+[![pipeline status](https://gitlab.com/figorr/meteocat/badges/master/pipeline.svg)](https://gitlab.com/figorr/meteocat/commits/master)
+
+
+This is a project to obtain meteorological data from the Meteocat API.
+
+**NOTE:** Meteocat API requires to use an API_KEY, you should ask to (https://apidocs.meteocat.gencat.cat/documentacio/acces-ciutada-i-administracio/)
+
+# Credits
+
+This is a personal project.
+
+Authors:
+- Figorr
+
+# Contributing
+
+1.  [Check for open features/bugs](https://gitlab.com/figorr/meteocat/issues)
+    or [initiate a discussion on one](https://gitlab.com/figorr/meteocat/issues/new).
+2.  [Fork the repository](https://gitlab.com/figorr/meteocat/forks/new).
+3.  Install the dev environment: `make init`.
+4.  Enter the virtual environment: `pipenv shell`
+5.  Code your new feature or bug fix.
+6.  Write a test that covers your new functionality.
+7.  Update `README.md` with any new documentation.
+8.  Run tests and ensure 100% code coverage for your contribution: `make coverage`
+9.  Ensure you have no linting errors: `make lint`
+10. Ensure you have typed your code correctly: `make typing`
+11. Add yourself to `AUTHORS.md`.
+12. Submit a pull request!
+
+# License
+
+[Apache-2.0](LICENSE). By providing a contribution, you agree the contribution is licensed under Apache-2.0.
+
+# API Reference
+
+[See the docs 📚](https://apidocs.meteocat.gencat.cat/section/informacio-general/).

package/custom_components/meteocat/__init__.py

@@ -0,0 +1,139 @@
+from __future__ import annotations
+
+import os
+import logging
+from homeassistant import core
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import HomeAssistantError
+from .coordinator import MeteocatSensorCoordinator, MeteocatEntityCoordinator
+from .const import (
+    DOMAIN,
+    CONF_API_KEY,
+    TOWN_NAME,
+    TOWN_ID,
+    VARIABLE_NAME,
+    VARIABLE_ID,
+    STATION_NAME,
+    STATION_ID,
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+# Versión
+__version__ = "0.1.18"
+
+# Plataformas soportadas por la integración
+PLATFORMS = ["sensor", "entity"]
+
+
+async def async_setup(hass: core.HomeAssistant, config: dict) -> bool:
+    """Configuración inicial del componente Meteocat."""
+    return True
+
+
+async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+    """Configura una entrada de configuración para Meteocat."""
+    _LOGGER.info("Configurando la integración de Meteocat...")
+
+    # Extraer los datos necesarios de la entrada de configuración
+    entry_data = entry.data
+    required_fields = [
+        CONF_API_KEY, TOWN_NAME, TOWN_ID, VARIABLE_ID, STATION_NAME, STATION_ID
+    ]
+
+    # Validar que todos los campos requeridos estén presentes
+    if not all(field in entry_data for field in required_fields):
+        _LOGGER.error("Faltan datos en la configuración. Por favor, reconfigura la integración.")
+        return False
+
+    api_key = entry_data[CONF_API_KEY]
+    town_name = entry_data[TOWN_NAME]
+    town_id = entry_data[TOWN_ID]
+    variable_name = entry_data[VARIABLE_NAME]
+    variable_id = entry_data[VARIABLE_ID]
+    station_name = entry_data[STATION_NAME]
+    station_id = entry_data[STATION_ID]
+
+    _LOGGER.info(
+        f"Integración configurada para el municipio '{town_name}' (ID: {town_id}), "
+        f"variable '{variable_name}' (ID: {variable_id}), estación {station_name} (ID: {station_id})."
+    )
+
+    # Inicializa y refresca los coordinadores
+    try:
+        # Pasar los datos adicionales al constructor del coordinador
+        sensor_coordinator = MeteocatSensorCoordinator(
+            hass,
+            entry,
+            town_name=town_name,
+            town_id=town_id,
+            station_name=station_name,
+            station_id=station_id,
+            variable_name=variable_name,
+            variable_id=variable_id,
+        )
+        # Pasar los mismos datos al constructor de MeteocatEntityCoordinator
+        entity_coordinator = MeteocatEntityCoordinator(
+            hass,
+            entry,
+            town_name=town_name,
+            town_id=town_id,
+            station_name=station_name,
+            station_id=station_id,
+            variable_name=variable_name,
+            variable_id=variable_id,
+        )
+
+        await sensor_coordinator.async_config_entry_first_refresh()
+        await entity_coordinator.async_config_entry_first_refresh()
+    except HomeAssistantError as err:
+        _LOGGER.error(f"Error al inicializar los coordinadores: {err}")
+        return False
+
+    # Guardar los datos y los coordinadores en hass.data
+    hass.data.setdefault(DOMAIN, {})
+    hass.data[DOMAIN][entry.entry_id] = {
+        "sensor_coordinator": sensor_coordinator,
+        "entity_coordinator": entity_coordinator,
+        "api_key": api_key,
+        "town_id": town_id,
+        "town_name": town_name,
+        "station_id": station_id,
+        "station_name": station_name,
+        "variable_id": variable_id,
+        "variable_name": variable_name,
+    }
+
+    # Configurar las plataformas
+    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
+
+    return True
+
+async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+    """Desactiva una entrada de configuración para Meteocat."""
+    if entry.entry_id in hass.data.get(DOMAIN, {}):
+        hass.data[DOMAIN].pop(entry.entry_id, None)
+        if not hass.data[DOMAIN]:  # Si no quedan entradas, elimina el dominio
+            hass.data.pop(DOMAIN)
+
+    # Desinstalar las plataformas
+    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
+
+
+async def async_remove_entry(hass: HomeAssistant, entry: ConfigEntry) -> None:
+    """Limpia cualquier dato adicional al desinstalar la integración."""
+    _LOGGER.info(f"Eliminando datos residuales de la integración: {entry.entry_id}")
+
+    # Definir la ruta del archivo de símbolos
+    assets_folder = hass.config.path("custom_components", DOMAIN, "assets")
+    symbols_file = os.path.join(assets_folder, "symbols.json")
+
+    try:
+        if os.path.exists(symbols_file):
+            os.remove(symbols_file)
+            _LOGGER.info("Archivo symbols.json eliminado correctamente.")
+        else:
+            _LOGGER.info("El archivo symbols.json no se encontró.")
+    except OSError as e:
+        _LOGGER.error(f"Error al intentar eliminar el archivo symbols.json: {e}")

package/custom_components/meteocat/condition.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from datetime import datetime
+from .const import CONDITION_MAPPING
+from .helpers import is_night  # Importar la función is_night de helpers.py
+
+def get_condition_from_statcel(codi_estatcel, current_time: datetime, hass) -> dict:
+    """
+    Convierte el código 'estatCel' en condición de Home Assistant.
+
+    :param codi_estatcel: Código del estado del cielo (celestial state code).
+    :param current_time: Fecha y hora actual (datetime).
+    :param hass: Instancia de Home Assistant.
+    :return: Diccionario con la condición y el icono.
+    """
+    # Determinar si es de noche usando la lógica centralizada en helpers.py
+    is_night_flag = is_night(current_time, hass)
+
+    # Identificar la condición basada en el código
+    for condition, codes in CONDITION_MAPPING.items():
+        if codi_estatcel in codes:
+            # Ajustar para condiciones nocturnas si aplica
+            if condition == "sunny" and is_night_flag:
+                return {"condition": "clear-night", "icon": None}
+            return {"condition": condition, "icon": None}
+
+    # Si no coincide ningún código, devolver condición desconocida
+    return {"condition": "unknown", "icon": None}

package/custom_components/meteocat/config_flow.py

@@ -0,0 +1,192 @@
+from __future__ import annotations
+
+import json
+import logging
+from pathlib import Path
+from typing import Any
+
+import voluptuous as vol
+from aiohttp import ClientError
+import aiofiles
+
+from homeassistant.config_entries import ConfigEntry, ConfigFlow, ConfigFlowResult
+from homeassistant.core import callback
+from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers import aiohttp_client, config_validation as cv
+
+from .const import (
+    DOMAIN,
+    CONF_API_KEY,
+    TOWN_NAME,
+    TOWN_ID,
+    VARIABLE_NAME,
+    VARIABLE_ID,
+    STATION_NAME,
+    STATION_ID
+)
+    
+from .options_flow import MeteocatOptionsFlowHandler
+from meteocatpy.town import MeteocatTown
+from meteocatpy.symbols import MeteocatSymbols
+from meteocatpy.variables import MeteocatVariables
+from meteocatpy.townstations import MeteocatTownStations
+from meteocatpy.exceptions import BadRequestError, ForbiddenError, TooManyRequestsError, InternalServerError, UnknownAPIError
+
+_LOGGER = logging.getLogger(__name__)
+
+class MeteocatConfigFlow(ConfigFlow, domain=DOMAIN):
+    """Flujo de configuración para Meteocat."""
+
+    VERSION = 1
+
+    def __init__(self):
+        self.api_key: str | None = None
+        self.municipis: list[dict[str, Any]] = []
+        self.selected_municipi: dict[str, Any] | None = None
+        self.variable_id: str | None = None
+        self.station_id: str | None = None
+        self.station_name: str | None = None
+
+    async def async_step_user(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Primer paso: Solicitar la API Key."""
+        errors = {}
+
+        if user_input is not None:
+            self.api_key = user_input[CONF_API_KEY]
+
+            town_client = MeteocatTown(self.api_key)
+
+            try:
+                self.municipis = await town_client.get_municipis()
+            except (BadRequestError, ForbiddenError, TooManyRequestsError, InternalServerError, UnknownAPIError) as ex:
+                _LOGGER.error("Error al conectar con la API de Meteocat: %s", ex)
+                errors["base"] = "cannot_connect"
+            except Exception as ex:
+                _LOGGER.error("Error inesperado al validar la API Key: %s", ex)
+                errors["base"] = "unknown"
+
+            if not errors:
+                return await self.async_step_select_municipi()
+
+        schema = vol.Schema({vol.Required(CONF_API_KEY): str})
+        return self.async_show_form(step_id="user", data_schema=schema, errors=errors)
+
+    async def async_step_select_municipi(self, user_input: dict[str, Any] | None = None) -> ConfigFlowResult:
+        """Segundo paso: Seleccionar el municipio."""
+        errors = {}
+
+        if user_input is not None:
+            selected_codi = user_input["municipi"]
+            self.selected_municipi = next(
+                (m for m in self.municipis if m["codi"] == selected_codi), None
+            )
+
+            if self.selected_municipi:
+                await self.fetch_symbols_and_variables()
+
+        if not errors and self.selected_municipi:
+            return await self.async_step_select_station()
+
+        schema = vol.Schema(
+            {vol.Required("municipi"): vol.In({m["codi"]: m["nom"] for m in self.municipis})}
+        )
+
+        return self.async_show_form(step_id="select_municipi", data_schema=schema, errors=errors)
+
+    async def fetch_symbols_and_variables(self):
+        """Descarga los símbolos y las variables después de seleccionar el municipio."""
+
+        errors = {}
+
+        # Descargar y guardar los símbolos
+        assets_dir = Path(__file__).parent / "assets"
+        assets_dir.mkdir(parents=True, exist_ok=True)
+        symbols_file = assets_dir / "symbols.json"
+        symbols_client = MeteocatSymbols(self.api_key)
+
+        try:
+            symbols_data = await symbols_client.fetch_symbols()
+            async with aiofiles.open(symbols_file, "w", encoding="utf-8") as file:
+                await file.write(json.dumps({"symbols": symbols_data}, ensure_ascii=False, indent=4))
+        except (BadRequestError, ForbiddenError, TooManyRequestsError, InternalServerError, UnknownAPIError) as ex:
+            _LOGGER.error("Error al descargar o guardar los símbolos: %s", ex)
+            errors["base"] = "symbols_download_failed"
+
+        if not errors:
+            variables_client = MeteocatVariables(self.api_key)
+            try:
+                variables_data = await variables_client.get_variables()
+                self.variable_id = next(
+                    (v["codi"] for v in variables_data if v["nom"].lower() == "temperatura"), None
+                )
+                if not self.variable_id:
+                    _LOGGER.error("No se encontró la variable 'Temperatura'")
+                    errors["base"] = "variable_not_found"
+            except (BadRequestError, ForbiddenError, TooManyRequestsError, InternalServerError, UnknownAPIError) as ex:
+                _LOGGER.error("Error al obtener las variables: %s", ex)
+                errors["base"] = "variables_fetch_failed"
+
+        if errors:
+            raise HomeAssistantError(errors)
+
+    async def async_step_select_station(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Tercer paso: Seleccionar la estación para la variable seleccionada."""
+        errors = {}
+
+        townstations_client = MeteocatTownStations(self.api_key)
+        try:
+            stations_data = await townstations_client.get_town_stations(
+                self.selected_municipi["codi"], self.variable_id
+            )
+        except Exception as ex:
+            _LOGGER.error("Error al obtener las estaciones: %s", ex)
+            errors["base"] = "stations_fetch_failed"
+            stations_data = []
+
+        if user_input is not None:
+            selected_station_codi = user_input["station"]
+            selected_station = next(
+                (station for station in stations_data[0]["variables"][0]["estacions"] if station["codi"] == selected_station_codi),
+                None
+            )
+
+            if selected_station:
+                self.station_id = selected_station["codi"]
+                self.station_name = selected_station["nom"]
+
+                return self.async_create_entry(
+                    title=self.selected_municipi["nom"],
+                    data={
+                        CONF_API_KEY: self.api_key,
+                        TOWN_NAME: self.selected_municipi["nom"],
+                        TOWN_ID: self.selected_municipi["codi"],
+                        VARIABLE_NAME: "Temperatura",
+                        VARIABLE_ID: str(self.variable_id),
+                        STATION_NAME: self.station_name,
+                        STATION_ID: self.station_id
+                    },
+                )
+            else:
+                errors["base"] = "station_not_found"
+
+        schema = vol.Schema(
+            {
+                vol.Required("station"): vol.In(
+                    {station["codi"]: station["nom"] for station in stations_data[0]["variables"][0]["estacions"]}
+                )
+            }
+        )
+
+        return self.async_show_form(
+            step_id="select_station", data_schema=schema, errors=errors
+        )
+
+    @staticmethod
+    @callback
+    def async_get_options_flow(config_entry: ConfigEntry) -> MeteocatOptionsFlowHandler:
+        """Devuelve el flujo de opciones para esta configuración."""
+        return MeteocatOptionsFlowHandler(config_entry)

package/custom_components/meteocat/const.py

@@ -0,0 +1,46 @@
+# Constantes generales
+DOMAIN = "meteocat"
+BASE_URL = "https://api.meteo.cat"
+CONF_API_KEY = "api_key"
+TOWN_NAME = "town_name"
+TOWN_ID = "town_id"
+VARIABLE_NAME = "variable_name"
+VARIABLE_ID = "variable_id"
+STATION_NAME = "station_name"
+STATION_ID = "station_id"
+
+# Códigos de sensores de la API
+WIND_SPEED = "30"  # Velocidad del viento
+WIND_DIRECTION = "31"  # Dirección del viento
+TEMPERATURE = "32"  # Temperatura
+HUMIDITY = "33"  # Humedad relativa
+PRESSURE = "34"  # Presión atmosférica
+PRECIPITATION = "35"  # Precipitación
+UV_INDEX = "39"  # UV
+MAX_TEMPERATURE = "40"  # Temperatura máxima
+MIN_TEMPERATURE = "42"  # Temperatura mínima
+WIND_GUST = "50"  # Racha de viento
+
+# Unidades de medida de los sensores
+WIND_SPEED_UNIT = "m/s"
+WIND_DIRECTION_UNIT = "°"
+TEMPERATURE_UNIT = "°C"
+HUMIDITY_UNIT = "%"
+PRESSURE_UNIT = "hPa"
+PRECIPITATION_UNIT = "mm"
+UV_INDEX_UNIT = "UV"
+
+# Mapeo de códigos 'estatCel' a condiciones de Home Assistant
+CONDITION_MAPPING = {
+    "sunny": [1],
+    "clear-night": [1],
+    "partlycloudy": [2, 3],
+    "cloudy": [4, 20, 21, 22],
+    "rainy": [5, 6, 23],
+    "pouring": [7, 8, 25],
+    "lightning-rainy": [8, 24],
+    "hail": [9],
+    "snowy": [10, 26, 27, 28],
+    "fog": [11, 12],
+    "snow-rainy": [27, 29, 30],
+}

package/custom_components/meteocat/coordinator.py

@@ -0,0 +1,177 @@
+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,
+        api_key: str,
+        town_name: str,
+        town_id: str,
+        station_name: str,
+        station_id: str,
+        variable_name: str,
+        variable_id: str,
+        update_interval: timedelta = DEFAULT_SENSOR_UPDATE_INTERVAL,
+    ):
+        """Inicializa el coordinador de sensores de Meteocat."""
+        self.api_key = api_key
+        self.town_name = town_name
+        self.town_id = town_id
+        self.station_name = station_name
+        self.station_id = station_id
+        self.variable_name = variable_name
+        self.variable_id = variable_id
+        self.meteocat_station_data = MeteocatStationData(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.
+
+        Returns:
+            dict: Datos actualizados de los sensores.
+        """
+        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,
+        api_key: str,
+        town_name: str,
+        town_id: str,
+        station_name: str,
+        station_id: str,
+        variable_name: str,
+        variable_id: str,
+        update_interval: timedelta = DEFAULT_ENTITY_UPDATE_INTERVAL,
+    ):
+        """Inicializa el coordinador de datos para entidades de predicción."""
+        self.api_key = api_key
+        self.town_name = town_name
+        self.town_id = town_id
+        self.station_name = station_name
+        self.station_id = station_id
+        self.variable_name = variable_name
+        self.variable_id = variable_id
+        self.meteocat_forecast = MeteocatForecast(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.
+
+        Returns:
+            dict: Datos actualizados de predicción horaria y diaria.
+        """
+        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