meteocat 0.1.40 → 0.1.41

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [0.1.41](https://github.com/figorr/meteocat/compare/v0.1.40...v0.1.41) (2024-12-27)
+
+
+### Bug Fixes
+
+* 0.1.41 ([ba2c800](https://github.com/figorr/meteocat/commit/ba2c80048cc2da6efe5f950a5d8fb958a53a7ef6))
+* add new Max and Min Today Temperature sensors ([6cc726d](https://github.com/figorr/meteocat/commit/6cc726d127432ddc13a54638157f1f9566967ed4))
+* add Today temp max and min translations ([8e1d31e](https://github.com/figorr/meteocat/commit/8e1d31e78c1d5df61c37635a19d95b6339f0b0a5))
+* add Today temp max and min translations ([041c3ab](https://github.com/figorr/meteocat/commit/041c3ab877b269f3b3d3359792ecf13b14969466))
+* add Today temp max and min translations ([be25fc4](https://github.com/figorr/meteocat/commit/be25fc43bef58e1cecc2afaff8e0b8d3288399fb))
+* add Today temp max and min translations ([e236182](https://github.com/figorr/meteocat/commit/e236182dfe29b15c3eb06d6a8fd3e02712837858))
+* fix condition when is night ([fb64e0b](https://github.com/figorr/meteocat/commit/fb64e0b754eb5a39afe9135a0be842d5e8bdeae0))
+* fix sunset and sunrise events for night flag ([4770e56](https://github.com/figorr/meteocat/commit/4770e5633707933c0bdd2aae0f74ada363da86bb))
+
 ## [0.1.40](https://github.com/figorr/meteocat/compare/v0.1.39...v0.1.40) (2024-12-26)
 
 

package/custom_components/meteocat/__init__.py

@@ -17,6 +17,7 @@ from .coordinator import (
     HourlyForecastCoordinator,
     DailyForecastCoordinator,
     MeteocatConditionCoordinator,
+    MeteocatTempForecastCoordinator,
 )
 
 from .const import DOMAIN, PLATFORMS
@@ -24,7 +25,7 @@ from .const import DOMAIN, PLATFORMS
 _LOGGER = logging.getLogger(__name__)
 
 # Versión
-__version__ = "0.1.40"
+__version__ = "0.1.41"
 
 def safe_remove(path: Path, is_folder: bool = False):
     """Elimina de forma segura un archivo o carpeta si existe."""
@@ -91,6 +92,9 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
         condition_coordinator = MeteocatConditionCoordinator(hass=hass, entry_data=entry_data)
         await condition_coordinator.async_config_entry_first_refresh()
 
+        temp_forecast_coordinator = MeteocatTempForecastCoordinator(hass=hass, entry_data=entry_data)
+        await temp_forecast_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
@@ -106,6 +110,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
         "hourly_forecast_coordinator": hourly_forecast_coordinator,
         "daily_forecast_coordinator": daily_forecast_coordinator,
         "condition_coordinator": condition_coordinator,
+        "temp_forecast_coordinator": temp_forecast_coordinator,
         **entry_data,
     }
 

package/custom_components/meteocat/condition.py

@@ -3,7 +3,9 @@ from __future__ import annotations
 from datetime import datetime
 from .const import CONDITION_MAPPING
 from .helpers import is_night
+import logging
 
+_LOGGER = logging.getLogger(__name__)
 
 def get_condition_from_statcel(
     codi_estatcel, current_time: datetime, hass, is_hourly: bool = True
@@ -17,6 +19,13 @@ def get_condition_from_statcel(
     :param is_hourly: Indica si los datos son de predicción horaria (True) o diaria (False).
     :return: Diccionario con la condición y el icono.
     """
+    
+    _LOGGER.debug(
+        "Entrando en get_condition_from_statcel con codi_estatcel: %s, is_hourly: %s",
+        codi_estatcel,
+        is_hourly,
+    )
+
     # Asegurarse de que codi_estatcel sea una lista válida
     if codi_estatcel is None:
         codi_estatcel = []
@@ -31,7 +40,19 @@ def get_condition_from_statcel(
         if any(code in codes for code in codi_estatcel):
             # Ajustar para condiciones nocturnas si aplica
             if condition == "sunny" and is_night_flag:
+                _LOGGER.debug(
+                    "Códigos EstatCel: %s, Es Noche: %s, Condición Devuelta: clear-night",
+                    codi_estatcel,
+                    is_night_flag,
+                )
                 return {"condition": "clear-night", "icon": None}
+            
+            _LOGGER.debug(
+                "Códigos EstatCel: %s, Es Noche: %s, Condición Devuelta: %s",
+                codi_estatcel,
+                is_night_flag,
+                condition,
+            )
             return {"condition": condition, "icon": None}
 
     # Si no coincide ningún código, devolver condición desconocida

package/custom_components/meteocat/const.py

@@ -32,6 +32,8 @@ FEELS_LIKE = "feels_like"  # Sensación térmica
 WIND_GUST = "wind_gust"  # Racha de viento
 STATION_TIMESTAMP = "station_timestamp"  # Código de tiempo de la estación
 CONDITION = "condition"  # Estado del cielo
+MAX_TEMPERATURE_FORECAST = "max_temperature_forecast"  # Temperatura máxima prevista
+MIN_TEMPERATURE_FORECAST = "min_temperature_forecast"  # Temperatura mínima prevista
 
 # Definición de códigos para variables
 WIND_SPEED_CODE = 30

package/custom_components/meteocat/coordinator.py

@@ -36,12 +36,13 @@ _LOGGER = logging.getLogger(__name__)
 # Valores predeterminados para los intervalos de actualización
 DEFAULT_SENSOR_UPDATE_INTERVAL = timedelta(minutes=90)
 DEFAULT_STATIC_SENSOR_UPDATE_INTERVAL = timedelta(hours=24)
-DEFAULT_ENTITY_UPDATE_INTERVAL = timedelta(hours=48)
+DEFAULT_ENTITY_UPDATE_INTERVAL = timedelta(minutes=60)
 DEFAULT_HOURLY_FORECAST_UPDATE_INTERVAL = timedelta(minutes=5)
 DEFAULT_DAILY_FORECAST_UPDATE_INTERVAL = timedelta(minutes=15)
-DEFAULT_UVI_UPDATE_INTERVAL = timedelta(hours=48)
+DEFAULT_UVI_UPDATE_INTERVAL = timedelta(minutes=60)
 DEFAULT_UVI_SENSOR_UPDATE_INTERVAL = timedelta(minutes=5)
 DEFAULT_CONDITION_SENSOR_UPDATE_INTERVAL = timedelta(minutes=5)
+DEFAULT_TEMP_FORECAST_UPDATE_INTERVAL = timedelta(minutes=5)
 
 async def save_json_to_file(data: dict, output_file: str) -> None:
     """Guarda datos JSON en un archivo de forma asíncrona."""
@@ -291,9 +292,9 @@ class MeteocatUviCoordinator(DataUpdateCoordinator):
             if not isinstance(uvi_data, list) or not uvi_data:
                 return None
 
-            # Validar la fecha del primer elemento
-            first_date = uvi_data[0].get("date")
-            if first_date != datetime.now(timezone.utc).strftime("%Y-%m-%d"):
+             # Validar la fecha del primer elemento superior a 1 día
+            first_date = datetime.strptime(uvi_data[0].get("date"), "%Y-%m-%d").date()
+            if (datetime.now(timezone.utc).date() - first_date).days > 1:
                 return None
 
             return data
@@ -489,7 +490,10 @@ class MeteocatEntityCoordinator(DataUpdateCoordinator):
 
             # Obtener la fecha del primer día
             first_date = datetime.fromisoformat(data["dies"][0]["data"].rstrip("Z")).date()
-            return first_date == datetime.now(timezone.utc).date()
+            today = datetime.now(timezone.utc).date()
+
+            # Verificar si la antigüedad es mayor a un día
+            return (today - first_date).days <= 1
         except Exception as e:
             _LOGGER.warning("Error validando datos en %s: %s", file_path, e)
             return False
@@ -646,7 +650,15 @@ class HourlyForecastCoordinator(DataUpdateCoordinator):
              datetime.fromisoformat(item["data"].rstrip("Z")).replace(tzinfo=timezone.utc) == forecast_time),
             -1,
         )
-        condition = get_condition_from_code(int(condition_code))
+        
+        # Determinar la condición usando `get_condition_from_statcel`
+        condition_data = get_condition_from_statcel(
+            codi_estatcel=condition_code,
+            current_time=forecast_time,
+            hass=self.hass,
+            is_hourly=True
+        )
+        condition = condition_data["condition"]
 
         return {
             "datetime": forecast_time.isoformat(),
@@ -842,6 +854,8 @@ class MeteocatConditionCoordinator(DataUpdateCoordinator):
 
     async def _async_update_data(self):
         """Read and process condition data for the current hour from the file asynchronously."""
+        _LOGGER.debug("Iniciando actualización de datos desde el archivo: %s", self._file_path)
+
         try:
             async with aiofiles.open(self._file_path, "r", encoding="utf-8") as file:
                 raw_data = await file.read()
@@ -889,6 +903,12 @@ class MeteocatConditionCoordinator(DataUpdateCoordinator):
                             "hour": current_hour,
                             "date": current_date,
                         })
+                        _LOGGER.debug(
+                            "Hora actual: %s, Código estatCel: %s, Condición procesada: %s",
+                            current_datetime,
+                            codi_estatcel,
+                            condition,
+                        )
                         return condition
                 break  # Sale del bucle una vez encontrada la fecha actual
 
@@ -900,3 +920,102 @@ class MeteocatConditionCoordinator(DataUpdateCoordinator):
         )
         return {"condition": "unknown", "hour": current_hour, "icon": None, "date": current_date}
 
+class MeteocatTempForecastCoordinator(DataUpdateCoordinator):
+    """Coordinator para manejar las predicciones diarias desde archivos locales."""
+
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        entry_data: dict,
+        update_interval: timedelta = DEFAULT_TEMP_FORECAST_UPDATE_INTERVAL,
+    ):
+        """Inicializa el coordinador para predicciones diarias."""
+        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"]
+        self.file_path = os.path.join(
+            hass.config.path(),
+            "custom_components",
+            "meteocat",
+            "files",
+            f"forecast_{self.town_id.lower()}_daily_data.json",
+        )
+        super().__init__(
+            hass,
+            _LOGGER,
+            name=f"{DOMAIN} Daily Forecast Coordinator",
+            update_interval=update_interval,
+        )
+
+    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):
+            return False
+
+        try:
+            async with aiofiles.open(self.file_path, "r", encoding="utf-8") as f:
+                content = await f.read()
+                data = json.loads(content)
+
+            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
+        except Exception as e:
+            _LOGGER.warning("Error validando datos diarios en %s: %s", self.file_path, e)
+            return False
+
+    async def _async_update_data(self) -> dict:
+        """Lee y filtra los datos de predicción diaria desde el archivo local."""
+        if await self._is_data_valid():
+            try:
+                async with aiofiles.open(self.file_path, "r", encoding="utf-8") as f:
+                    content = await f.read()
+                    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
+                ]
+
+                # Usar datos 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_forecast(today_temp_forecast)
+                    return parsed_data
+            except Exception as e:
+                _LOGGER.warning("Error leyendo archivo de predicción diaria: %s", e)
+
+        return {}
+
+    def get_temp_forecast_for_today(self, data: dict) -> dict | None:
+        """Obtiene los datos diarios para el día actual."""
+        if not data or "dies" not in data or not data["dies"]:
+            return None
+
+        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 dia
+        return None
+
+    def parse_forecast(self, dia: dict) -> dict:
+        """Convierte un día de predicción en un diccionario con los datos necesarios."""
+        variables = dia.get("variables", {})
+
+        temp_forecast_data = {
+            "date": datetime.fromisoformat(dia["data"].rstrip("Z")).date(),
+            "max_temp_forecast": float(variables.get("tmax", {}).get("valor", 0.0)),
+            "min_temp_forecast": float(variables.get("tmin", {}).get("valor", 0.0)),
+        }
+        return temp_forecast_data

package/custom_components/meteocat/helpers.py

@@ -1,41 +1,51 @@
 from __future__ import annotations
 
 import logging
-from datetime import datetime, timedelta
-from homeassistant.core import HomeAssistant
-from homeassistant.util.dt import as_local, as_utc
-from homeassistant.helpers.sun import get_astral_event_next
+from datetime import datetime
+from homeassistant.util.dt import as_local, as_utc, start_of_local_day
+from homeassistant.helpers.sun import get_astral_event_date
 
 _LOGGER = logging.getLogger(__name__)
 
-def get_sun_times(hass: HomeAssistant, current_time: datetime | None = None):
-    """Get the sunrise and sunset times."""
-    # Usa la hora actual si no se proporciona una hora específica
+def get_sun_times(hass, current_time=None):
+    """Obtén las horas de amanecer y atardecer para el día actual."""
     if current_time is None:
         current_time = datetime.now()
 
-    # Asegúrate de que current_time es aware (UTC con offset)
+    # Asegúrate de que current_time es aware (UTC)
     current_time = as_utc(current_time)
+    today = start_of_local_day(as_local(current_time))
 
-    # Obtén los tiempos de amanecer y atardecer desde el helper
-    sunrise = get_astral_event_next(hass, "sunrise", utc_point_in_time=current_time)
-    sunset = get_astral_event_next(hass, "sunset", utc_point_in_time=current_time)
+    # Obtén los eventos de amanecer y atardecer del día actual
+    sunrise = get_astral_event_date(hass, "sunrise", today)
+    sunset = get_astral_event_date(hass, "sunset", today)
+
+    _LOGGER.debug(
+        "Sunrise: %s, Sunset: %s, Current Time: %s",
+        sunrise,
+        sunset,
+        as_local(current_time),
+    )
 
-    # Asegúrate de que no sean None y conviértelos a la zona horaria local
     if sunrise and sunset:
-        return as_local(sunrise), as_local(sunset)
+        return sunrise, sunset
 
-    # Lanza un error si no se pudieron determinar los eventos
-    raise ValueError("Sunrise or sunset data is unavailable.")
+    raise ValueError("No se pudieron determinar los datos de amanecer y atardecer.")
 
-def is_night(current_time: datetime, hass: HomeAssistant) -> bool:
-    """Determine if it is currently night based on sunrise and sunset times."""
-    # Convierte current_time a UTC si no tiene información de zona horaria
+def is_night(current_time, hass):
+    """Determina si actualmente es de noche."""
+    # Asegúrate de que current_time es aware (UTC)
     if current_time.tzinfo is None:
         current_time = as_utc(current_time)
 
-    # Obtén los tiempos de amanecer y atardecer
     sunrise, sunset = get_sun_times(hass, current_time)
 
-    # Compara las horas
+    _LOGGER.debug(
+        "Hora actual: %s, Amanecer: %s, Atardecer: %s",
+        as_local(current_time),
+        as_local(sunrise),
+        as_local(sunset),
+    )
+
+    # Es de noche si es antes del amanecer o después del atardecer
     return current_time < sunrise or current_time > sunset

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.40"
+    "version": "0.1.41"
 }

package/custom_components/meteocat/sensor.py

@@ -46,6 +46,8 @@ from .const import (
     WIND_GUST,
     STATION_TIMESTAMP,
     CONDITION,
+    MAX_TEMPERATURE_FORECAST,
+    MIN_TEMPERATURE_FORECAST,
     WIND_SPEED_CODE,
     WIND_DIRECTION_CODE,
     TEMPERATURE_CODE,
@@ -65,6 +67,7 @@ from .coordinator import (
     MeteocatStaticSensorCoordinator,
     MeteocatUviFileCoordinator,
     MeteocatConditionCoordinator,
+    MeteocatTempForecastCoordinator,
 )
 
 _LOGGER = logging.getLogger(__name__)
@@ -209,7 +212,23 @@ SENSOR_TYPES: tuple[MeteocatSensorEntityDescription, ...] = (
         key=CONDITION,
         translation_key="condition",
         icon="mdi:weather-partly-cloudy",
-    )
+    ),
+     MeteocatSensorEntityDescription(
+        key=MAX_TEMPERATURE_FORECAST,
+        translation_key="max_temperature_forecast",
+        icon="mdi:thermometer-plus",
+        device_class=SensorDeviceClass.TEMPERATURE,
+        state_class=SensorStateClass.MEASUREMENT,
+        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
+    ),
+    MeteocatSensorEntityDescription(
+        key=MIN_TEMPERATURE_FORECAST,
+        translation_key="min_temperature_forecast",
+        icon="mdi:thermometer-minus",
+        device_class=SensorDeviceClass.TEMPERATURE,
+        state_class=SensorStateClass.MEASUREMENT,
+        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
+    ),
 )
 
 @callback
@@ -222,12 +241,13 @@ async def async_setup_entry(hass, entry, async_add_entities: AddEntitiesCallback
     uvi_file_coordinator = entry_data.get("uvi_file_coordinator")
     static_sensor_coordinator = entry_data.get("static_sensor_coordinator")
     condition_coordinator = entry_data.get("condition_coordinator")
+    temp_forecast_coordinator = entry_data.get("temp_forecast_coordinator")
 
     # Sensores generales
     async_add_entities(
         MeteocatSensor(coordinator, description, entry_data)
         for description in SENSOR_TYPES
-        if description.key not in {TOWN_NAME, TOWN_ID, STATION_NAME, STATION_ID, UV_INDEX, CONDITION}  # Excluir estáticos y UVI
+        if description.key not in {TOWN_NAME, TOWN_ID, STATION_NAME, STATION_ID, UV_INDEX, CONDITION, MAX_TEMPERATURE_FORECAST, MIN_TEMPERATURE_FORECAST}  # Excluir estáticos y UVI
     )
 
     # Sensores estáticos
@@ -251,6 +271,13 @@ async def async_setup_entry(hass, entry, async_add_entities: AddEntitiesCallback
         if description.key == CONDITION  # Incluir CONDITION en el coordinador CONDITION COORDINATOR
     )
 
+    # Sensores temperatura previsión
+    async_add_entities(
+        MeteocatTempForecast(temp_forecast_coordinator, description, entry_data)
+        for description in SENSOR_TYPES
+        if description.key in {MAX_TEMPERATURE_FORECAST, MIN_TEMPERATURE_FORECAST}
+    )
+
 class MeteocatStaticSensor(CoordinatorEntity[MeteocatStaticSensorCoordinator], SensorEntity):
     """Representation of a static Meteocat sensor."""
     STATIC_KEYS = {TOWN_NAME, TOWN_ID, STATION_NAME, STATION_ID}
@@ -543,7 +570,7 @@ class MeteocatSensor(CoordinatorEntity[MeteocatSensorCoordinator], SensorEntity)
                         return value
                     
         # Lógica específica para el sensor de timestamp
-        if self.entity_description.key == "station_timestamp":
+        if self.entity_description.key == STATION_TIMESTAMP:
             stations = self.coordinator.data or []
             for station in stations:
                 variables = station.get("variables", [])
@@ -563,7 +590,7 @@ class MeteocatSensor(CoordinatorEntity[MeteocatSensorCoordinator], SensorEntity)
                                 return None
 
         # Nuevo sensor para la precipitación acumulada
-        if self.entity_description.key == "precipitation_accumulated":
+        if self.entity_description.key == PRECIPITATION_ACCUMULATED:
             stations = self.coordinator.data or []
             total_precipitation = 0.0  # Usa float para permitir acumulación de decimales
 
@@ -644,3 +671,50 @@ class MeteocatSensor(CoordinatorEntity[MeteocatSensorCoordinator], SensorEntity)
             manufacturer="Meteocat",
             model="Meteocat API",
         )
+
+class MeteocatTempForecast(CoordinatorEntity[MeteocatTempForecastCoordinator], 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, temp_forecast_coordinator, description, entry_data):
+        """Initialize the UV Index sensor."""
+        super().__init__(temp_forecast_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 Max and Min Temp Forecast value."""
+        temp_forecast_data = self.coordinator.data or {}
+        
+        if self.entity_description.key == MAX_TEMPERATURE_FORECAST:
+            return temp_forecast_data.get("max_temp_forecast", None)
+        if self.entity_description.key == MIN_TEMPERATURE_FORECAST:
+            return temp_forecast_data.get("min_temp_forecast", None)
+        return None
+
+    @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",
+        )

package/custom_components/meteocat/strings.json

@@ -127,6 +127,12 @@
             "name": "Hour"
           }
         }
+      },
+      "max_temperature_forecast": {
+        "name": "Max Temperature Today"
+      },
+      "min_temperature_forecast": {
+        "name": "Min Temperature Today"
       }
     }
   }

package/custom_components/meteocat/translations/ca.json

@@ -127,7 +127,14 @@
             "name": "Hora"
           }
         }
+      },
+      "max_temperature_forecast": {
+        "name": "Temperatura Max Avui"
+      },
+      "min_temperature_forecast": {
+        "name": "Temperatura Min Avui"
       }
     }
   }
-}   
+}
+  

package/custom_components/meteocat/translations/en.json

@@ -127,8 +127,14 @@
             "name": "Hour"
           }
         }
+      },
+      "max_temperature_forecast": {
+        "name": "Max Temperature Today"
+      },
+      "min_temperature_forecast": {
+        "name": "Min Temperature Today"
       }
     }
   }
 }
-  
+ 

package/custom_components/meteocat/translations/es.json

@@ -127,6 +127,12 @@
             "name": "Hora"
           }
         }
+      },
+      "max_temperature_forecast": {
+        "name": "Temperatura Max Hoy"
+      },
+      "min_temperature_forecast": {
+        "name": "Temperatura Min Hoy"
       }
     }
   }

package/custom_components/meteocat/version.py

@@ -1,2 +1,2 @@
 # version.py
-__version__ = "0.1.40"
+__version__ = "0.1.41"

package/package.json

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