meteocat 0.1.35 → 0.1.36

package/CHANGELOG.md

@@ -1,3 +1,20 @@
+## [0.1.36](https://github.com/figorr/meteocat/compare/v0.1.35...v0.1.36) (2024-12-17)
+
+
+### Bug Fixes
+
+* 0.1.36 ([73da4ed](https://github.com/figorr/meteocat/commit/73da4ed7c598a150528294e89c93407e33abfd24))
+* add hour attribute to UVI sensor ([a365626](https://github.com/figorr/meteocat/commit/a365626aa2bb585ca9a835afcec6cea99e85a4bd))
+* add hour attribute translation ([d50f8bb](https://github.com/figorr/meteocat/commit/d50f8bbbcb3c8867dedcbe51f065951f5dfab817))
+* fix self. _config.entry from deprecated self. config.entry ([ed4bfeb](https://github.com/figorr/meteocat/commit/ed4bfebf0ea45bc63de000a21f6063a0cb9e499a))
+* ignore uvi test ([cf35867](https://github.com/figorr/meteocat/commit/cf358675b1afce3e1ea1650414a22c2372af4b49))
+* set coordinators to uvi sensor ([38288cc](https://github.com/figorr/meteocat/commit/38288cc75a30a1ad77a492dcb2b15592379e774f))
+* set uvi coordinators ([1ea0432](https://github.com/figorr/meteocat/commit/1ea0432d6749cac96d45e52d3cf18e7a83e59739))
+* update devs ([9274984](https://github.com/figorr/meteocat/commit/9274984154facd81bdeaf0e0050c870a08996b10))
+* update devs ([44d7699](https://github.com/figorr/meteocat/commit/44d7699c4d3bde13f6145a5380eafc5c77818c45))
+* use cached data when API failed ([f31bd10](https://github.com/figorr/meteocat/commit/f31bd10539e77f7d3e12bc27b3bf88cc9ab317d2))
+* uvi sensor ([ee0b194](https://github.com/figorr/meteocat/commit/ee0b19461bdfacc26d493f9af0e27729e45ae545))
+
 ## [0.1.35](https://github.com/figorr/meteocat/compare/v0.1.34...v0.1.35) (2024-12-14)
 
 

package/custom_components/meteocat/__init__.py

@@ -8,13 +8,19 @@ from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.entity_platform import async_get_platforms
 
-from .coordinator import MeteocatSensorCoordinator  # , MeteocatEntityCoordinator
+from .coordinator import (
+    MeteocatSensorCoordinator,
+    # MeteocatEntityCoordinator,
+    MeteocatUviCoordinator,
+    MeteocatUviFileCoordinator,
+)
+
 from .const import DOMAIN, PLATFORMS
 
 _LOGGER = logging.getLogger(__name__)
 
 # Versión
-__version__ = "0.1.35"
+__version__ = "0.1.36"
 
 def safe_remove(path: Path, is_folder: bool = False):
     """Elimina de forma segura un archivo o carpeta si existe."""
@@ -62,6 +68,13 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
 
         # entity_coordinator = MeteocatEntityCoordinator(hass=hass, entry_data=entry_data)
         # await entity_coordinator.async_config_entry_first_refresh()
+
+        uvi_coordinator = MeteocatUviCoordinator(hass=hass, entry_data=entry_data)
+        await uvi_coordinator.async_config_entry_first_refresh()
+
+        uvi_file_coordinator = MeteocatUviFileCoordinator(hass=hass, entry_data=entry_data)
+        await uvi_file_coordinator.async_config_entry_first_refresh()
+
     except Exception as err:  # Capturar todos los errores
         _LOGGER.exception(f"Error al inicializar los coordinadores: {err}")
         return False
@@ -71,6 +84,8 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     hass.data[DOMAIN][entry.entry_id] = {
         "sensor_coordinator": sensor_coordinator,
         # "entity_coordinator": entity_coordinator,
+        "uvi_coordinator":  uvi_coordinator,
+        "uvi_file_coordinator": uvi_file_coordinator,
         **entry_data,
     }
 
@@ -114,6 +129,15 @@ async def async_remove_entry(hass: HomeAssistant, entry: ConfigEntry) -> None:
     # Archivo JSON de la estación
     station_data_file = files_folder / f"station_{station_id.lower()}_data.json"
 
+    # Obtener el `town_id` para identificar el archivo a eliminar
+    town_id = entry.data.get("town_id")
+    if not town_id:
+        _LOGGER.warning("No se encontró 'town_id' en la configuración. No se puede eliminar el archivo de datos de la estación.")
+        return
+
+    # Archivo JSON UVI del municipio
+    town_data_file = files_folder / f"uvi_{town_id.lower()}_data.json"
+
     # Validar la ruta base
     if not custom_components_path.exists():
         _LOGGER.warning(f"La ruta {custom_components_path} no existe. No se realizará la limpieza.")
@@ -123,5 +147,6 @@ async def async_remove_entry(hass: HomeAssistant, entry: ConfigEntry) -> None:
     safe_remove(symbols_file)
     safe_remove(variables_file)
     safe_remove(station_data_file)
+    safe_remove(town_data_file)
     safe_remove(assets_folder, is_folder=True)
     safe_remove(files_folder, is_folder=True)

package/custom_components/meteocat/coordinator.py

@@ -5,7 +5,7 @@ import json
 import aiofiles
 import logging
 import asyncio
-from datetime import timedelta
+from datetime import datetime, timedelta
 from typing import Dict, Any
 
 from homeassistant.core import HomeAssistant
@@ -13,7 +13,9 @@ from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
 from homeassistant.exceptions import ConfigEntryNotReady
 
 from meteocatpy.data import MeteocatStationData
+from meteocatpy.uvi import MeteocatUviData
 # from meteocatpy.forecast import MeteocatForecast
+
 from meteocatpy.exceptions import (
     BadRequestError,
     ForbiddenError,
@@ -28,10 +30,14 @@ _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)
+DEFAULT_ENTITY_UPDATE_INTERVAL = timedelta(hours=48)
+DEFAULT_HOURLY_FORECAST_UPDATE_INTERVAL = timedelta(hours=24)
+DEFAULT_DAYLY_FORECAST_UPDATE_INTERVAL = timedelta(hours=48)
+DEFAULT_UVI_UPDATE_INTERVAL = timedelta(hours=48)
+DEFAULT_UVI_SENSOR_UPDATE_INTERVAL = timedelta(minutes=5)
 
 async def save_json_to_file(data: dict, output_file: str) -> None:
-    """Save the JSON data to a file asynchronously."""
+    """Guarda datos JSON en un archivo de forma asíncrona."""
     try:
         # Crea el directorio si no existe
         os.makedirs(os.path.dirname(output_file), exist_ok=True)
@@ -40,7 +46,17 @@ async def save_json_to_file(data: dict, output_file: str) -> None:
         async with aiofiles.open(output_file, mode="w", encoding="utf-8") as f:
             await f.write(json.dumps(data, indent=4, ensure_ascii=False))
     except Exception as e:
-        raise RuntimeError(f"Error saving JSON to {output_file}: {e}")
+        raise RuntimeError(f"Error guardando JSON to {output_file}: {e}")
+
+def load_json_from_file(input_file: str) -> dict | list | None:
+    """Carga datos JSON desde un archivo de forma síncrona."""
+    try:
+        if os.path.exists(input_file):
+            with open(input_file, "r", encoding="utf-8") as f:
+                return json.load(f)
+    except Exception as e:
+        _LOGGER.error(f"Error cargando JSON desde {input_file}: {e}")
+    return None
 
 class MeteocatSensorCoordinator(DataUpdateCoordinator):
     """Coordinator para manejar la actualización de datos de los sensores."""
@@ -132,12 +148,218 @@ class MeteocatSensorCoordinator(DataUpdateCoordinator):
             )
             raise
         except Exception as err:
-            _LOGGER.exception(
-                "Error inesperado al obtener datos de sensores (Station ID: %s): %s",
-                self.station_id,
+            if isinstance(err, ConfigEntryNotReady):
+                # El dispositivo no pudo inicializarse por primera vez
+                _LOGGER.exception(
+                    "No se pudo inicializar el dispositivo (Station ID: %s) debido a un error: %s",
+                    self.station_id,
+                    err,
+                )
+                raise  # Re-raise the exception to indicate a fundamental failure in initialization
+            else:
+                # Manejar error durante la actualización de datos
+                _LOGGER.exception(
+                    "Error inesperado al obtener datos de los sensores para (Station ID: %s): %s",
+                    self.station_id,
+                    err,
+                )
+                # Intentar cargar datos en caché si hay un error
+                cached_data = load_json_from_file(output_file)
+                if cached_data:
+                    _LOGGER.info("Usando datos en caché para la estación %s.", self.station_id)
+                    return cached_data
+                # No se puede actualizar el estado, retornar None o un estado fallido
+                return None  # o cualquier otro valor que indique un estado de error
+
+class MeteocatUviCoordinator(DataUpdateCoordinator):
+    """Coordinator para manejar la actualización de datos de los sensores."""
+
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        entry_data: dict,
+        update_interval: timedelta = DEFAULT_UVI_UPDATE_INTERVAL,
+    ):
+        """
+        Inicializa el coordinador del sensor del Índice UV 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_id = entry_data["town_id"]  # Usamos el ID del municipio
+        self.meteocat_uvi_data = MeteocatUviData(self.api_key)
+
+        super().__init__(
+            hass,
+            _LOGGER,
+            name=f"{DOMAIN} Uvi 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 con manejo de tiempo límite
+            data = await asyncio.wait_for(
+                self.meteocat_uvi_data.get_uvi_index(self.town_id),
+                timeout=30  # Tiempo límite de 30 segundos
+            )
+            _LOGGER.debug("Datos de sensores actualizados exitosamente: %s", data)
+
+            # Validar que los datos sean un dict con una clave 'uvi'
+            if not isinstance(data, dict) or 'uvi' not in data:
+                _LOGGER.error("Formato inválido: Se esperaba un dict con la clave 'uvi'. Datos: %s", data)
+                raise ValueError("Formato de datos inválido")
+            
+            # Extraer la lista de datos bajo la clave 'uvi'
+            uvi_data = data.get('uvi', [])
+            
+            # Validar que 'uvi' sea una lista de diccionarios
+            if not isinstance(uvi_data, list) or not all(isinstance(item, dict) for item in uvi_data):
+                _LOGGER.error("Formato inválido: 'uvi' debe ser una lista de dicts. Datos: %s", uvi_data)
+                raise ValueError("Formato de datos inválido")
+
+            # Determinar la ruta al archivo en la carpeta raíz del repositorio
+            output_file = os.path.join(
+                self.hass.config.path(),
+                "custom_components",
+                "meteocat",
+                "files",
+                f"uvi_{self.town_id.lower()}_data.json"
+            )
+
+            # Guardar los datos en un archivo JSON
+            await save_json_to_file(data, output_file)
+
+            return uvi_data
+        except asyncio.TimeoutError as err:
+            _LOGGER.warning("Tiempo de espera agotado al obtener datos de la API de Meteocat.")
+            raise ConfigEntryNotReady from err
+        except ForbiddenError as err:
+            _LOGGER.error(
+                "Acceso denegado al obtener datos del índice UV para (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 del índice UV para (Town ID: %s): %s",
+                self.town_id,
+                err,
+            )
+            raise ConfigEntryNotReady from err
+        except (BadRequestError, InternalServerError, UnknownAPIError) as err:
+            _LOGGER.error(
+                "Error al obtener datos del índice UV para (Town ID: %s): %s",
+                self.town_id,
                 err,
             )
             raise
+        except Exception as err:
+            if isinstance(err, ConfigEntryNotReady):
+                # El dispositivo no pudo inicializarse por primera vez
+                _LOGGER.exception(
+                    "No se pudo inicializar el dispositivo (Town ID: %s) debido a un error: %s",
+                    self.town_id,
+                    err,
+                )
+                raise  # Re-raise the exception to indicate a fundamental failure in initialization
+            else:
+                # Manejar error durante la actualización de datos
+                _LOGGER.exception(
+                    "Error inesperado al obtener datos del índice UV para (Town ID: %s): %s",
+                    self.town_id,
+                    err,
+                )
+                # Intentar cargar datos en caché si hay un error
+                cached_data = load_json_from_file(output_file)
+                if cached_data:
+                    _LOGGER.info("Usando datos en caché para la ciudad %s.", self.town_id)
+                    return cached_data
+                # No se puede actualizar el estado, retornar None o un estado fallido
+                return None  # o cualquier otro valor que indique un estado de error
+
+class MeteocatUviFileCoordinator(DataUpdateCoordinator):
+    """Coordinator to read and process UV data from a file."""
+
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        entry_data: dict,
+        update_interval: timedelta = DEFAULT_UVI_SENSOR_UPDATE_INTERVAL,
+    ):
+        """
+        Inicializa el coordinador del sensor del Índice UV 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.town_id = entry_data["town_id"]  # Usamos el ID del municipio
+
+        super().__init__(
+            hass,
+            _LOGGER,
+            name=f"{DOMAIN} Uvi File Coordinator",
+            update_interval=update_interval,
+        )
+        self._file_path = os.path.join(
+            hass.config.path("custom_components/meteocat/files"),
+            f"uvi_{self.town_id.lower()}_data.json",
+        )
+
+    async def _async_update_data(self):
+        """Read and process UV data for the current hour from the file asynchronously."""
+        try:
+            async with aiofiles.open(self._file_path, "r", encoding="utf-8") as file:
+                raw_data = await file.read()
+                raw_data = json.loads(raw_data)  # Parse JSON data
+        except FileNotFoundError:
+            _LOGGER.error(
+                "No se ha encontrado el archivo JSON con datos del índice UV en %s.",
+                self._file_path,
+            )
+            return {}
+        except json.JSONDecodeError:
+            _LOGGER.error(
+                "Error al decodificar el archivo JSON del índice UV en %s.",
+                self._file_path,
+            )
+            return {}
+
+        return self._get_uv_for_current_hour(raw_data)
+
+    def _get_uv_for_current_hour(self, raw_data):
+        """Get UV data for the current hour."""
+        # Fecha y hora actual
+        current_datetime = datetime.now()
+        current_date = current_datetime.strftime("%Y-%m-%d")
+        current_hour = current_datetime.hour
+
+        # Busca los datos para la fecha actual
+        for day_data in raw_data.get("uvi", []):
+            if day_data["date"] == current_date:
+                # Encuentra los datos de la hora actual
+                for hour_data in day_data.get("hours", []):
+                    if hour_data["hour"] == current_hour:
+                        return {
+                            "hour": hour_data.get("hour", 0),
+                            "uvi": hour_data.get("uvi", 0),
+                            "uvi_clouds": hour_data.get("uvi_clouds", 0),
+                        }
+
+        # Si no se encuentran datos, devuelve un diccionario vacío con valores predeterminados
+        _LOGGER.warning(
+            "No se encontraron datos del índice UV para hoy (%s) y la hora actual (%s).",
+            current_date,
+            current_hour,
+        )
+        return {"hour": 0, "uvi": 0, "uvi_clouds": 0}
 
 # class MeteocatEntityCoordinator(DataUpdateCoordinator):
 #     """Coordinator para manejar la actualización de datos de las entidades de predicción."""

package/custom_components/meteocat/manifest.json

@@ -8,5 +8,5 @@
     "documentation": "https://gitlab.com/figorr/meteocat",
     "loggers": ["meteocatpy"],
     "requirements": ["meteocatpy==0.0.15", "packaging>=20.3", "wrapt>=1.14.0"],
-    "version": "0.1.35"
+    "version": "0.1.36"
 }

package/custom_components/meteocat/options_flow.py

@@ -25,7 +25,7 @@ class MeteocatOptionsFlowHandler(OptionsFlow):
 
     def __init__(self, config_entry: ConfigEntry):
         """Inicializa el flujo de opciones."""
-        self.config_entry = config_entry
+        self._config_entry = config_entry
         self.api_key: str | None = None
 
     async def async_step_init(self, user_input: dict | None = None):
@@ -60,8 +60,8 @@ class MeteocatOptionsFlowHandler(OptionsFlow):
             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},
+                    self._config_entry,
+                    data={**self._config_entry.data, CONF_API_KEY: self.api_key},
                 )
                 return self.async_create_entry(title="", data={})
 

package/custom_components/meteocat/sensor.py

@@ -59,7 +59,10 @@ from .const import (
     WIND_GUST_CODE,
 )
 
-from .coordinator import MeteocatSensorCoordinator
+from .coordinator import (
+    MeteocatSensorCoordinator,
+    MeteocatUviFileCoordinator,
+)
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -201,18 +204,82 @@ SENSOR_TYPES: tuple[MeteocatSensorEntityDescription, ...] = (
     )
 )
 
-
 @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"]
 
+    # Coordinadores para sensores
+    coordinator = entry_data.get("sensor_coordinator")
+    uvi_file_coordinator = entry_data.get("uvi_file_coordinator")
+
+    # Sensores generales
     async_add_entities(
         MeteocatSensor(coordinator, description, entry_data)
         for description in SENSOR_TYPES
+        if description.key != UV_INDEX  # Excluir UVI del coordinador general
+    )
+
+    # Sensor UVI
+    async_add_entities(
+        MeteocatUviSensor(uvi_file_coordinator, description, entry_data)
+        for description in SENSOR_TYPES
+        if description.key == UV_INDEX  # Incluir UVI en el coordinador UVI FILE COORDINATOR
     )
 
+class MeteocatUviSensor(CoordinatorEntity[MeteocatUviFileCoordinator], SensorEntity):
+    """Representation of a Meteocat UV Index sensor."""
+
+    _attr_has_entity_name = True  # Activa el uso de nombres basados en el dispositivo
+
+    def __init__(self, uvi_file_coordinator, description, entry_data):
+        """Initialize the UV Index sensor."""
+        super().__init__(uvi_file_coordinator)
+        self.entity_description = description
+        self._town_name = entry_data["town_name"]
+        self._town_id = entry_data["town_id"]
+        self._station_id = entry_data["station_id"]
+
+        # Unique ID for the entity
+        self._attr_unique_id = f"sensor.{DOMAIN}_{self._town_id}_{self.entity_description.key}"
+
+        # Asigna entity_category desde description (si está definido)
+        self._attr_entity_category = getattr(description, "entity_category", None)
+        
+        # Log para depuración
+        _LOGGER.debug(
+            "Inicializando sensor: %s, Unique ID: %s",
+            self.entity_description.name,
+            self._attr_unique_id,
+        )
+
+    @property
+    def native_value(self):
+        """Return the current UV index value."""
+        if self.entity_description.key == UV_INDEX:
+            uvi_data = self.coordinator.data or {}
+            return uvi_data.get("uvi", None)
+    
+    @property
+    def extra_state_attributes(self):
+        """Return additional attributes for the sensor."""
+        attributes = super().extra_state_attributes or {}
+        if self.entity_description.key == UV_INDEX:
+            uvi_data = self.coordinator.data or {}
+            # Add the "hour" attribute if it exists
+            attributes["hour"] = uvi_data.get("hour")
+        return attributes
+    
+    @property
+    def device_info(self) -> DeviceInfo:
+        """Return the device info."""
+        return DeviceInfo(
+            identifiers={(DOMAIN, self._town_id)},
+            name="Meteocat " + self._station_id + " " + self._town_name,
+            manufacturer="Meteocat",
+            model="Meteocat API",
+        )
+
 class MeteocatSensor(CoordinatorEntity[MeteocatSensorCoordinator], SensorEntity):
     """Representation of a Meteocat sensor."""
     STATIC_KEYS = {TOWN_NAME, TOWN_ID, STATION_NAME, STATION_ID}
@@ -225,7 +292,7 @@ class MeteocatSensor(CoordinatorEntity[MeteocatSensorCoordinator], SensorEntity)
         PRESSURE: PRESSURE_CODE,
         PRECIPITATION: PRECIPITATION_CODE,
         SOLAR_GLOBAL_IRRADIANCE: SOLAR_GLOBAL_IRRADIANCE_CODE,
-        UV_INDEX: UV_INDEX_CODE,
+        # UV_INDEX: UV_INDEX_CODE,
         MAX_TEMPERATURE: MAX_TEMPERATURE_CODE,
         MIN_TEMPERATURE: MIN_TEMPERATURE_CODE,
         WIND_GUST: WIND_GUST_CODE,

package/custom_components/meteocat/strings.json

@@ -69,7 +69,10 @@
         "name": "Solar Global Irradiance"
       },
       "uv_index": {
-        "name": "UV Index"
+        "name": "UV Index",
+        "attributes": {
+          "hour": "Hour"
+        }
       },
       "max_temperature": {
         "name": "Max Temperature"

package/custom_components/meteocat/translations/ca.json

@@ -69,7 +69,10 @@
         "name": "Irradiació Solar Global"
       },
       "uv_index": {
-        "name": "UV Índex"
+        "name": "UV Índex",
+        "attributes": {
+          "hour": "Hora"
+        }
       },
       "max_temperature": {
         "name": "Temperatura Max"

package/custom_components/meteocat/translations/en.json

@@ -69,7 +69,10 @@
         "name": "Solar Global Irradiance"
       },
       "uv_index": {
-        "name": "UV Index"
+        "name": "UV Index",
+        "attributes": {
+          "hour": "Hour"
+        }
       },
       "max_temperature": {
         "name": "Max Temperature"

package/custom_components/meteocat/translations/es.json

@@ -69,7 +69,10 @@
         "name": "Irradiación Solar Global"
       },
       "uv_index": {
-        "name": "UV Índice"
+        "name": "UV Índice",
+        "attributes": {
+          "hour": "Hora"
+        }
       },
       "max_temperature": {
         "name": "Temperatura Max"

package/custom_components/meteocat/version.py

@@ -1,2 +1,2 @@
 # version.py
-__version__ = "0.1.35"
+__version__ = "0.1.36"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "meteocat",
-  "version": "0.1.35",
+  "version": "0.1.36",
   "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": {

package/poetry.lock

@@ -121,13 +121,13 @@ speedups = ["Brotli", "aiodns (>=3.2.0)", "brotlicffi"]
 
 [[package]]
 name = "aiosignal"
-version = "1.3.1"
+version = "1.3.2"
 description = "aiosignal: a list of registered asynchronous callbacks"
 optional = false
-python-versions = ">=3.7"
+python-versions = ">=3.9"
 files = [
-    {file = "aiosignal-1.3.1-py3-none-any.whl", hash = "sha256:f8376fb07dd1e86a584e4fcdec80b36b7f81aac666ebc724e2c090300dd83b17"},
-    {file = "aiosignal-1.3.1.tar.gz", hash = "sha256:54cd96e15e1649b75d6c87526a6ff0b6c1b0dd3459f43d9ca11d48c339b68cfc"},
+    {file = "aiosignal-1.3.2-py2.py3-none-any.whl", hash = "sha256:45cde58e409a301715980c2b01d0c28bdde3770d8290b5eb2173759d9acb31a5"},
+    {file = "aiosignal-1.3.2.tar.gz", hash = "sha256:a8c255c66fafb1e499c9351d0bf32ff2d8a0321595ebac3b93713656d2436f54"},
 ]
 
 [package.dependencies]
@@ -298,13 +298,13 @@ files = [
 
 [[package]]
 name = "certifi"
-version = "2024.8.30"
+version = "2024.12.14"
 description = "Python package for providing Mozilla's CA Bundle."
 optional = false
 python-versions = ">=3.6"
 files = [
-    {file = "certifi-2024.8.30-py3-none-any.whl", hash = "sha256:922820b53db7a7257ffbda3f597266d435245903d80737e34f8a45ff3e3230d8"},
-    {file = "certifi-2024.8.30.tar.gz", hash = "sha256:bec941d2aa8195e248a60b31ff9f0558284cf01a52591ceda73ea9afffd69fd9"},
+    {file = "certifi-2024.12.14-py3-none-any.whl", hash = "sha256:1275f7a45be9464efc1173084eaa30f866fe2e47d389406136d332ed4967ec56"},
+    {file = "certifi-2024.12.14.tar.gz", hash = "sha256:b650d30f370c2b724812bee08008be0c4163b163ddaec3f2546c1caf65f191db"},
 ]
 
 [[package]]
@@ -796,13 +796,13 @@ poetry = ["poetry"]
 
 [[package]]
 name = "eventlet"
-version = "0.38.1"
+version = "0.38.2"
 description = "Highly concurrent networking library"
 optional = false
 python-versions = ">=3.7"
 files = [
-    {file = "eventlet-0.38.1-py3-none-any.whl", hash = "sha256:428eeff656bacf6d8c9a3d92fdbfe5a607c9e3e575ea70641de175aa9f3ec67a"},
-    {file = "eventlet-0.38.1.tar.gz", hash = "sha256:ae23e3eb455facf0802df30c55da4ffbbf72e952757efa2197a1b47901255b1f"},
+    {file = "eventlet-0.38.2-py3-none-any.whl", hash = "sha256:4a2e3cbc53917c8f39074ccf689501168563d3a4df59e9cddd5e9d3b7f85c599"},
+    {file = "eventlet-0.38.2.tar.gz", hash = "sha256:6a46823af1dca7d29cf04c0d680365805435473c3acbffc176765c7f8787edac"},
 ]
 
 [package.dependencies]
@@ -2160,20 +2160,20 @@ testing = ["coverage (==6.2)", "mypy (==0.931)"]
 
 [[package]]
 name = "pytest-asyncio"
-version = "0.24.0"
+version = "0.25.0"
 description = "Pytest support for asyncio"
 optional = false
-python-versions = ">=3.8"
+python-versions = ">=3.9"
 files = [
-    {file = "pytest_asyncio-0.24.0-py3-none-any.whl", hash = "sha256:a811296ed596b69bf0b6f3dc40f83bcaf341b155a269052d82efa2b25ac7037b"},
-    {file = "pytest_asyncio-0.24.0.tar.gz", hash = "sha256:d081d828e576d85f875399194281e92bf8a68d60d72d1a2faf2feddb6c46b276"},
+    {file = "pytest_asyncio-0.25.0-py3-none-any.whl", hash = "sha256:db5432d18eac6b7e28b46dcd9b69921b55c3b1086e85febfe04e70b18d9e81b3"},
+    {file = "pytest_asyncio-0.25.0.tar.gz", hash = "sha256:8c0610303c9e0442a5db8604505fc0f545456ba1528824842b37b4a626cbf609"},
 ]
 
 [package.dependencies]
 pytest = ">=8.2,<9"
 
 [package.extras]
-docs = ["sphinx (>=5.3)", "sphinx-rtd-theme (>=1.0)"]
+docs = ["sphinx (>=5.3)", "sphinx-rtd-theme (>=1)"]
 testing = ["coverage (>=6.2)", "hypothesis (>=5.7.1)"]
 
 [[package]]

package/pyproject.toml

@@ -1,12 +1,15 @@
 [tool.poetry]
 name = "meteocat"
-version = "0.1.35"
+version = "0.1.36"
 description = "Script para obtener datos meteorológicos de la API de Meteocat"
 authors = ["figorr <jdcuartero@yahoo.es>"]
 license = "Apache-2.0"
 readme = "README.md"
 repository = "https://gitlab.com/figorr/meteocat"
 keywords = ['meteocat']
+packages = [
+    { include = "meteocat", from = "custom_components" }
+]
 
 
 [tool.poetry.dependencies]
@@ -62,4 +65,4 @@ pipdeptree = "^2.2.1"
 
 [tool.poetry.group.dev.dependencies]
 pyupgrade = "^3.4.0"
-pre-commit = "^3.3.1"
+pre-commit = "^3.3.1"