meteocat 0.1.46 → 0.1.48

package/.github/workflows/release.yml

@@ -24,8 +24,14 @@ jobs:
       # Paso 3: Instalar dependencias necesarias
       - name: Install dependencies
         run: npm ci
+      
+      # Paso 4: Configurar el autor de Git
+      - name: Configure Git author
+        run: |
+          git config user.name "semantic-release-bot"
+          git config user.email "jdcuartero@yahoo.es"
 
-      # Paso 4: Ejecutar semantic-release
+      # Paso 5: Ejecutar semantic-release
       - name: Run semantic-release
         env:
           GITHUB_TOKEN: ${{ secrets.WORKFLOW_TOKEN }}

package/CHANGELOG.md

@@ -1,3 +1,21 @@
+## [0.1.48](https://github.com/figorr/meteocat/compare/v0.1.47...v0.1.48) (2025-01-03)
+
+
+### Bug Fixes
+
+* 0.1.48 ([b8b8830](https://github.com/figorr/meteocat/commit/b8b8830a23b0d63744f30c3dff33fc9f172a3c01))
+* fix UTC to local time conversion ([14cf7d2](https://github.com/figorr/meteocat/commit/14cf7d2ca696ede2bedcd6041195df44fdd6d245))
+
+## [0.1.47](https://github.com/figorr/meteocat/compare/v0.1.46...v0.1.47) (2025-01-02)
+
+
+### Bug Fixes
+
+* 0.1.47 ([03d1d08](https://github.com/figorr/meteocat/commit/03d1d08dd837dc47d8f2062ba561be706e1d8b05))
+* convert to local time from UTC ([0dfe9f9](https://github.com/figorr/meteocat/commit/0dfe9f9ef7409bcd23d839963076aff14921f114))
+* fix semantic-release-bot ([754f18b](https://github.com/figorr/meteocat/commit/754f18b2c0378c704eb255259192655b76100c43))
+* fix timestamp sensor from UTC to local time Europe/Madrid ([e64539a](https://github.com/figorr/meteocat/commit/e64539a091adecfd4e23419c63bc54eda2293da3))
+
 ## [0.1.46](https://github.com/figorr/meteocat/compare/v0.1.45...v0.1.46) (2025-01-01)
 
 

package/custom_components/meteocat/__init__.py

@@ -25,7 +25,7 @@ from .const import DOMAIN, PLATFORMS
 _LOGGER = logging.getLogger(__name__)
 
 # Versión
-__version__ = "0.1.46"
+__version__ = "0.1.48"
 
 def safe_remove(path: Path, is_folder: bool = False):
     """Elimina de forma segura un archivo o carpeta si existe."""

package/custom_components/meteocat/coordinator.py

@@ -6,6 +6,7 @@ import aiofiles
 import logging
 import asyncio
 from datetime import datetime, timedelta, timezone, time
+from zoneinfo import ZoneInfo
 from typing import Dict, Any
 
 from homeassistant.core import HomeAssistant
@@ -47,6 +48,9 @@ DEFAULT_UVI_SENSOR_UPDATE_INTERVAL = timedelta(minutes=5)
 DEFAULT_CONDITION_SENSOR_UPDATE_INTERVAL = timedelta(minutes=5)
 DEFAULT_TEMP_FORECAST_UPDATE_INTERVAL = timedelta(minutes=5)
 
+# Definir la zona horaria local
+TIMEZONE = ZoneInfo("Europe/Madrid")
+
 async def save_json_to_file(data: dict, output_file: str) -> None:
     """Guarda datos JSON en un archivo de forma asíncrona."""
     try:
@@ -633,6 +637,12 @@ class HourlyForecastCoordinator(DataUpdateCoordinator):
             update_interval=DEFAULT_HOURLY_FORECAST_UPDATE_INTERVAL,
         )
 
+    def _convert_to_local_time(self, forecast_time: datetime) -> datetime:
+        """Convierte una hora UTC a la hora local en la zona horaria de Madrid, considerando el horario de verano."""
+        # Convertir la hora UTC a la hora local usando la zona horaria de Madrid
+        local_time = forecast_time.astimezone(TIMEZONE)
+        return local_time
+
     async def _is_data_valid(self) -> bool:
         """Verifica si los datos horarios en el archivo JSON son válidos y actuales."""
         if not os.path.exists(self.file_path):
@@ -646,11 +656,13 @@ class HourlyForecastCoordinator(DataUpdateCoordinator):
             if not data or "dies" not in data:
                 return False
 
-            now = datetime.now(timezone.utc)
+            now = datetime.now(TIMEZONE)
             for dia in data["dies"]:
                 for forecast in dia.get("variables", {}).get("estatCel", {}).get("valors", []):
                     forecast_time = datetime.fromisoformat(forecast["data"].rstrip("Z")).replace(tzinfo=timezone.utc)
-                    if forecast_time >= now:
+                    # Convertir la hora de la predicción a la hora local
+                    forecast_time_local = self._convert_to_local_time(forecast_time)
+                    if forecast_time_local >= now:
                         return True
 
             return False
@@ -670,32 +682,36 @@ class HourlyForecastCoordinator(DataUpdateCoordinator):
 
         return {}
 
-    def parse_hourly_forecast(self, dia: dict, forecast_time: datetime) -> dict:
+    def parse_hourly_forecast(self, dia: dict, forecast_time_local: datetime) -> dict:
         """Convierte una hora de predicción en un diccionario con los datos necesarios."""
         variables = dia.get("variables", {})
+
+        # Buscar el código de condición correspondiente al tiempo objetivo (en hora local)
         condition_code = next(
             (item["valor"] for item in variables.get("estatCel", {}).get("valors", []) if
-             datetime.fromisoformat(item["data"].rstrip("Z")).replace(tzinfo=timezone.utc) == forecast_time),
+            self._convert_to_local_time(
+                datetime.fromisoformat(item["data"].rstrip("Z")).replace(tzinfo=timezone.utc)
+            ) == forecast_time_local),
             -1,
         )
-        
+
         # Determinar la condición usando `get_condition_from_statcel`
         condition_data = get_condition_from_statcel(
             codi_estatcel=condition_code,
-            current_time=forecast_time,
+            current_time=forecast_time_local,
             hass=self.hass,
             is_hourly=True
         )
         condition = condition_data["condition"]
 
         return {
-            "datetime": forecast_time.isoformat(),
-            "temperature": self._get_variable_value(dia, "temp", forecast_time),
-            "precipitation": self._get_variable_value(dia, "precipitacio", forecast_time),
+            "datetime": forecast_time_local.isoformat(),
+            "temperature": self._get_variable_value(dia, "temp", forecast_time_local),
+            "precipitation": self._get_variable_value(dia, "precipitacio", forecast_time_local),
             "condition": condition,
-            "wind_speed": self._get_variable_value(dia, "velVent", forecast_time),
-            "wind_bearing": self._get_variable_value(dia, "dirVent", forecast_time),
-            "humidity": self._get_variable_value(dia, "humitat", forecast_time),
+            "wind_speed": self._get_variable_value(dia, "velVent", forecast_time_local),
+            "wind_bearing": self._get_variable_value(dia, "dirVent", forecast_time_local),
+            "humidity": self._get_variable_value(dia, "humitat", forecast_time_local),
         }
 
     def get_all_hourly_forecasts(self) -> list[dict]:
@@ -704,12 +720,14 @@ class HourlyForecastCoordinator(DataUpdateCoordinator):
             return []
 
         forecasts = []
-        now = datetime.now(timezone.utc)
+        now = datetime.now(TIMEZONE)
         for dia in self.data["dies"]:
             for forecast in dia.get("variables", {}).get("estatCel", {}).get("valors", []):
                 forecast_time = datetime.fromisoformat(forecast["data"].rstrip("Z")).replace(tzinfo=timezone.utc)
-                if forecast_time >= now:
-                    forecasts.append(self.parse_hourly_forecast(dia, forecast_time))
+                # Convertir la hora de la predicción a la hora local
+                forecast_time_local = self._convert_to_local_time(forecast_time)
+                if forecast_time_local >= now:
+                    forecasts.append(self.parse_hourly_forecast(dia, forecast_time_local))
         return forecasts
 
     def _get_variable_value(self, dia, variable_name, target_time):
@@ -727,8 +745,12 @@ class HourlyForecastCoordinator(DataUpdateCoordinator):
 
         for valor in valores:
             try:
+                # Convertir tiempo del JSON a hora local
                 data_hora = datetime.fromisoformat(valor["data"].rstrip("Z")).replace(tzinfo=timezone.utc)
-                if data_hora == target_time:
+                data_hora_local = self._convert_to_local_time(data_hora)
+
+                # Comparar con tiempo objetivo en hora local
+                if data_hora_local == target_time:
                     return float(valor["valor"])
             except (KeyError, ValueError) as e:
                 _LOGGER.warning("Error procesando '%s' para %s: %s", variable_name, valor, e)
@@ -764,6 +786,16 @@ class DailyForecastCoordinator(DataUpdateCoordinator):
             update_interval=DEFAULT_DAILY_FORECAST_UPDATE_INTERVAL,
         )
 
+    def _convert_to_local_date(self, forecast_time: datetime) -> datetime.date:
+        """Convierte una hora UTC a la fecha local en la zona horaria de Madrid, considerando el horario de verano."""
+        # Asegura que forecast_time es datetime y no date
+        if not isinstance(forecast_time, datetime):
+            forecast_time = datetime.combine(forecast_time, time(0, tzinfo=timezone.utc))
+
+        # Convertir la hora UTC a la hora local y extraer solo la fecha
+        local_datetime = forecast_time.astimezone(TIMEZONE)
+        return local_datetime.date()
+
     async def _is_data_valid(self) -> bool:
         """Verifica si hay datos válidos y actuales en el archivo JSON."""
         if not os.path.exists(self.file_path):
@@ -777,10 +809,11 @@ class DailyForecastCoordinator(DataUpdateCoordinator):
             if not data or "dies" not in data or not data["dies"]:
                 return False
 
-            today = datetime.now(timezone.utc).date()
+            today = datetime.now(TIMEZONE).date()
             for dia in data["dies"]:
                 forecast_date = datetime.fromisoformat(dia["data"].rstrip("Z")).date()
-                if forecast_date >= today:
+                forecast_date_local = self._convert_to_local_date(forecast_date)
+                if forecast_date_local >= today:
                     return True
 
             return False
@@ -797,11 +830,15 @@ class DailyForecastCoordinator(DataUpdateCoordinator):
                     data = json.loads(content)
 
                 # Filtrar días pasados
-                today = datetime.now(timezone.utc).date()
-                data["dies"] = [
-                    dia for dia in data["dies"]
-                    if datetime.fromisoformat(dia["data"].rstrip("Z")).date() >= today
-                ]
+                today = datetime.now(TIMEZONE).date()
+                filtered_days = []
+                for dia in data["dies"]:
+                    forecast_date = datetime.fromisoformat(dia["data"].rstrip("Z"))
+                    forecast_date_local = self._convert_to_local_date(forecast_date)
+                    if forecast_date_local >= today:
+                        filtered_days.append(dia)
+
+                data["dies"] = filtered_days
                 return data
             except Exception as e:
                 _LOGGER.warning("Error leyendo archivo de predicción diaria: %s", e)
@@ -813,10 +850,11 @@ class DailyForecastCoordinator(DataUpdateCoordinator):
         if not self.data or "dies" not in self.data or not self.data["dies"]:
             return None
 
-        today = datetime.now(timezone.utc).date()
+        today = datetime.now(TIMEZONE).date()
         for dia in self.data["dies"]:
             forecast_date = datetime.fromisoformat(dia["data"].rstrip("Z")).date()
-            if forecast_date == today:
+            forecast_date_local = self._convert_to_local_date(forecast_date)
+            if forecast_date_local == today:
                 return dia
         return None
 
@@ -826,8 +864,12 @@ class DailyForecastCoordinator(DataUpdateCoordinator):
         condition_code = variables.get("estatCel", {}).get("valor", -1)
         condition = get_condition_from_code(int(condition_code))
 
+        # Usar la fecha original del pronóstico
+        forecast_date = datetime.fromisoformat(dia["data"].rstrip("Z"))
+        forecast_date_local = self._convert_to_local_date(forecast_date)
+
         forecast_data = {
-            "date": datetime.fromisoformat(dia["data"].rstrip("Z")).date(),
+            "date": forecast_date_local.isoformat(),
             "temperature_max": float(variables.get("tmax", {}).get("valor", 0.0)),
             "temperature_min": float(variables.get("tmin", {}).get("valor", 0.0)),
             "precipitation": float(variables.get("precipitacio", {}).get("valor", 0.0)),
@@ -903,11 +945,15 @@ class MeteocatConditionCoordinator(DataUpdateCoordinator):
             return self.DEFAULT_CONDITION
 
         return self._get_condition_for_current_hour(raw_data) or self.DEFAULT_CONDITION
+    
+    def _convert_to_local_time(self, forecast_time: datetime) -> datetime:
+        """Convierte una hora UTC a la hora local en la zona horaria de Madrid, considerando el horario de verano."""
+        return forecast_time.astimezone(TIMEZONE)
 
     def _get_condition_for_current_hour(self, raw_data):
         """Get condition data for the current hour."""
         # Fecha y hora actual
-        current_datetime = datetime.now()
+        current_datetime = datetime.now(TIMEZONE)
         current_date = current_datetime.strftime("%Y-%m-%d")
         current_hour = current_datetime.hour
 
@@ -915,8 +961,9 @@ class MeteocatConditionCoordinator(DataUpdateCoordinator):
         for day in raw_data.get("dies", []):
             if day["data"].startswith(current_date):
                 for value in day["variables"]["estatCel"]["valors"]:
-                    data_hour = datetime.fromisoformat(value["data"])
-                    if data_hour.hour == current_hour:
+                    data_hour = datetime.fromisoformat(value["data"]).replace(tzinfo=ZoneInfo("UTC"))
+                    local_hour = self._convert_to_local_time(data_hour)
+                    if local_hour.hour == current_hour:
                         codi_estatcel = value["valor"]
                         condition = get_condition_from_statcel(
                             codi_estatcel,
@@ -973,6 +1020,11 @@ class MeteocatTempForecastCoordinator(DataUpdateCoordinator):
             update_interval=DEFAULT_TEMP_FORECAST_UPDATE_INTERVAL,
         )
 
+    def _convert_to_local_time(self, forecast_time: datetime) -> datetime:
+        """Convierte una hora UTC a la hora local en la zona horaria de Madrid, considerando el horario de verano."""
+        local_time = forecast_time.astimezone(TIMEZONE)
+        return local_time
+
     async def _is_data_valid(self) -> bool:
         """Verifica si hay datos válidos y actuales en el archivo JSON."""
         if not os.path.exists(self.file_path):
@@ -986,16 +1038,18 @@ class MeteocatTempForecastCoordinator(DataUpdateCoordinator):
             if not data or "dies" not in data or not data["dies"]:
                 return False
 
-            today = datetime.now(timezone.utc).date()
-            for dia in data["dies"]:
-                forecast_date = datetime.fromisoformat(dia["data"].rstrip("Z")).date()
-                if forecast_date >= today:
-                    return True
-
-            return False
+            today = datetime.now(TIMEZONE).date()
+            if any(
+                self._convert_to_local_time(
+                    datetime.fromisoformat(dia["data"].rstrip("Z")).replace(tzinfo=timezone.utc)
+                ).date() >= today
+                for dia in data["dies"]
+            ):
+                return True
         except Exception as e:
             _LOGGER.warning("Error validando datos diarios en %s: %s", self.file_path, e)
-            return False
+
+        return False
 
     async def _async_update_data(self) -> dict:
         """Lee y filtra los datos de predicción diaria desde el archivo local."""
@@ -1005,20 +1059,22 @@ class MeteocatTempForecastCoordinator(DataUpdateCoordinator):
                     content = await f.read()
                     data = json.loads(content)
 
-                # Filtrar días pasados
-                today = datetime.now(timezone.utc).date()
+                today = datetime.now(TIMEZONE).date()
                 data["dies"] = [
                     dia for dia in data["dies"]
-                    if datetime.fromisoformat(dia["data"].rstrip("Z")).date() >= today
+                    if self._convert_to_local_time(
+                        datetime.fromisoformat(dia["data"].rstrip("Z")).replace(tzinfo=timezone.utc)
+                    ).date() >= today
                 ]
 
-                # Usar datos de temperatura del día actual si están disponibles
                 today_temp_forecast = self.get_temp_forecast_for_today(data)
                 if today_temp_forecast:
                     parsed_data = self.parse_temp_forecast(today_temp_forecast)
                     return parsed_data
             except Exception as e:
-                _LOGGER.warning("Error leyendo temperaturas del archivo de predicción diaria: %s", e)
+                _LOGGER.warning(
+                    "Error leyendo temperaturas del archivo de predicción diaria '%s': %s", self.file_path, e
+                )
 
         return {}
 
@@ -1027,19 +1083,21 @@ class MeteocatTempForecastCoordinator(DataUpdateCoordinator):
         if not data or "dies" not in data or not data["dies"]:
             return None
 
-        today = datetime.now(timezone.utc).date()
+        today = datetime.now(TIMEZONE).date()
         for dia in data["dies"]:
-            forecast_date = datetime.fromisoformat(dia["data"].rstrip("Z")).date()
-            if forecast_date == today:
+            forecast_date_utc = datetime.fromisoformat(dia["data"].rstrip("Z")).replace(tzinfo=timezone.utc)
+            forecast_date_local = self._convert_to_local_time(forecast_date_utc)
+            if forecast_date_local.date() == today:
                 return dia
         return None
 
     def parse_temp_forecast(self, dia: dict) -> dict:
         """Convierte la temperatura de un día de predicción en un diccionario con los datos necesarios."""
         variables = dia.get("variables", {})
+        forecast_date_utc = datetime.fromisoformat(dia["data"].rstrip("Z")).replace(tzinfo=timezone.utc)
 
         temp_forecast_data = {
-            "date": datetime.fromisoformat(dia["data"].rstrip("Z")).date(),
+            "date": self._convert_to_local_time(forecast_date_utc).date(),
             "max_temp_forecast": float(variables.get("tmax", {}).get("valor", 0.0)),
             "min_temp_forecast": float(variables.get("tmin", {}).get("valor", 0.0)),
         }

package/custom_components/meteocat/manifest.json

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

package/custom_components/meteocat/sensor.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 from datetime import datetime, timezone, time
+from zoneinfo import ZoneInfo 
 import logging
 from homeassistant.helpers.entity import (
     DeviceInfo,
@@ -327,6 +328,29 @@ async def async_setup_entry(hass, entry, async_add_entities: AddEntitiesCallback
         if description.key == UVI_FILE_STATUS
     )
 
+# Cambiar UTC a la zona horaria local
+def convert_to_local_time(utc_time: str, local_tz: str = "Europe/Madrid") -> datetime | None:
+    """
+    Convierte una fecha/hora UTC en formato ISO 8601 a la zona horaria local especificada.
+
+    Args:
+        utc_time (str): Fecha/hora en formato ISO 8601 (ejemplo: '2025-01-02T12:00:00Z').
+        local_tz (str): Zona horaria local en formato IANA (por defecto, 'Europe/Madrid').
+
+    Returns:
+        datetime | None: Objeto datetime convertido a la zona horaria local, o None si hay un error.
+    """
+    try:
+        # Convertir la cadena UTC a un objeto datetime
+        utc_dt = datetime.fromisoformat(utc_time.replace("Z", "+00:00"))
+        
+        # Convertir a la zona horaria local usando ZoneInfo
+        local_dt = utc_dt.replace(tzinfo=ZoneInfo("UTC")).astimezone(ZoneInfo(local_tz))
+        
+        return local_dt
+    except ValueError:
+        return None
+
 class MeteocatStaticSensor(CoordinatorEntity[MeteocatStaticSensorCoordinator], SensorEntity):
     """Representation of a static Meteocat sensor."""
     STATIC_KEYS = {TOWN_NAME, TOWN_ID, STATION_NAME, STATION_ID}
@@ -633,9 +657,13 @@ class MeteocatSensor(CoordinatorEntity[MeteocatSensorCoordinator], SensorEntity)
                         if raw_timestamp:
                             # Convertir el timestamp a un objeto datetime
                             try:
-                                return datetime.fromisoformat(raw_timestamp.replace("Z", "+00:00"))
+                                # Convertimos raw_timestamp a hora local
+                                local_time = convert_to_local_time(raw_timestamp)
+                                _LOGGER.debug("Hora UTC: %s convertida a hora local: %s", raw_timestamp, local_time)
+                                return local_time
                             except ValueError:
                                 # Manejo de errores si el formato no es válido
+                                _LOGGER.error(f"Error al convertir el timestamp '{raw_timestamp}' a hora local.")
                                 return None
 
         # Nuevo sensor para la precipitación acumulada

package/custom_components/meteocat/version.py

@@ -1,2 +1,2 @@
 # version.py
-__version__ = "0.1.46"
+__version__ = "0.1.48"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "meteocat",
-  "version": "0.1.46",
+  "version": "0.1.48",
   "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.46"
+version = "0.1.48"
 description = "Script para obtener datos meteorológicos de la API de Meteocat"
 authors = ["figorr <jdcuartero@yahoo.es>"]
 license = "Apache-2.0"