meteocat 2.2.4 → 2.2.6

package/.github/workflows/stale.yml

@@ -0,0 +1,51 @@
+name: Mark stale issues and pull requests
+
+on:
+  schedule:
+    - cron: "30 1 * * *"  # Ejecutar diariamente a la 01:30 UTC
+  workflow_dispatch:       # Permite ejecución manual desde la interfaz
+
+jobs:
+  stale:
+    runs-on: ubuntu-latest
+    permissions:
+      issues: write
+      pull-requests: write
+
+    steps:
+      # 1. Issues/PRs generales sin actividad (excepto etiquetados)
+      - uses: actions/stale@v8
+        with:
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+          days-before-stale: 60
+          days-before-close: 7
+          exempt-issue-labels: "help wanted,bug,feature"
+          exempt-pr-labels: "help wanted"
+          stale-issue-message: "This issue has had no activity for 60 days and will be closed in a week if there is no further activity."
+          stale-pr-message: "This pull request has had no activity for 60 days and will be closed in a week if there is no further activity."
+          stale-issue-label: "stale"
+          stale-pr-label: "stale"
+
+      # 2. Issues tipo "feature" sin actividad (solo etiquetar)
+      - uses: actions/stale@v8
+        with:
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+          only-labels: "feature"
+          days-before-stale: 21
+          days-before-close: -1
+          stale-issue-message: >-
+            This feature request has had no activity for 3 weeks.
+            It has been marked as *help wanted* and will remain open.
+          stale-issue-label: "help wanted"
+
+      # 3. Issues tipo "bug" sin actividad (solo etiquetar)
+      - uses: actions/stale@v8
+        with:
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+          only-labels: "bug"
+          days-before-stale: 21
+          days-before-close: -1
+          stale-issue-message: >-
+            This bug report has had no activity for 3 weeks.
+            It has been marked as *help wanted* and will remain open.
+          stale-issue-label: "help wanted"

package/CHANGELOG.md

@@ -1,3 +1,23 @@
+## [2.2.6](https://github.com/figorr/meteocat/compare/v2.2.5...v2.2.6) (2025-08-27)
+
+
+### Bug Fixes
+
+* 2.2.6 ([bb92000](https://github.com/figorr/meteocat/commit/bb9200099ed951168bc891c870c6fd61b758c73d))
+* Fix alerts region data update at first setup of the next entrances ([40018dc](https://github.com/figorr/meteocat/commit/40018dc0bb703a8dc606aaedcfa27b5c3e6bbf7a))
+* Fix delete an entry but keeping common files for the rest of entries ([211e545](https://github.com/figorr/meteocat/commit/211e54510c458378ca46c465303995d1a9df0dbb))
+* Fix region alerts json file for multiple entrances ([2b7072c](https://github.com/figorr/meteocat/commit/2b7072cb6fd7eafa1ab95dcedb2c2dea8f35005d))
+
+## [2.2.5](https://github.com/figorr/meteocat/compare/v2.2.4...v2.2.5) (2025-02-16)
+
+
+### Bug Fixes
+
+* 2.2.5 ([cd8fb52](https://github.com/figorr/meteocat/commit/cd8fb52c607e3a74308246136b6ac2d47b51e125))
+* fix lightning status sensor native value ([dc3badc](https://github.com/figorr/meteocat/commit/dc3badc7b66d9afbcc14e23da3f0909f845cef2f))
+* fix validity at lightning coordinator and cached data ([d959bc5](https://github.com/figorr/meteocat/commit/d959bc56dfb19a475b2e34a2649bbabd803ab41e))
+* new lighting validity hour ([eab0215](https://github.com/figorr/meteocat/commit/eab0215cc3d68de9f900a4ecf1844ef3c6c22610))
+
 ## [2.2.4](https://github.com/figorr/meteocat/compare/v2.2.3...v2.2.4) (2025-02-09)
 
 

package/custom_components/meteocat/__init__.py

@@ -33,7 +33,7 @@ from .const import DOMAIN, PLATFORMS
 _LOGGER = logging.getLogger(__name__)
 
 # Versión
-__version__ = "2.2.4"
+__version__ = "2.2.6"
 
 # Definir el esquema de configuración CONFIG_SCHEMA
 CONFIG_SCHEMA = vol.Schema(
@@ -192,68 +192,48 @@ 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 las rutas base a eliminar
+    # Definir las rutas base
     custom_components_path = Path(hass.config.path("custom_components")) / DOMAIN
     assets_folder = custom_components_path / "assets"
     files_folder = custom_components_path / "files"
 
-    # Definir archivos relacionados a eliminar
+    # Archivos comunes
     symbols_file = assets_folder / "symbols.json"
     variables_file = assets_folder / "variables.json"
+    alerts_file = files_folder / "alerts.json"
+    quotes_file = files_folder / "quotes.json"
 
-    # Obtener el `station_id` para identificar el archivo a eliminar
+    # Archivos específicos de cada entry
     station_id = entry.data.get("station_id")
-    if not station_id:
-        _LOGGER.warning("No se encontró 'station_id' en la configuración. No se puede eliminar el archivo de datos de la estación.")
-        return
-
-    # 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"
-
-    # Arhivos JSON de las predicciones del municipio a eliminar
-    forecast_hourly_data_file = files_folder / f"forecast_{town_id.lower()}_hourly_data.json"
-    forecast_daily_data_file = files_folder / f"forecast_{town_id.lower()}_daily_data.json"
-
-    # Obtener el `region_id` para identificar el archivo a eliminar
     region_id = entry.data.get("region_id")
-    if not region_id:
-        _LOGGER.warning("No se encontró 'region_id' en la configuración. No se puede eliminar el archivo de alertas de la comarca.")
-        return
-
-    # Archivos JSON de alertas
-    alerts_file = files_folder / "alerts.json"
-    alerts_region_file = files_folder / f"alerts_{region_id}.json"
-
-    # Archivo JSON de cuotas
-    quotes_file = files_folder / f"quotes.json"
 
-    # Archivo JSON de rayos
-    lightning_file = files_folder / f"lightning_{region_id}.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.")
         return
 
-    # Eliminar archivos y carpetas
+    # Eliminar archivos específicos de la entrada
+    if station_id:
+        safe_remove(files_folder / f"station_{station_id.lower()}_data.json")
+    if town_id:
+        safe_remove(files_folder / f"uvi_{town_id.lower()}_data.json")
+        safe_remove(files_folder / f"forecast_{town_id.lower()}_hourly_data.json")
+        safe_remove(files_folder / f"forecast_{town_id.lower()}_daily_data.json")
+    if region_id:
+        safe_remove(files_folder / f"alerts_{region_id}.json")
+        safe_remove(files_folder / f"lightning_{region_id}.json")
+
+    # Siempre eliminables
     safe_remove(symbols_file)
     safe_remove(variables_file)
-    safe_remove(station_data_file)
-    safe_remove(town_data_file)
-    safe_remove(forecast_hourly_data_file)
-    safe_remove(forecast_daily_data_file)
-    safe_remove(alerts_file)
-    safe_remove(quotes_file)
-    safe_remove(alerts_region_file)
-    safe_remove(lightning_file)
-    safe_remove(assets_folder, is_folder=True)
-    safe_remove(files_folder, is_folder=True)
+
+    # 🔑 Solo eliminar los archivos comunes si ya no quedan otras entradas
+    remaining_entries = [
+        e for e in hass.config_entries.async_entries(DOMAIN)
+        if e.entry_id != entry.entry_id
+    ]
+    if not remaining_entries:  # significa que estamos borrando la última
+        safe_remove(alerts_file)
+        safe_remove(quotes_file)
+        safe_remove(assets_folder, is_folder=True)
+        safe_remove(files_folder, is_folder=True)

package/custom_components/meteocat/config_flow.py

@@ -10,14 +10,13 @@ from datetime import datetime, timezone
 from zoneinfo import ZoneInfo
 
 import voluptuous as vol
-from aiohttp import ClientError
 import aiofiles
 import unicodedata
 
 from homeassistant.config_entries import ConfigEntry, ConfigFlow, ConfigFlowResult
 from homeassistant.core import callback
 from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers import aiohttp_client, config_validation as cv
+from homeassistant.helpers import config_validation as cv
 
 from .const import (
     DOMAIN,
@@ -38,12 +37,12 @@ from .const import (
     PROVINCE_NAME,
     STATION_STATUS,
     LIMIT_XEMA,
-	LIMIT_PREDICCIO,
+    LIMIT_PREDICCIO,
     LIMIT_XDDE,
     LIMIT_BASIC,
     LIMIT_QUOTA
 )
-    
+
 from .options_flow import MeteocatOptionsFlowHandler
 from meteocatpy.town import MeteocatTown
 from meteocatpy.symbols import MeteocatSymbols
@@ -51,18 +50,22 @@ from meteocatpy.variables import MeteocatVariables
 from meteocatpy.townstations import MeteocatTownStations
 from meteocatpy.infostation import MeteocatInfoStation
 from meteocatpy.quotes import MeteocatQuotes
-
 from meteocatpy.exceptions import BadRequestError, ForbiddenError, TooManyRequestsError, InternalServerError, UnknownAPIError
 
 _LOGGER = logging.getLogger(__name__)
-
 TIMEZONE = ZoneInfo("Europe/Madrid")
 
-def normalize_name(name):
+INITIAL_TEMPLATE = {
+    "actualitzat": {"dataUpdate": "1970-01-01T00:00:00+00:00"},
+    "dades": []
+}
+
+def normalize_name(name: str) -> str:
     """Normaliza el nombre eliminando acentos y convirtiendo a minúsculas."""
     name = unicodedata.normalize("NFKD", name).encode("ASCII", "ignore").decode("utf-8")
     return name.lower()
 
+
 class MeteocatConfigFlow(ConfigFlow, domain=DOMAIN):
     """Flujo de configuración para Meteocat."""
 
@@ -76,27 +79,25 @@ class MeteocatConfigFlow(ConfigFlow, domain=DOMAIN):
         self.station_id: str | None = None
         self.station_name: str | None = None
         self.region_id: str | None = None
-        self._cache = {}
-
-    async def fetch_and_save_quotes(self, api_key):
+        self.region_name: str | None = None
+        self.province_id: str | None = None
+        self.province_name: str | None = None
+        self.station_type: str | None = None
+        self.latitude: float | None = None
+        self.longitude: float | None = None
+        self.altitude: float | None = None
+        self.station_status: str | None = None
+
+    async def fetch_and_save_quotes(self, api_key: str):
         """Obtiene las cuotas de la API de Meteocat y las guarda en quotes.json."""
         meteocat_quotes = MeteocatQuotes(api_key)
-        quotes_dir = os.path.join(
-            self.hass.config.path(),
-            "custom_components",
-            "meteocat",
-            "files"
-        )
+        quotes_dir = os.path.join(self.hass.config.path(), "custom_components", "meteocat", "files")
         os.makedirs(quotes_dir, exist_ok=True)
         quotes_file = os.path.join(quotes_dir, "quotes.json")
 
         try:
-            data = await asyncio.wait_for(
-                meteocat_quotes.get_quotes(),
-                timeout=30
-            )
-            
-            # Modificar los nombres de los planes con normalización
+            data = await asyncio.wait_for(meteocat_quotes.get_quotes(), timeout=30)
+
             plan_mapping = {
                 "xdde_": "XDDE",
                 "prediccio_": "Prediccio",
@@ -109,7 +110,6 @@ class MeteocatConfigFlow(ConfigFlow, domain=DOMAIN):
             for plan in data["plans"]:
                 normalized_nom = normalize_name(plan["nom"])
                 new_name = next((v for k, v in plan_mapping.items() if normalized_nom.startswith(k)), plan["nom"])
-
                 modified_plans.append({
                     "nom": new_name,
                     "periode": plan["periode"],
@@ -118,28 +118,23 @@ class MeteocatConfigFlow(ConfigFlow, domain=DOMAIN):
                     "consultesRealitzades": plan["consultesRealitzades"]
                 })
 
-            # Añadir la clave 'actualitzat' con la fecha y hora actual de la zona horaria local
             current_time = datetime.now(timezone.utc).astimezone(TIMEZONE).isoformat()
             data_with_timestamp = {
-                "actualitzat": {
-                    "dataUpdate": current_time
-                },
+                "actualitzat": {"dataUpdate": current_time},
                 "client": data["client"],
                 "plans": modified_plans
             }
 
-            # Guardar los datos en el archivo JSON
             async with aiofiles.open(quotes_file, "w", encoding="utf-8") as file:
                 await file.write(json.dumps(data_with_timestamp, ensure_ascii=False, indent=4))
-            
             _LOGGER.info("Cuotas guardadas exitosamente en %s", quotes_file)
 
         except Exception as ex:
             _LOGGER.error("Error al obtener o guardar las cuotas: %s", ex)
             raise HomeAssistantError("No se pudieron obtener las cuotas de la API")
-    
+
     async def create_alerts_file(self):
-        """Crea el archivo alerts.json si no existe."""
+        """Crea los archivos de alertas global y regional si no existen."""
         alerts_dir = os.path.join(
             self.hass.config.path(),
             "custom_components",
@@ -147,67 +142,44 @@ class MeteocatConfigFlow(ConfigFlow, domain=DOMAIN):
             "files"
         )
         os.makedirs(alerts_dir, exist_ok=True)
-        alerts_file = os.path.join(alerts_dir, "alerts.json")
 
+        # Archivo global de alertas
+        alerts_file = os.path.join(alerts_dir, "alerts.json")
         if not os.path.exists(alerts_file):
-            initial_data = {
-                "actualitzat": {
-                    "dataUpdate": "1970-01-01T00:00:00+00:00"
-                },
-                "dades": []
-            }
             async with aiofiles.open(alerts_file, "w", encoding="utf-8") as file:
-                await file.write(json.dumps(initial_data, ensure_ascii=False, indent=4))
-            
-            _LOGGER.info("Archivo alerts.json creado en %s", alerts_file)
-    
-    async def create_lightning_file(self):
-        """Crea el archivo lightning_{self.region_id}.json si no existe."""
-        lightning_dir = os.path.join(
-            self.hass.config.path(),
-            "custom_components",
-            "meteocat",
-            "files"
-        )
-        os.makedirs(lightning_dir, exist_ok=True)
-        lightning_file = os.path.join(lightning_dir, f"lightning_{self.region_id}.json")
-
-        if not os.path.exists(lightning_file):
-            initial_data = {
-                "actualitzat": {
-                    "dataUpdate": "1970-01-01T00:00:00+00:00"
-                },
-                "dades": []
-            }
-            async with aiofiles.open(lightning_file, "w", encoding="utf-8") as file:
-                await file.write(json.dumps(initial_data, ensure_ascii=False, indent=4))
-            
-            _LOGGER.info("Archivo %s creado", lightning_file)
-
-    async def async_step_user(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Primer paso: Solicitar la API Key."""
+                await file.write(json.dumps(INITIAL_TEMPLATE, ensure_ascii=False, indent=4))
+            _LOGGER.info("Archivo global %s creado con plantilla inicial", alerts_file)
+
+        # Solo si existe region_id
+        if self.region_id:
+            # Archivo regional de alertas
+            alerts_region_file = os.path.join(alerts_dir, f"alerts_{self.region_id}.json")
+            if not os.path.exists(alerts_region_file):
+                async with aiofiles.open(alerts_region_file, "w", encoding="utf-8") as file:
+                    await file.write(json.dumps(INITIAL_TEMPLATE, ensure_ascii=False, indent=4))
+                _LOGGER.info("Archivo regional %s creado con plantilla inicial", alerts_region_file)
+
+            # Archivo lightning regional
+            lightning_file = os.path.join(alerts_dir, f"lightning_{self.region_id}.json")
+            if not os.path.exists(lightning_file):
+                async with aiofiles.open(lightning_file, "w", encoding="utf-8") as file:
+                    await file.write(json.dumps(INITIAL_TEMPLATE, ensure_ascii=False, indent=4))
+                _LOGGER.info("Archivo lightning %s creado con plantilla inicial", lightning_file)
+
+    async def async_step_user(self, user_input: dict[str, Any] | None = None) -> ConfigFlowResult:
+        """Primer paso: solicitar API Key."""
         errors = {}
-
         if user_input is not None:
             self.api_key = user_input[CONF_API_KEY]
-
             town_client = MeteocatTown(self.api_key)
-
             try:
                 self.municipis = await town_client.get_municipis()
-                # Aquí obtenemos y guardamos las cuotas
                 await self.fetch_and_save_quotes(self.api_key)
-                # Aquí creamos el archivo alerts.json si no existe
+                # Crea solo el archivo global de alertas (regional se hará después)
                 await self.create_alerts_file()
-            except (BadRequestError, ForbiddenError, TooManyRequestsError, InternalServerError, UnknownAPIError) as ex:
+            except Exception as ex:
                 _LOGGER.error("Error al conectar con la API de Meteocat: %s", ex)
                 errors["base"] = "cannot_connect"
-            except Exception as ex:
-                _LOGGER.error("Error inesperado al validar la API Key: %s", ex)
-                errors["base"] = "unknown"
-
             if not errors:
                 return await self.async_step_select_municipi()
 
@@ -215,92 +187,44 @@ class MeteocatConfigFlow(ConfigFlow, domain=DOMAIN):
         return self.async_show_form(step_id="user", data_schema=schema, errors=errors)
 
     async def async_step_select_municipi(self, user_input: dict[str, Any] | None = None) -> ConfigFlowResult:
-        """Segundo paso: Seleccionar el municipio."""
+        """Segundo paso: seleccionar el municipio."""
         errors = {}
-
         if user_input is not None:
             selected_codi = user_input["municipi"]
-            self.selected_municipi = next(
-                (m for m in self.municipis if m["codi"] == selected_codi), None
-            )
-
+            self.selected_municipi = next((m for m in self.municipis if m["codi"] == selected_codi), None)
             if self.selected_municipi:
                 await self.fetch_symbols_and_variables()
 
-        if not errors and self.selected_municipi:
+        if self.selected_municipi:
             return await self.async_step_select_station()
 
-        schema = vol.Schema(
-            {vol.Required("municipi"): vol.In({m["codi"]: m["nom"] for m in self.municipis})}
-        )
-
+        schema = vol.Schema({vol.Required("municipi"): vol.In({m["codi"]: m["nom"] for m in self.municipis})})
         return self.async_show_form(step_id="select_municipi", data_schema=schema, errors=errors)
 
     async def fetch_symbols_and_variables(self):
         """Descarga y guarda los símbolos y variables después de seleccionar el municipio."""
-
-        errors = {}
-
-        # Crear directorio de activos (assets) si no existe
-        assets_dir = os.path.join(
-            self.hass.config.path(),
-            "custom_components",
-            "meteocat",
-            "assets"
-        )
+        assets_dir = os.path.join(self.hass.config.path(), "custom_components", "meteocat", "assets")
         os.makedirs(assets_dir, exist_ok=True)
-
-        # Rutas para los archivos de símbolos y variables
         symbols_file = os.path.join(assets_dir, "symbols.json")
         variables_file = os.path.join(assets_dir, "variables.json")
-
         try:
-            # Descargar y guardar los símbolos
-            symbols_client = MeteocatSymbols(self.api_key)
-            symbols_data = await symbols_client.fetch_symbols()
-
+            symbols_data = await MeteocatSymbols(self.api_key).fetch_symbols()
             async with aiofiles.open(symbols_file, "w", encoding="utf-8") as file:
                 await file.write(json.dumps({"symbols": symbols_data}, ensure_ascii=False, indent=4))
-            
-            _LOGGER.info(f"Símbolos guardados en {symbols_file}")
-
-            # Descargar y guardar las variables
-            variables_client = MeteocatVariables(self.api_key)
-            variables_data = await variables_client.get_variables()
-
+            variables_data = await MeteocatVariables(self.api_key).get_variables()
             async with aiofiles.open(variables_file, "w", encoding="utf-8") as file:
                 await file.write(json.dumps({"variables": variables_data}, ensure_ascii=False, indent=4))
-
-            _LOGGER.info(f"Variables guardadas en {variables_file}")
-
-            # Buscar la variable de temperatura
-            self.variable_id = next(
-                (v["codi"] for v in variables_data if v["nom"].lower() == "temperatura"), None
-            )
-            if not self.variable_id:
-                _LOGGER.error("No se encontró la variable 'Temperatura'")
-                errors["base"] = "variable_not_found"
-        except (BadRequestError, ForbiddenError, TooManyRequestsError, InternalServerError, UnknownAPIError) as ex:
-            _LOGGER.error("Error al conectar con la API de Meteocat: %s", ex)
-            errors["base"] = "cannot_connect"
+            self.variable_id = next((v["codi"] for v in variables_data if v["nom"].lower() == "temperatura"), None)
         except Exception as ex:
-            _LOGGER.error("Error inesperado al descargar los datos: %s", ex)
-            errors["base"] = "unknown"
+            _LOGGER.error("Error al descargar símbolos o variables: %s", ex)
+            raise HomeAssistantError("No se pudieron obtener símbolos o variables")
 
-        if errors:
-            raise HomeAssistantError(errors)
-
-    async def async_step_select_station(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Tercer paso: Seleccionar la estación para la variable seleccionada."""
+    async def async_step_select_station(self, user_input: dict[str, Any] | None = None) -> ConfigFlowResult:
+        """Tercer paso: seleccionar estación."""
         errors = {}
-
         townstations_client = MeteocatTownStations(self.api_key)
         try:
-            stations_data = await townstations_client.get_town_stations(
-                self.selected_municipi["codi"], self.variable_id
-            )
+            stations_data = await townstations_client.get_town_stations(self.selected_municipi["codi"], self.variable_id)
         except Exception as ex:
             _LOGGER.error("Error al obtener las estaciones: %s", ex)
             errors["base"] = "stations_fetch_failed"
@@ -309,19 +233,15 @@ class MeteocatConfigFlow(ConfigFlow, domain=DOMAIN):
         if user_input is not None:
             selected_station_codi = user_input["station"]
             selected_station = next(
-                (station for station in stations_data[0]["variables"][0]["estacions"] if station["codi"] == selected_station_codi),
-                None
+                (station for station in stations_data[0]["variables"][0]["estacions"] if station["codi"] == selected_station_codi), None
             )
-
             if selected_station:
                 self.station_id = selected_station["codi"]
                 self.station_name = selected_station["nom"]
 
                 # Obtener metadatos de la estación
-                infostation_client = MeteocatInfoStation(self.api_key)
                 try:
-                    station_metadata = await infostation_client.get_infostation(self.station_id)
-                    # Extraer los valores necesarios de los metadatos
+                    station_metadata = await MeteocatInfoStation(self.api_key).get_infostation(self.station_id)
                     self.station_type = station_metadata.get("tipus", "")
                     self.latitude = station_metadata.get("coordenades", {}).get("latitud", 0.0)
                     self.longitude = station_metadata.get("coordenades", {}).get("longitud", 0.0)
@@ -332,9 +252,9 @@ class MeteocatConfigFlow(ConfigFlow, domain=DOMAIN):
                     self.province_name = station_metadata.get("provincia", {}).get("nom", "")
                     self.station_status = station_metadata.get("estats", [{}])[0].get("codi", "")
 
-                    # Crear el archivo lightning después de obtener region_id
-                    await self.create_lightning_file()
-                    
+                    # Crear archivos regionales de alertas y lightning
+                    await self.create_alerts_file()
+
                     return await self.async_step_set_api_limits()
                 except Exception as ex:
                     _LOGGER.error("Error al obtener los metadatos de la estación: %s", ex)
@@ -342,22 +262,12 @@ class MeteocatConfigFlow(ConfigFlow, domain=DOMAIN):
             else:
                 errors["base"] = "station_not_found"
 
-        schema = vol.Schema(
-            {
-                vol.Required("station"): vol.In(
-                    {station["codi"]: station["nom"] for station in stations_data[0]["variables"][0]["estacions"]}
-                )
-            }
-        )
+        schema = vol.Schema({vol.Required("station"): vol.In({station["codi"]: station["nom"] for station in stations_data[0]["variables"][0]["estacions"]})})
+        return self.async_show_form(step_id="select_station", data_schema=schema, errors=errors)
 
-        return self.async_show_form(
-            step_id="select_station", data_schema=schema, errors=errors
-        )
-        
     async def async_step_set_api_limits(self, user_input=None):
-        """Cuarto paso: Introducir los límites de XEMA y PREDICCIO del plan de la API."""
+        """Cuarto paso: límites de la API."""
         errors = {}
-
         if user_input is not None:
             self.limit_xema = user_input.get(LIMIT_XEMA, 750)
             self.limit_prediccio = user_input.get(LIMIT_PREDICCIO, 100)
@@ -388,22 +298,17 @@ class MeteocatConfigFlow(ConfigFlow, domain=DOMAIN):
                     LIMIT_XDDE: self.limit_xdde,
                     LIMIT_QUOTA: self.limit_quota,
                     LIMIT_BASIC: self.limit_basic,
-                },
+                }
             )
 
-        schema = vol.Schema(
-            {
-                vol.Required(LIMIT_XEMA, default=750): cv.positive_int,
-                vol.Required(LIMIT_PREDICCIO, default=100): cv.positive_int,
-                vol.Required(LIMIT_XDDE, default=250): cv.positive_int,
-                vol.Required(LIMIT_QUOTA, default=300): cv.positive_int,
-                vol.Required(LIMIT_BASIC, default=2000): cv.positive_int,
-            }
-        )
-
-        return self.async_show_form(
-            step_id="set_api_limits", data_schema=schema, errors=errors
-        )
+        schema = vol.Schema({
+            vol.Required(LIMIT_XEMA, default=750): cv.positive_int,
+            vol.Required(LIMIT_PREDICCIO, default=100): cv.positive_int,
+            vol.Required(LIMIT_XDDE, default=250): cv.positive_int,
+            vol.Required(LIMIT_QUOTA, default=300): cv.positive_int,
+            vol.Required(LIMIT_BASIC, default=2000): cv.positive_int,
+        })
+        return self.async_show_form(step_id="set_api_limits", data_schema=schema, errors=errors)
 
     @staticmethod
     @callback

package/custom_components/meteocat/const.py

@@ -56,7 +56,7 @@ DEFAULT_VALIDITY_MINUTES = 0  # Minutos a partir de los cuales la API tiene la i
 DEFAULT_ALERT_VALIDITY_TIME = 120  # Minutos a partir de los cuales las alertas están obsoletas y se se debe proceder a una nueva llamada a la API
 DEFAULT_QUOTES_VALIDITY_TIME = 240 # Minutos a partir de los cuales los datos de cuotas están obsoletos y se se debe proceder a una nueva llamada a la API
 DEFAULT_LIGHTNING_VALIDITY_TIME = 240 # Minutos a partir de los cuales los datos de rayos están obsoletos y se se debe proceder a una nueva llamada a la API
-DEFAULT_LIGHTNING_VALIDITY_HOURS = 2  # Hora a partir de la cual la API tiene la información actualizada de rayos disponible para descarga
+DEFAULT_LIGHTNING_VALIDITY_HOURS = 1  # Hora a partir de la cual la API tiene la información actualizada de rayos disponible para descarga
 DEFAULT_LIGHTNING_VALIDITY_MINUTES = 0  # Minutos a partir de los cuales la API tiene la información actualizada de rayos disponible para descarga
 
 # Multiplicadores para la duración de validez basada en limit_prediccio

package/custom_components/meteocat/coordinator.py

@@ -1268,6 +1268,18 @@ class MeteocatAlertsCoordinator(DataUpdateCoordinator):
             if now - last_update > validity_duration:
                 return await self._fetch_and_save_new_data()
             else:
+                # Comprobar si el archivo regional sigue con INITIAL_TEMPLATE o sin datos válidos
+                region_data = await load_json_from_file(self.alerts_region_file)
+                if (
+                    not region_data
+                    or region_data.get("actualitzat", {}).get("dataUpdate") in [None, "1970-01-01T00:00:00+00:00"]
+                ):
+                    _LOGGER.info(
+                        "El archivo regional %s sigue con plantilla inicial. Regenerando a partir de alerts.json",
+                        self.alerts_region_file,
+                    )
+                    await self._filter_alerts_by_region()
+
                 # Devolver los datos del archivo existente
                 _LOGGER.debug("Usando datos existentes de alertas: %s", existing_data)
                 return {
@@ -1334,7 +1346,7 @@ class MeteocatAlertsCoordinator(DataUpdateCoordinator):
                 "Usando datos en caché para las alertas. Última actualización: %s",
                 cached_data["actualitzat"]["dataUpdate"],
             )
-            return cached_data
+            return {"actualizado": cached_data['actualitzat']['dataUpdate']}
 
         # Si no se puede actualizar ni cargar datos en caché, retornar None
         _LOGGER.error("No se pudo obtener datos actualizados ni cargar datos en caché de alertas.")
@@ -1783,7 +1795,7 @@ class MeteocatQuotesCoordinator(DataUpdateCoordinator):
         cached_data = await load_json_from_file(self.quotes_file)
         if cached_data:
             _LOGGER.warning("Usando datos en caché para las cuotas de la API de Meteocat.")
-            return cached_data
+            return {"actualizado": cached_data['actualitzat']['dataUpdate']}
 
         _LOGGER.error("No se pudo obtener datos actualizados ni cargar datos en caché.")
         return None
@@ -1910,15 +1922,19 @@ class MeteocatLightningCoordinator(DataUpdateCoordinator):
         existing_data = await load_json_from_file(self.lightning_file) or {}
 
         # Definir la duración de validez de los datos
-        current_time = datetime.now(timezone.utc).time()
-        validity_start_time = time(DEFAULT_LIGHTNING_VALIDITY_HOURS, DEFAULT_LIGHTNING_VALIDITY_MINUTES)
+        now = datetime.now(timezone.utc).astimezone(TIMEZONE)
+        current_time = now.time()  # Extraer solo la parte de la hora
+        offset = now.utcoffset().total_seconds() / 3600  # Obtener el offset en horas
+        
+        # Determinar la hora de validez considerando el offset horario, el horario de verano (+02:00) o invierno (+01:00)
+        validity_start_time = time(int(DEFAULT_LIGHTNING_VALIDITY_HOURS + offset), DEFAULT_LIGHTNING_VALIDITY_MINUTES)
+        
         validity_duration = timedelta(minutes=DEFAULT_LIGHTNING_VALIDITY_TIME)
 
         if not existing_data:
             return await self._fetch_and_save_new_data()
         else:
             last_update = datetime.fromisoformat(existing_data['actualitzat']['dataUpdate'])
-            now = datetime.now(timezone.utc).astimezone(TIMEZONE)
             
             if now - last_update >= validity_duration and current_time >= validity_start_time:
                 return await self._fetch_and_save_new_data()
@@ -1967,7 +1983,7 @@ class MeteocatLightningCoordinator(DataUpdateCoordinator):
         cached_data = await load_json_from_file(self.lightning_file)
         if cached_data:
             _LOGGER.warning("Usando datos en caché para los datos de rayos de la API de Meteocat.")
-            return cached_data
+            return {"actualizado": cached_data['actualitzat']['dataUpdate']}
 
         _LOGGER.error("No se pudo obtener datos actualizados ni cargar datos en caché.")
         return None
@@ -2012,20 +2028,20 @@ class MeteocatLightningFileCoordinator(DataUpdateCoordinator):
         if not existing_data:
             _LOGGER.warning("No se encontraron datos en %s.", self.lightning_file)
             return {
-                "actualizado": datetime.now(ZoneInfo("Europe/Madrid")).isoformat(),
+                "actualizado": datetime.now(TIMEZONE).isoformat(),
                 "region": self._reset_data(),
                 "town": self._reset_data()
             }
 
         # Convertir la cadena de fecha a un objeto datetime y ajustar a la zona horaria local
         update_date = datetime.fromisoformat(existing_data.get("actualitzat", {}).get("dataUpdate", ""))
-        update_date = update_date.astimezone(ZoneInfo("Europe/Madrid"))
-        now = datetime.now(ZoneInfo("Europe/Madrid"))
+        update_date = update_date.astimezone(TIMEZONE)
+        now = datetime.now(TIMEZONE)
 
         if update_date.date() != now.date():  # Si la fecha no es la de hoy
             _LOGGER.info("Los datos de rayos son de un día diferente. Reiniciando valores a cero.")
             region_data = town_data = self._reset_data()
-            update_date = datetime.now(ZoneInfo("Europe/Madrid")).isoformat()  # Usar la fecha actual
+            update_date = datetime.now(TIMEZONE).isoformat()  # Usar la fecha actual
         else:
             region_data = self._process_region_data(existing_data.get("dades", []))
             town_data = self._process_town_data(existing_data.get("dades", []))

package/custom_components/meteocat/manifest.json

@@ -9,5 +9,5 @@
     "issue_tracker": "https://github.com/figorr/meteocat/issues",
     "loggers": ["meteocatpy"],
     "requirements": ["meteocatpy==1.0.1", "packaging>=20.3", "wrapt>=1.14.0"],
-    "version": "2.2.4"
+    "version": "2.2.6"
 }

package/custom_components/meteocat/sensor.py

@@ -103,6 +103,8 @@ from .const import (
     ALERT_VALIDITY_MULTIPLIER_500,
     ALERT_VALIDITY_MULTIPLIER_DEFAULT,
     DEFAULT_LIGHTNING_VALIDITY_TIME,
+    DEFAULT_LIGHTNING_VALIDITY_HOURS,
+    DEFAULT_LIGHTNING_VALIDITY_MINUTES,
 )
 
 from .coordinator import (
@@ -1687,29 +1689,40 @@ class MeteocatLightningStatusSensor(CoordinatorEntity[MeteocatLightningCoordinat
         self._attr_entity_category = getattr(description, "entity_category", None)
 
     def _get_data_update(self):
-        """Obtiene la fecha de actualización directamente desde el coordinador."""
+        """Obtiene la fecha de actualización directamente desde el coordinador y la convierte a UTC."""
         data_update = self.coordinator.data.get("actualizado")
         if data_update:
             try:
-                return datetime.fromisoformat(data_update.rstrip("Z"))
+                local_time = datetime.fromisoformat(data_update)  # Ya tiene offset (+01:00 o +02:00)
+                return local_time.astimezone(ZoneInfo("UTC"))  # Convertir a UTC
             except ValueError:
                 _LOGGER.error("Formato de fecha de actualización inválido: %s", data_update)
         return None
+    
+    def _determine_status(self, now, data_update, current_time, validity_start_time, validity_duration):
+        """Determina el estado basado en la fecha de actualización."""
+        if now - data_update > timedelta(days=1):
+            return "obsolete"
+        elif now - data_update < validity_duration or current_time < validity_start_time:
+            return "updated"
+        return "obsolete"
 
     @property
     def native_value(self):
-        """Devuelve el estado actual de las alertas basado en la fecha de actualización."""
+        """Devuelve el estado del archivo de rayos basado en la fecha de actualización."""
         data_update = self._get_data_update()
         if not data_update:
             return "unknown"
 
-        current_time = datetime.now(ZoneInfo("UTC"))
+        now = datetime.now(timezone.utc).astimezone(TIMEZONE)
+        current_time = now.time()  # Extraer solo la parte de la hora
+        offset = now.utcoffset().total_seconds() / 3600  # Obtener el offset en horas
 
-        # Comprobar si el archivo de alertas está obsoleto
-        if current_time - data_update >= timedelta(minutes=DEFAULT_LIGHTNING_VALIDITY_TIME):
-            return "obsolete"
+        # Determinar la hora de validez considerando el offset horario, el horario de verano (+02:00) o invierno (+01:00)
+        validity_start_time = time(int(DEFAULT_LIGHTNING_VALIDITY_HOURS + offset), DEFAULT_LIGHTNING_VALIDITY_MINUTES)
+        validity_duration = timedelta(minutes=DEFAULT_LIGHTNING_VALIDITY_TIME)
 
-        return "updated"
+        return self._determine_status(now, data_update, current_time, validity_start_time, validity_duration)
 
     @property
     def extra_state_attributes(self):

package/custom_components/meteocat/version.py

@@ -1,2 +1,2 @@
 # version.py
-__version__ = "2.2.4"
+__version__ = "2.2.6"

package/package.json

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