meteocat 0.1.23 → 0.1.26

package/CHANGELOG.md

@@ -1,3 +1,36 @@
+## [0.1.26](https://github.com/figorr/meteocat/compare/v0.1.25...v0.1.26) (2024-12-09)
+
+
+### Bug Fixes
+
+* 0.1.26 ([9d6b083](https://github.com/figorr/meteocat/commit/9d6b083205d12b628d9a62b0c8c558c0ca9d39e2))
+* add station timestamp constant ([6bd0569](https://github.com/figorr/meteocat/commit/6bd0569030361b89c532ef49faae4b938c1dcf8a))
+* add station timestamp sensor ([ac8b98b](https://github.com/figorr/meteocat/commit/ac8b98bcb225d1348b450b619879b6f636a213da))
+* fix async_remove_entry ([ba28daa](https://github.com/figorr/meteocat/commit/ba28daa87271b6286cf22cd2bcc39422f71b668a))
+* fix entity_id names ([b670d8d](https://github.com/figorr/meteocat/commit/b670d8d53888dc93f371ba7c0e4ed2cdad7ac64b))
+* fix loop when saving JSON ([151dbdd](https://github.com/figorr/meteocat/commit/151dbddd932313831028e1e3e17780dd33d44640))
+* sensor names ([5244f7f](https://github.com/figorr/meteocat/commit/5244f7f8e9d332bfd6adf9e65c053e4b12d8a109))
+
+## [0.1.25](https://github.com/figorr/meteocat/compare/v0.1.24...v0.1.25) (2024-12-08)
+
+
+### Bug Fixes
+
+* 0.1.25 ([5ba0823](https://github.com/figorr/meteocat/commit/5ba0823db1da999d61c5a4d43733dff5db238ea4))
+* add town and station sensors ([372383f](https://github.com/figorr/meteocat/commit/372383f1bd17ba8e385fef638cf3c1f58515dbaf))
+
+## [0.1.24](https://github.com/figorr/meteocat/compare/v0.1.23...v0.1.24) (2024-12-08)
+
+
+### Bug Fixes
+
+* 0.1.24 ([87b8b51](https://github.com/figorr/meteocat/commit/87b8b519f78ba97a3e9fe01ac1ee85c0efd0a879))
+* add function to save station_data.json ([e78d872](https://github.com/figorr/meteocat/commit/e78d872938c002fe363c2634b1d8d171ea1e2d6e))
+* add solar global irradiance ([dc757b0](https://github.com/figorr/meteocat/commit/dc757b0a8df6ee971c01e290568730cdf3eb54b0))
+* add solar global irradiance sensor ([d0e7373](https://github.com/figorr/meteocat/commit/d0e737302f9d7889a698468ba6ffb881d8da17c2))
+* bump meteocatpy to 0.0.8 ([c280c06](https://github.com/figorr/meteocat/commit/c280c06c7c3c0703e12e94b19108537bbd03baa0))
+* fix constants ([5d4e0b7](https://github.com/figorr/meteocat/commit/5d4e0b77336f1e051a04a45ccaace40ada3ed33a))
+
 ## [0.1.23](https://github.com/figorr/meteocat/compare/v0.1.22...v0.1.23) (2024-12-07)
 
 

package/custom_components/meteocat/__init__.py

@@ -6,13 +6,15 @@ from homeassistant import core
 from homeassistant.config_entries import ConfigEntry
 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 .const import DOMAIN, PLATFORMS
 
 _LOGGER = logging.getLogger(__name__)
 
 # Versión
-__version__ = "0.1.23"
+__version__ = "0.1.26"
 
 
 async def async_setup(hass: core.HomeAssistant, config: dict) -> bool:
@@ -27,44 +29,34 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     # Extraer los datos necesarios de la entrada de configuración
     entry_data = entry.data
 
-    # Validar que todos los campos requeridos estén presentes
+    # Validar campos requeridos
     required_fields = [
         "api_key", "town_name", "town_id", "variable_name",
         "variable_id", "station_name", "station_id"
     ]
-    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.")
+    missing_fields = [field for field in required_fields if field not in entry_data]
+    if missing_fields:
+        _LOGGER.error(f"Faltan los siguientes campos en la configuración: {missing_fields}")
         return False
 
-    _LOGGER.info(
-        f"Integración configurada para el municipio '{entry_data['town_name']}' "
-        f"(ID: {entry_data['town_id']}), variable '{entry_data['variable_name']}' "
-        f"(ID: {entry_data['variable_id']}), estación '{entry_data['station_name']}' "
-        f"(ID: {entry_data['station_id']})."
+    _LOGGER.debug(
+        f"Datos de configuración: Municipio '{entry_data['town_name']}' (ID: {entry_data['town_id']}), "
+        f"Variable '{entry_data['variable_name']}' (ID: {entry_data['variable_id']}), "
+        f"Estación '{entry_data['station_name']}' (ID: {entry_data['station_id']})."
     )
 
-    # Inicializa y refresca los coordinadores
+    # Inicializar coordinadores
     try:
-        # Crear el coordinador para sensores
-        sensor_coordinator = MeteocatSensorCoordinator(
-            hass=hass,
-            entry_data=entry_data,  # Pasa los datos como un diccionario
-        )
-
-        # Crear el coordinador para entidades de predicción
-        entity_coordinator = MeteocatEntityCoordinator(
-            hass=hass,
-            entry_data=entry_data,  # Pasa los mismos datos
-        )
-
-        # Ejecutar la primera actualización
+        sensor_coordinator = MeteocatSensorCoordinator(hass=hass, entry_data=entry_data)
+        entity_coordinator = MeteocatEntityCoordinator(hass=hass, entry_data=entry_data)
+
         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}")
+    except Exception as err:  # Capturar todos los errores
+        _LOGGER.exception(f"Error al inicializar los coordinadores: {err}")
         return False
 
-    # Guardar los coordinadores en hass.data
+    # Guardar coordinadores y datos en hass.data
     hass.data.setdefault(DOMAIN, {})
     hass.data[DOMAIN][entry.entry_id] = {
         "sensor_coordinator": sensor_coordinator,
@@ -72,7 +64,8 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
         **entry_data,
     }
 
-    # Configurar las plataformas
+    # Configurar plataformas
+    _LOGGER.debug(f"Cargando plataformas: {PLATFORMS}")
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
 
     return True
@@ -80,12 +73,14 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
 
 async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Desactiva una entrada de configuración para Meteocat."""
+    platforms = async_get_platforms(hass, DOMAIN)
+    _LOGGER.info(f"Descargando plataformas: {[p.domain for p in platforms]}")
+
     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
+        if not hass.data[DOMAIN]:
             hass.data.pop(DOMAIN)
 
-    # Desinstalar las plataformas
     return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
 
 
@@ -93,10 +88,14 @@ 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")
+    # Definir las rutas de los archivos y carpetas a eliminar
+    custom_components_path = hass.config.path("custom_components", DOMAIN)
+    assets_folder = os.path.join(custom_components_path, "assets")
+    files_folder = os.path.join(custom_components_path, "files")
     symbols_file = os.path.join(assets_folder, "symbols.json")
+    station_data_file = os.path.join(files_folder, "station_data.json")
 
+    # Eliminar el archivo symbols.json si existe
     try:
         if os.path.exists(symbols_file):
             os.remove(symbols_file)
@@ -105,3 +104,33 @@ async def async_remove_entry(hass: HomeAssistant, entry: ConfigEntry) -> None:
             _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}")
+
+    # Eliminar el archivo station_data.json si existe
+    try:
+        if os.path.exists(station_data_file):
+            os.remove(station_data_file)
+            _LOGGER.info("Archivo station_data.json eliminado correctamente.")
+        else:
+            _LOGGER.info("El archivo station_data.json no se encontró.")
+    except OSError as e:
+        _LOGGER.error(f"Error al intentar eliminar el archivo station_data.json: {e}")
+
+    # Eliminar la carpeta assets si está vacía
+    try:
+        if os.path.exists(assets_folder) and not os.listdir(assets_folder):
+            os.rmdir(assets_folder)
+            _LOGGER.info("Carpeta assets eliminada correctamente.")
+        elif os.path.exists(assets_folder):
+            _LOGGER.warning("La carpeta assets no está vacía y no se pudo eliminar.")
+    except OSError as e:
+        _LOGGER.error(f"Error al intentar eliminar la carpeta assets: {e}")
+    
+    # Eliminar la carpeta files si está vacía
+    try:
+        if os.path.exists(files_folder) and not os.listdir(files_folder):
+            os.rmdir(files_folder)
+            _LOGGER.info("Carpeta files eliminada correctamente.")
+        elif os.path.exists(files_folder):
+            _LOGGER.warning("La carpeta files no está vacía y no se pudo eliminar.")
+    except OSError as e:
+        _LOGGER.error(f"Error al intentar eliminar la carpeta files: {e}")

package/custom_components/meteocat/const.py

@@ -16,10 +16,25 @@ TEMPERATURE = "temperature"  # Temperatura
 HUMIDITY = "humidity"  # Humedad relativa
 PRESSURE = "pressure"  # Presión atmosférica
 PRECIPITATION = "precipitation"  # Precipitación
+SOLAR_GLOBAL_IRRADIANCE = "solar_global_irradiance"  # Irradiación solar global
 UV_INDEX = "uv_index"  # UV
 MAX_TEMPERATURE = "max_temperature"  # Temperatura máxima
 MIN_TEMPERATURE = "min_temperature"  # Temperatura mínima
 WIND_GUST = "wind_gust"  # Racha de viento
+STATION_TIMESTAMP = "station_timestamp"  # Código de tiempo de la estación
+
+# Definición de códigos para variables
+WIND_SPEED_CODE = 30
+WIND_DIRECTION_CODE = 31
+TEMPERATURE_CODE = 32
+HUMIDITY_CODE = 33
+PRESSURE_CODE = 34
+PRECIPITATION_CODE = 35
+SOLAR_GLOBAL_IRRADIANCE_CODE = 36
+UV_INDEX_CODE = 39
+MAX_TEMPERATURE_CODE = 40
+MIN_TEMPERATURE_CODE = 42
+WIND_GUST_CODE = 50
 
 # Mapeo de códigos 'estatCel' a condiciones de Home Assistant
 CONDITION_MAPPING = {
@@ -36,19 +51,5 @@ CONDITION_MAPPING = {
     "snow-rainy": [27, 29, 30],
 }
 
-# Mapeo de códigos a claves de sensores
-VARIABLE_CODE_MAPPING = {
-    30: WIND_SPEED,
-    31: WIND_DIRECTION,
-    32: TEMPERATURE,
-    33: HUMIDITY,
-    34: PRESSURE,
-    35: PRECIPITATION,
-    39: UV_INDEX,
-    40: MAX_TEMPERATURE,
-    42: MIN_TEMPERATURE,
-    50: WIND_GUST,
-}
-
 # Platforms
 PLATFORMS = ["sensor"]

package/custom_components/meteocat/coordinator.py

@@ -1,5 +1,8 @@
 from __future__ import annotations
 
+import os
+import json
+import aiofiles
 import logging
 from datetime import timedelta
 from typing import Dict
@@ -26,6 +29,17 @@ _LOGGER = logging.getLogger(__name__)
 DEFAULT_SENSOR_UPDATE_INTERVAL = timedelta(minutes=90)
 DEFAULT_ENTITY_UPDATE_INTERVAL = timedelta(hours=12)
 
+async def save_json_to_file(data: dict, output_file: str) -> None:
+    """Save the JSON data to a file asynchronously."""
+    try:
+        # Crea el directorio si no existe
+        os.makedirs(os.path.dirname(output_file), exist_ok=True)
+
+        # Escribe los datos JSON de forma asíncrona
+        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}")
 
 class MeteocatSensorCoordinator(DataUpdateCoordinator):
     """Coordinator para manejar la actualización de datos de los sensores."""
@@ -63,8 +77,18 @@ class MeteocatSensorCoordinator(DataUpdateCoordinator):
     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)
+            # 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)
+
+            # 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", "station_data.json"
+            )
+
+            # Guardar los datos en un archivo JSON
+            await save_json_to_file(data, output_file)
+
             return data
         except ForbiddenError as err:
             _LOGGER.error(
@@ -95,7 +119,6 @@ class MeteocatSensorCoordinator(DataUpdateCoordinator):
             )
             raise
 
-
 class MeteocatEntityCoordinator(DataUpdateCoordinator):
     """Coordinator para manejar la actualización de datos de las entidades de predicción."""
 

package/custom_components/meteocat/manifest.json

@@ -7,6 +7,6 @@
     "iot_class": "cloud_polling",
     "documentation": "https://gitlab.com/figorr/meteocat",
     "loggers": ["meteocatpy"],
-    "requirements": ["meteocatpy==0.0.7", "packaging>=20.3", "wrapt>=1.14.0"],
-    "version": "0.1.23"
+    "requirements": ["meteocatpy==0.0.8", "packaging>=20.3", "wrapt>=1.14.0"],
+    "version": "0.1.26"
 }

package/custom_components/meteocat/sensor.py

@@ -1,7 +1,12 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from homeassistant.helpers.entity import DeviceInfo
+from datetime import datetime
+import logging
+from homeassistant.helpers.entity import (
+    DeviceInfo,
+    EntityCategory,
+)
 from homeassistant.components.sensor import (
     SensorDeviceClass,
     SensorEntity,
@@ -18,39 +23,57 @@ from homeassistant.const import (
     UnitOfSpeed,
     UnitOfTemperature,
     UnitOfVolumetricFlux,
+    UnitOfIrradiance,
 )
 
 from .const import (
     DOMAIN,
+    TOWN_NAME,
+    TOWN_ID,
+    STATION_NAME,
+    STATION_ID,
     WIND_SPEED,
     WIND_DIRECTION,
     TEMPERATURE,
     HUMIDITY,
     PRESSURE,
     PRECIPITATION,
+    SOLAR_GLOBAL_IRRADIANCE,
     UV_INDEX,
     MAX_TEMPERATURE,
     MIN_TEMPERATURE,
     WIND_GUST,
-    VARIABLE_CODE_MAPPING,
+    STATION_TIMESTAMP,
+    WIND_SPEED_CODE,
+    WIND_DIRECTION_CODE,
+    TEMPERATURE_CODE,
+    HUMIDITY_CODE,
+    PRESSURE_CODE,
+    PRECIPITATION_CODE,
+    SOLAR_GLOBAL_IRRADIANCE_CODE,
+    UV_INDEX_CODE,
+    MAX_TEMPERATURE_CODE,
+    MIN_TEMPERATURE_CODE,
+    WIND_GUST_CODE,
 )
 
 from .coordinator import MeteocatSensorCoordinator
 
+_LOGGER = logging.getLogger(__name__)
 
 @dataclass
 class MeteocatSensorEntityDescription(SensorEntityDescription):
     """A class that describes Meteocat sensor entities."""
 
-
 SENSOR_TYPES: tuple[MeteocatSensorEntityDescription, ...] = (
+    # Sensores dinámicos
     MeteocatSensorEntityDescription(
         key=WIND_SPEED,
         name="Wind Speed",
         icon="mdi:weather-windy",
         device_class=SensorDeviceClass.WIND_SPEED,
         state_class=SensorStateClass.MEASUREMENT,
-        native_unit_of_measurement=UnitOfSpeed.METERS_PER_SECOND,
+        native_unit_of_measurement=UnitOfSpeed.KILOMETERS_PER_HOUR,
     ),
     MeteocatSensorEntityDescription(
         key=WIND_DIRECTION,
@@ -90,6 +113,14 @@ SENSOR_TYPES: tuple[MeteocatSensorEntityDescription, ...] = (
         state_class=SensorStateClass.MEASUREMENT,
         native_unit_of_measurement=UnitOfVolumetricFlux.MILLIMETERS_PER_HOUR,
     ),
+    MeteocatSensorEntityDescription(
+        key=SOLAR_GLOBAL_IRRADIANCE,
+        name="Solar Global Irradiance",
+        icon="mdi:weather-sunny",
+        device_class=SensorDeviceClass.IRRADIANCE,
+        state_class=SensorStateClass.MEASUREMENT,
+        native_unit_of_measurement = UnitOfIrradiance.WATTS_PER_SQUARE_METER,
+    ),
     MeteocatSensorEntityDescription(
         key=UV_INDEX,
         name="UV Index",
@@ -117,8 +148,39 @@ SENSOR_TYPES: tuple[MeteocatSensorEntityDescription, ...] = (
         icon="mdi:weather-windy",
         device_class=SensorDeviceClass.WIND_SPEED,
         state_class=SensorStateClass.MEASUREMENT,
-        native_unit_of_measurement=UnitOfSpeed.METERS_PER_SECOND,
+        native_unit_of_measurement=UnitOfSpeed.KILOMETERS_PER_HOUR,
+    ),
+    # Sensores estáticos
+    MeteocatSensorEntityDescription(
+        key=TOWN_NAME,
+        name="Town Name",
+        icon="mdi:home-city",
+        entity_category=EntityCategory.DIAGNOSTIC,
     ),
+    MeteocatSensorEntityDescription(
+        key=TOWN_ID,
+        name="Town ID",
+        icon="mdi:identifier",
+        entity_category=EntityCategory.DIAGNOSTIC,
+    ),
+    MeteocatSensorEntityDescription(
+        key=STATION_NAME,
+        name="Station Name",
+        icon="mdi:broadcast",
+        entity_category=EntityCategory.DIAGNOSTIC,
+    ),
+    MeteocatSensorEntityDescription(
+        key=STATION_ID,
+        name="Station ID",
+        icon="mdi:identifier",
+        entity_category=EntityCategory.DIAGNOSTIC,
+    ),
+    MeteocatSensorEntityDescription(
+    key=STATION_TIMESTAMP,
+    name="Station Timestamp",
+    icon="mdi:calendar-clock",
+    device_class=SensorDeviceClass.TIMESTAMP,
+    )
 )
 
 
@@ -133,62 +195,125 @@ async def async_setup_entry(hass, entry, async_add_entities: AddEntitiesCallback
         for description in SENSOR_TYPES
     )
 
-
 class MeteocatSensor(CoordinatorEntity[MeteocatSensorCoordinator], SensorEntity):
     """Representation of a Meteocat sensor."""
+    STATIC_KEYS = {TOWN_NAME, TOWN_ID, STATION_NAME, STATION_ID}
+
+    CODE_MAPPING = {
+        WIND_SPEED: WIND_SPEED_CODE,
+        WIND_DIRECTION: WIND_DIRECTION_CODE,
+        TEMPERATURE: TEMPERATURE_CODE,
+        HUMIDITY: HUMIDITY_CODE,
+        PRESSURE: PRESSURE_CODE,
+        PRECIPITATION: PRECIPITATION_CODE,
+        SOLAR_GLOBAL_IRRADIANCE: SOLAR_GLOBAL_IRRADIANCE_CODE,
+        UV_INDEX: UV_INDEX_CODE,
+        MAX_TEMPERATURE: MAX_TEMPERATURE_CODE,
+        MIN_TEMPERATURE: MIN_TEMPERATURE_CODE,
+        WIND_GUST: WIND_GUST_CODE,
+    }
+
+    _attr_has_entity_name = True  # Activa el uso de nombres basados en el dispositivo
 
     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
+        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"]
 
         # Unique ID for the entity
-        self._attr_unique_id = f"{self._town_id}_{self.entity_description.key}"
+        self._attr_unique_id = f"sensor.{DOMAIN}_{self._station_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 state of the sensor."""
-        sensor_code = next(
-            (code for code, key in VARIABLE_CODE_MAPPING.items() if key == self.entity_description.key),
-            None,
-        )
-        
+        # Información estática
+        if self.entity_description.key in self.STATIC_KEYS:
+            # Información estática del `entry_data`
+            if self.entity_description.key == TOWN_NAME:
+                return self._town_name
+            if self.entity_description.key == TOWN_ID:
+                return self._town_id
+            if self.entity_description.key == STATION_NAME:
+                return self._station_name
+            if self.entity_description.key == STATION_ID:
+                return self._station_id
+        # Información dinámica
+        sensor_code = self.CODE_MAPPING.get(self.entity_description.key)
+
         if sensor_code is not None:
-            variable_data = next(
-                (var for var in self.coordinator.data.get("variables", []) if var["codi"] == sensor_code),
-                None,
-            )
-            if variable_data:
-                # Asume que quieres el último valor registrado
-                latest_reading = variable_data["lectures"][-1]
-                value = latest_reading.get("valor")
+            # Accedemos a las estaciones en el JSON recibido
+            stations = self.coordinator.data or []
+            for station in stations:
+                variables = station.get("variables", [])
+
+                # Filtramos por código
+                variable_data = next(
+                    (var for var in variables if var.get("codi") == sensor_code),
+                    None,
+                )
+
+                if variable_data:
+                    # Obtenemos la última lectura
+                    lectures = variable_data.get("lectures", [])
+                    if lectures:
+                        latest_reading = lectures[-1]
+                        value = latest_reading.get("valor")
 
-                # Convertir grados a direcciones cardinales para WIND_DIRECTION
-                if self.entity_description.key == WIND_DIRECTION and isinstance(value, (int, float)):
-                    return self._convert_degrees_to_cardinal(value)
+                        # Convertimos grados a dirección cardinal para WIND_DIRECTION
+                        if self.entity_description.key == WIND_DIRECTION and isinstance(value, (int, float)):
+                            return self._convert_degrees_to_cardinal(value)
 
-                return value
+                        return value
+          # Lógica específica para el sensor de timestamp
+        if self.entity_description.key == "station_timestamp":
+            stations = self.coordinator.data or []
+            for station in stations:
+                variables = station.get("variables", [])
+                for variable in variables:
+                    lectures = variable.get("lectures", [])
+                    if lectures:
+                        # Obtenemos el campo `data` de la última lectura
+                        latest_reading = lectures[-1]
+                        raw_timestamp = latest_reading.get("data")
+
+                        if raw_timestamp:
+                            # Convertir el timestamp a un objeto datetime
+                            try:
+                                return datetime.fromisoformat(raw_timestamp.replace("Z", "+00:00"))
+                            except ValueError:
+                                # Manejo de errores si el formato no es válido
+                                return None
 
         return None
 
     @staticmethod
     def _convert_degrees_to_cardinal(degree: float) -> str:
         """Convert degrees to cardinal direction."""
+        if not isinstance(degree, (int, float)):
+            return "Unknown"  # Retorna "Unknown" si el valor no es un número válido
+
         directions = [
             "N", "NNE", "NE", "ENE", "E", "ESE", "SE", "SSE",
-            "S", "SSW", "SW", "WSW", "W", "WNW", "NW", "NNW", "N",
+            "S", "SSO", "SO", "OSO", "O", "ONO", "NO", "NNO", "N",
         ]
         index = round(degree / 22.5) % 16
         return directions[index]
 
-
     @property
     def device_info(self) -> DeviceInfo:
         """Return the device info."""
@@ -196,5 +321,5 @@ class MeteocatSensor(CoordinatorEntity[MeteocatSensorCoordinator], SensorEntity)
             identifiers={(DOMAIN, self._town_id)},
             name=self._town_name,
             manufacturer="Meteocat",
-            model="Meteocat API"
+            model="Meteocat API",
         )

package/custom_components/meteocat/version.py

@@ -1,2 +1,2 @@
 # version.py
-__version__ = "0.1.23"
+__version__ = "0.1.26"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "meteocat",
-  "version": "0.1.23",
+  "version": "0.1.26",
   "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/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "meteocat"
-version = "0.1.23"
+version = "0.1.26"
 description = "Script para obtener datos meteorológicos de la API de Meteocat"
 authors = ["figorr <jdcuartero@yahoo.es>"]
 license = "Apache-2.0"