meteocat 0.1.19

package/custom_components/meteocat/entity.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+from homeassistant.components.weather import WeatherEntity
+from homeassistant.const import TEMP_CELSIUS, TEMP_FAHRENHEIT
+
+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 = TEMP_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

@@ -0,0 +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

package/custom_components/meteocat/manifest.json

@@ -0,0 +1,12 @@
+{
+    "domain": "meteocat",
+    "name": "Meteocat",
+    "codeowners": ["@figorr"],
+    "config_flow": true,
+    "dependencies": ["persistent_notification", "http"],
+    "iot_class": "cloud_polling",
+    "documentation": "https://gitlab.com/figorr/meteocat",
+    "loggers": ["meteocatpy"],
+    "requirements": ["meteocatpy==0.0.6", "packaging>=20.3", "wrapt>=1.14.0"],
+    "version": "0.1.18"
+}

package/custom_components/meteocat/options_flow.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+import logging
+from homeassistant.config_entries import ConfigEntry, OptionsFlow
+from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers import config_validation as cv
+import voluptuous as vol
+
+from .const import (
+    CONF_API_KEY
+)
+from meteocatpy.town import MeteocatTown
+from meteocatpy.exceptions import (
+    BadRequestError,
+    ForbiddenError,
+    TooManyRequestsError,
+    InternalServerError,
+    UnknownAPIError,
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+class MeteocatOptionsFlowHandler(OptionsFlow):
+    """Manejo del flujo de opciones para Meteocat."""
+
+    def __init__(self, config_entry: ConfigEntry):
+        """Inicializa el flujo de opciones."""
+        self.config_entry = config_entry
+        self.api_key: str | None = None
+
+    async def async_step_init(self, user_input: dict | None = None):
+        """Paso inicial del flujo de opciones."""
+        return await self.async_step_update_api_key()
+
+    async def async_step_update_api_key(self, user_input: dict | None = None):
+        """Permite al usuario actualizar la API Key."""
+        errors = {}
+
+        if user_input is not None:
+            self.api_key = user_input[CONF_API_KEY]
+
+            # Validar la nueva API Key utilizando MeteocatTown
+            town_client = MeteocatTown(self.api_key)
+
+            try:
+                await town_client.get_municipis()  # Verificar que la API Key sea válida
+            except (
+                BadRequestError,
+                ForbiddenError,
+                TooManyRequestsError,
+                InternalServerError,
+                UnknownAPIError,
+            ) as ex:
+                _LOGGER.error("Error al validar la nueva API Key: %s", ex)
+                errors["base"] = "cannot_connect"
+            except Exception as ex:
+                _LOGGER.error("Error inesperado al validar la nueva API Key: %s", ex)
+                errors["base"] = "unknown"
+
+            if not errors:
+                # Actualizar la configuración de la entrada con la nueva API Key
+                self.hass.config_entries.async_update_entry(
+                    self.config_entry,
+                    data={**self.config_entry.data, CONF_API_KEY: self.api_key},
+                )
+                return self.async_create_entry(title="", data={})
+
+        schema = vol.Schema({vol.Required(CONF_API_KEY): str})
+        return self.async_show_form(
+            step_id="update_api_key", data_schema=schema, errors=errors
+        )

package/custom_components/meteocat/sensor.py

@@ -0,0 +1,190 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from homeassistant.helpers.entity import DeviceInfo
+from homeassistant.components.sensor import (
+    SensorDeviceClass,
+    SensorEntity,
+    SensorEntityDescription,
+    SensorStateClass,
+)
+from homeassistant.core import callback
+from homeassistant.helpers.entity_platform import AddEntitiesCallback
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
+from homeassistant.const import PERCENTAGE, UnitOfTemperature
+
+from .const import (
+    DOMAIN,
+    WIND_SPEED,
+    WIND_DIRECTION,
+    TEMPERATURE,
+    HUMIDITY,
+    PRESSURE,
+    PRECIPITATION,
+    UV_INDEX,
+    MAX_TEMPERATURE,
+    MIN_TEMPERATURE,
+    WIND_GUST,
+    WIND_SPEED_UNIT,
+    PRESSURE_UNIT,
+    PRECIPITATION_UNIT,
+    UV_INDEX_UNIT,
+    WIND_DIRECTION_UNIT,
+)
+
+from .coordinator import MeteocatSensorCoordinator
+
+
+@dataclass
+class MeteocatSensorEntityDescription(SensorEntityDescription):
+    """A class that describes Meteocat sensor entities."""
+
+
+SENSOR_TYPES: tuple[MeteocatSensorEntityDescription, ...] = (
+    MeteocatSensorEntityDescription(
+        key=WIND_SPEED,
+        name="Wind Speed",
+        icon="mdi:weather-windy",
+        device_class=SensorDeviceClass.WIND_SPEED,
+        state_class=SensorStateClass.MEASUREMENT,
+        native_unit_of_measurement=WIND_SPEED_UNIT,
+    ),
+    MeteocatSensorEntityDescription(
+        key=WIND_DIRECTION,
+        name="Wind Direction",
+        icon="mdi:compass",
+        device_class=None,
+        native_unit_of_measurement=WIND_DIRECTION_UNIT,
+    ),
+    MeteocatSensorEntityDescription(
+        key=TEMPERATURE,
+        name="Temperature",
+        icon="mdi:thermometer",
+        device_class=SensorDeviceClass.TEMPERATURE,
+        state_class=SensorStateClass.MEASUREMENT,
+        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
+    ),
+    MeteocatSensorEntityDescription(
+        key=HUMIDITY,
+        name="Humidity",
+        icon="mdi:water-percent",
+        device_class=SensorDeviceClass.HUMIDITY,
+        state_class=SensorStateClass.MEASUREMENT,
+        native_unit_of_measurement=PERCENTAGE,
+    ),
+    MeteocatSensorEntityDescription(
+        key=PRESSURE,
+        name="Pressure",
+        icon="mdi:gauge",
+        device_class=SensorDeviceClass.ATMOSPHERIC_PRESSURE,
+        state_class=SensorStateClass.MEASUREMENT,
+        native_unit_of_measurement=PRESSURE_UNIT,
+    ),
+    MeteocatSensorEntityDescription(
+        key=PRECIPITATION,
+        name="Precipitation",
+        icon="mdi:weather-rainy",
+        device_class=None,
+        state_class=SensorStateClass.MEASUREMENT,
+        native_unit_of_measurement=PRECIPITATION_UNIT,
+    ),
+    MeteocatSensorEntityDescription(
+        key=UV_INDEX,
+        name="UV Index",
+        icon="mdi:sun",
+        state_class=SensorStateClass.MEASUREMENT,
+        native_unit_of_measurement=UV_INDEX_UNIT,
+    ),
+    MeteocatSensorEntityDescription(
+        key=MAX_TEMPERATURE,
+        name="Max Temperature",
+        icon="mdi:thermometer-plus",
+        device_class=SensorDeviceClass.TEMPERATURE,
+        state_class=SensorStateClass.MEASUREMENT,
+        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
+    ),
+    MeteocatSensorEntityDescription(
+        key=MIN_TEMPERATURE,
+        name="Min Temperature",
+        icon="mdi:thermometer-minus",
+        device_class=SensorDeviceClass.TEMPERATURE,
+        state_class=SensorStateClass.MEASUREMENT,
+        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
+    ),
+    MeteocatSensorEntityDescription(
+        key=WIND_GUST,
+        name="Wind Gust",
+        icon="mdi:weather-windy",
+        device_class=SensorDeviceClass.WIND_SPEED,
+        state_class=SensorStateClass.MEASUREMENT,
+        native_unit_of_measurement=WIND_SPEED_UNIT,
+    ),
+)
+
+
+@callback
+async def async_setup_entry(hass, entry, async_add_entities: AddEntitiesCallback) -> None:
+    """Set up Meteocat sensors from a config entry."""
+    entry_data = hass.data[DOMAIN][entry.entry_id]
+    coordinator = entry_data["sensor_coordinator"]
+
+    async_add_entities(
+        MeteocatSensor(coordinator, description, entry_data)
+        for description in SENSOR_TYPES
+    )
+
+
+class MeteocatSensor(CoordinatorEntity[MeteocatSensorCoordinator], SensorEntity):
+    """Representation of a Meteocat sensor."""
+
+    def __init__(self, coordinator, description, entry_data):
+        """Initialize the sensor."""
+        super().__init__(coordinator)
+        self.entity_description = description
+        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._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._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
+
+        # Unique ID for the entity
+        self._attr_unique_id = f"{self._town_id}_{self.entity_description.key}"
+
+    @property
+    def native_value(self):
+        """Return the state of the sensor."""
+        value = getattr(self.coordinator.data, self.entity_description.key, None)
+
+        if self.entity_description.key == WIND_DIRECTION:
+            return self._convert_degrees_to_cardinal(value)
+
+        return value
+
+    @staticmethod
+    def _convert_degrees_to_cardinal(degree: float | None) -> str | None:
+        """Convert degrees to cardinal direction."""
+        if degree is None:
+            return None
+        directions = [
+            "N", "NNE", "NE", "ENE", "E", "ESE", "SE", "SSE",
+            "S", "SSW", "SW", "WSW", "W", "WNW", "NW", "NNW", "N",
+        ]
+        index = int(((degree + 11.25) / 22.5)) % 16
+        return directions[index]
+
+    @property
+    def device_info(self) -> DeviceInfo:
+        """Return the device info."""
+        return DeviceInfo(
+            identifiers={(DOMAIN, self._town_id)},
+            name=self._town_name,
+            manufacturer="Meteocat",
+            model="Meteocat API",
+            additional_properties={
+                "Town ID": self._town_id,
+                "Station Name": self._station_name,
+                "Station ID": self._station_id,
+            },
+        )

package/custom_components/meteocat/strings.json

@@ -0,0 +1,26 @@
+{
+    "config": {
+      "step": {
+        "user": {
+          "description": "Enter your Meteocat API Key to validate it.",
+          "title": "API Key"
+        },
+        "select_municipi": {
+          "description": "Select a municipality from the list.",
+          "title": "Municipality Selection"
+        },
+        "select_station": {
+          "description": "Select a station.",
+          "title": "Station Selection"
+        }
+      },
+      "error": {
+        "bad_request": "Invalid request. Please check your API Key.",
+        "forbidden": "Access denied. Check your API Key permissions.",
+        "rate_limit_exceeded": "Rate limit exceeded. Please try again later.",
+        "server_error": "Server error. Please try again later.",
+        "connection_error": "Connection error. Please check your network.",
+        "unknown_error": "An unknown error occurred."
+      }
+    }
+  }    

package/custom_components/meteocat/translations/ca.json

@@ -0,0 +1,26 @@
+{
+  "config": {
+    "step": {
+      "user": {
+        "description": "Introduïu la API Key subministrada per Meteocat per poder iniciar el procés de validació.",
+        "title": "API Key"
+      },
+      "select_municipi": {
+        "description": "Seleccioneu el municipi de la llista.",
+        "title": "Selecció de municipi"
+      },
+      "select_station": {
+        "description": "Seleccioneu l'estació de la llista.",
+        "title": "Selecció d'estació"
+      }
+    },
+    "error": {
+      "bad_request": "Petició no vàlida. Reviseu la vostra API Key.",
+      "forbidden": "Accés denegat. Reviseu els permisos de la vostra API Key.",
+      "rate_limit_exceeded": "Excés del límit de peticions. Si us plau, torneu-ho a provar més tard.",
+      "server_error": "Error del servidor. Torneu-ho a provar més tard.",
+      "connection_error": "Error de connexió. Reviseu la vostra connexió de xarxa.",
+      "unknown_error": "Error desconegut."
+    }
+  }
+}    

package/custom_components/meteocat/translations/en.json

@@ -0,0 +1,26 @@
+{
+  "config": {
+    "step": {
+      "user": {
+        "description": "Enter your Meteocat API Key to validate it.",
+        "title": "API Key"
+      },
+      "select_municipi": {
+        "description": "Select a municipality from the list.",
+        "title": "Municipality Selection"
+      },
+      "select_station": {
+        "description": "Select a station.",
+        "title": "Station Selection"
+      }
+    },
+    "error": {
+      "bad_request": "Invalid request. Please check your API Key.",
+      "forbidden": "Access denied. Check your API Key permissions.",
+      "rate_limit_exceeded": "Rate limit exceeded. Please try again later.",
+      "server_error": "Server error. Please try again later.",
+      "connection_error": "Connection error. Please check your network.",
+      "unknown_error": "An unknown error occurred."
+    }
+  }
+}    

package/custom_components/meteocat/translations/es.json

@@ -0,0 +1,26 @@
+{
+  "config": {
+    "step": {
+      "user": {
+        "description": "Ingrese la API Key facilitada por Meteocat para poder iniciar el proceso de validación.",
+        "title": "API Key"
+      },
+      "select_municipi": {
+        "description": "Seleccione el municipio de la lista.",
+        "title": "Selección de municipio"
+      },
+      "select_station": {
+        "description": "Seleccione la estación de la lista.",
+        "title": "Selección de estación"
+      }
+    },
+    "error": {
+      "bad_request": "Petición no válida. Revise su API Key.",
+      "forbidden": "Acceso denegado. Revise los permisos de su API Key.",
+      "rate_limit_exceeded": "Exceso del límite de peticiones. Por favor, inténtelo de nuevo más tarde.",
+      "server_error": "Error del servidor. Inténtelo de nuevo más tarde.",
+      "connection_error": "Error de conexión. Revise su conexión de red.",
+      "unknown_error": "Error desconocido."
+    }
+  }
+}    

package/custom_components/meteocat/version.py

@@ -0,0 +1,2 @@
+# version.py
+__version__ = "0.1.18"

package/filetree.py

@@ -0,0 +1,48 @@
+import subprocess
+import os
+
+def generate_file_tree():
+    # Ruta donde se generará el archivo
+    output_file = 'filetree.txt'
+
+    # Ejecutar el comando git ls-files para obtener los archivos no ignorados
+    git_command = ['git', 'ls-files']
+    try:
+        # Captura de la salida del comando git
+        git_files = subprocess.check_output(git_command).decode('utf-8').splitlines()
+
+        # Crear una estructura de árbol
+        tree = {}
+
+        # Construir el árbol de directorios
+        for file in git_files:
+            parts = file.split('/')  # Separar la ruta del archivo por '/'
+            current = tree
+            for part in parts[:-1]:  # Recorremos todos los directorios
+                current = current.setdefault(part, {})
+            current[parts[-1]] = None  # El archivo final se marca como 'None'
+        
+        # Función recursiva para imprimir el árbol con la indentación correcta
+        def print_tree(directory, indent=""):
+            for name, subdirectory in directory.items():
+                if subdirectory is None:
+                    # Si es un archivo, lo imprimimos
+                    f.write(f"{indent}├── {name}\n")
+                else:
+                    # Si es un directorio, lo imprimimos y recursivamente llamamos a print_tree
+                    f.write(f"{indent}└── {name}/\n")
+                    print_tree(subdirectory, indent + "    ")
+
+        # Crear el archivo y escribir la estructura del árbol con codificación UTF-8
+        with open(output_file, 'w', encoding='utf-8') as f:
+            print_tree(tree)
+
+        print(f"Árbol de directorios generado en: {os.path.abspath(output_file)}")
+
+    except subprocess.CalledProcessError as e:
+        print(f"Error al ejecutar el comando: {e}")
+    except Exception as e:
+        print(f"Ocurrió un error inesperado: {e}")
+
+if __name__ == "__main__":
+    generate_file_tree()

package/filetree.txt

@@ -0,0 +1,43 @@
+└── .github/
+    └── workflows/
+        ├── release.yml
+├── .gitignore
+├── .gitlab-ci.yml
+├── .pre-commit-config.yaml
+├── .releaserc.toml
+├── AUTHORS.md
+├── CHANGELOG.md
+├── LICENSE
+├── README.md
+└── custom_components/
+    └── meteocat/
+        ├── __init__.py
+        ├── condition.py
+        ├── config_flow.py
+        ├── const.py
+        ├── coordinator.py
+        ├── entity.py
+        ├── helpers.py
+        ├── manifest.json
+        ├── options_flow.py
+        ├── sensor.py
+        ├── strings.json
+        └── translations/
+            ├── ca.json
+            ├── en.json
+            ├── es.json
+        ├── version.py
+├── filetree.py
+├── filetree.txt
+├── hacs.json
+├── package-lock.json
+├── poetry.lock
+├── pyproject.toml
+├── requirements.test.txt
+├── setup.cfg
+├── setup.py
+└── tests/
+    ├── __init__.py
+    ├── bandit.yaml
+    ├── conftest.py
+    ├── test_init.py

package/hacs.json

@@ -0,0 +1,6 @@
+{
+  "name": "Meteocat",
+  "render_readme": true,
+  "iot_class": "cloud_polling"
+}
+  

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "meteocat",
+  "version": "0.1.19",
+  "description": "[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)\r [![Python version compatibility](https://img.shields.io/pypi/pyversions/meteocat)](https://pypi.org/project/meteocat)\r [![pipeline status](https://gitlab.com/figorr/meteocat/badges/master/pipeline.svg)](https://gitlab.com/figorr/meteocat/commits/master)",
+  "main": "index.js",
+  "directories": {
+    "test": "tests"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/exec": "^6.0.3",
+    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/github": "^11.0.1",
+    "semantic-release": "^24.2.0"
+  }
+}