meteocatpy 0.0.11 → 0.0.13

package/meteocatpy/symbols.py

@@ -1,89 +1,89 @@
-import aiohttp
-from .const import BASE_URL, SYMBOLS_URL
-from .exceptions import BadRequestError, ForbiddenError, TooManyRequestsError, InternalServerError, UnknownAPIError
-
-
-class MeteocatSymbols:
-    """Clase para interactuar con la API de símbolos de Meteocat."""
-
-    def __init__(self, api_key: str):
-        """
-        Inicializa la clase MeteocatSymbols.
-
-        Args:
-            api_key (str): Clave de API para autenticar las solicitudes.
-        """
-        self.api_key = api_key
-        self.headers = {
-            "Content-Type": "application/json",
-            "X-Api-Key": self.api_key,
-        }
-        self.symbols_map = {}
-
-    async def fetch_symbols(self):
-        url = f"{BASE_URL}{SYMBOLS_URL}"
-        async with aiohttp.ClientSession() as session:
-            try:
-                async with session.get(url, headers=self.headers) as response:
-                    if response.status == 200:
-                        data = await response.json()
-                        print(data)  # Esto te mostrará la estructura completa en la consola
-
-                        # Asegurarse de que `data` sea una lista de categorías
-                        if isinstance(data, list):
-                            self.symbols_map = {}
-                            for category in data:
-                                if "valors" in category:
-                                    # Guardamos los valores de cada categoría
-                                    self.symbols_map[category["nom"]] = category["valors"]
-                            return data  # Devolvemos todo el conjunto de datos
-
-                        else:
-                            raise UnknownAPIError(f"Unexpected structure of data: {data}", status_code=response.status)
-
-                    # Gestionar errores de respuesta
-                    if response.status == 400:
-                        raise BadRequestError(await response.json())
-                    elif response.status == 403:
-                        error_data = await response.json()
-                        if error_data.get("message") == "Forbidden":
-                            raise ForbiddenError(error_data)
-                        elif error_data.get("message") == "Missing Authentication Token":
-                            raise ForbiddenError(error_data)
-                    elif response.status == 429:
-                        raise TooManyRequestsError(await response.json())
-                    elif response.status == 500:
-                        raise InternalServerError(await response.json())
-                    else:
-                        raise UnknownAPIError(f"Unexpected error {response.status}: {await response.text()}", status_code=response.status)
-
-            except aiohttp.ClientError as e:
-                raise UnknownAPIError(
-                    message=f"Error al conectar con la API de Meteocat: {str(e)}",
-                    status_code=0,
-                )
-
-            except Exception as ex:
-                raise UnknownAPIError(
-                    message=f"Error inesperado: {str(ex)}",
-                    status_code=0,
-                )
-
-
-
-    def get_description(self, category: str, code: int) -> str:
-        """
-        Obtiene la descripción de un código de símbolo dentro de una categoría.
-
-        Args:
-            category (str): Nombre de la categoría (e.g., "cel").
-            code (int): Código del símbolo.
-
-        Returns:
-            str: Descripción del símbolo. Retorna 'Desconocido' si el código no está en el mapeo.
-        """
-        category_symbols = self.symbols_map.get(category, [])
-        for symbol in category_symbols:
-            if symbol["codi"] == str(code):  # El código es devuelto como string por la API
-                return symbol["descripcio"]
-        return "Desconocido"
+import aiohttp
+from .const import BASE_URL, SYMBOLS_URL
+from .exceptions import BadRequestError, ForbiddenError, TooManyRequestsError, InternalServerError, UnknownAPIError
+
+
+class MeteocatSymbols:
+    """Clase para interactuar con la API de símbolos de Meteocat."""
+
+    def __init__(self, api_key: str):
+        """
+        Inicializa la clase MeteocatSymbols.
+
+        Args:
+            api_key (str): Clave de API para autenticar las solicitudes.
+        """
+        self.api_key = api_key
+        self.headers = {
+            "Content-Type": "application/json",
+            "X-Api-Key": self.api_key,
+        }
+        self.symbols_map = {}
+
+    async def fetch_symbols(self):
+        url = f"{BASE_URL}{SYMBOLS_URL}"
+        async with aiohttp.ClientSession() as session:
+            try:
+                async with session.get(url, headers=self.headers) as response:
+                    if response.status == 200:
+                        data = await response.json()
+                        print(data)  # Esto te mostrará la estructura completa en la consola
+
+                        # Asegurarse de que `data` sea una lista de categorías
+                        if isinstance(data, list):
+                            self.symbols_map = {}
+                            for category in data:
+                                if "valors" in category:
+                                    # Guardamos los valores de cada categoría
+                                    self.symbols_map[category["nom"]] = category["valors"]
+                            return data  # Devolvemos todo el conjunto de datos
+
+                        else:
+                            raise UnknownAPIError(f"Unexpected structure of data: {data}", status_code=response.status)
+
+                    # Gestionar errores de respuesta
+                    if response.status == 400:
+                        raise BadRequestError(await response.json())
+                    elif response.status == 403:
+                        error_data = await response.json()
+                        if error_data.get("message") == "Forbidden":
+                            raise ForbiddenError(error_data)
+                        elif error_data.get("message") == "Missing Authentication Token":
+                            raise ForbiddenError(error_data)
+                    elif response.status == 429:
+                        raise TooManyRequestsError(await response.json())
+                    elif response.status == 500:
+                        raise InternalServerError(await response.json())
+                    else:
+                        raise UnknownAPIError(f"Unexpected error {response.status}: {await response.text()}", status_code=response.status)
+
+            except aiohttp.ClientError as e:
+                raise UnknownAPIError(
+                    message=f"Error al conectar con la API de Meteocat: {str(e)}",
+                    status_code=0,
+                )
+
+            except Exception as ex:
+                raise UnknownAPIError(
+                    message=f"Error inesperado: {str(ex)}",
+                    status_code=0,
+                )
+
+
+
+    def get_description(self, category: str, code: int) -> str:
+        """
+        Obtiene la descripción de un código de símbolo dentro de una categoría.
+
+        Args:
+            category (str): Nombre de la categoría (e.g., "cel").
+            code (int): Código del símbolo.
+
+        Returns:
+            str: Descripción del símbolo. Retorna 'Desconocido' si el código no está en el mapeo.
+        """
+        category_symbols = self.symbols_map.get(category, [])
+        for symbol in category_symbols:
+            if symbol["codi"] == str(code):  # El código es devuelto como string por la API
+                return symbol["descripcio"]
+        return "Desconocido"

package/meteocatpy/town.py

@@ -1,61 +1,61 @@
-import aiohttp
-from .const import BASE_URL, MUNICIPIS_LIST_URL
-from .exceptions import BadRequestError, ForbiddenError, TooManyRequestsError, InternalServerError, UnknownAPIError
-
-class MeteocatTown:
-    """Clase para interactuar con la lista de municipios de la API de Meteocat."""
-
-    def __init__(self, api_key: str):
-        """
-        Inicializa la clase MeteocatTown.
-
-        Args:
-            api_key (str): Clave de API para autenticar las solicitudes.
-        """
-        self.api_key = api_key
-        self.headers = {
-            "Content-Type": "application/json",
-            "X-Api-Key": self.api_key,
-        }
-
-    async def get_municipis(self):
-        """
-        Obtiene la lista de municipios desde la API de Meteocat.
-
-        Returns:
-            dict: Datos de los municipios.
-        """
-        url = f"{BASE_URL}{MUNICIPIS_LIST_URL}"
-        async with aiohttp.ClientSession() as session:
-            try:
-                async with session.get(url, headers=self.headers) as response:
-                    if response.status == 200:
-                        return await response.json()
-
-                    # Gestionar errores según el código de estado
-                    if response.status == 400:
-                        raise BadRequestError(await response.json())
-                    elif response.status == 403:
-                        error_data = await response.json()
-                        if error_data.get("message") == "Forbidden":
-                            raise ForbiddenError(error_data)
-                        elif error_data.get("message") == "Missing Authentication Token":
-                            raise ForbiddenError(error_data)
-                    elif response.status == 429:
-                        raise TooManyRequestsError(await response.json())
-                    elif response.status == 500:
-                        raise InternalServerError(await response.json())
-                    else:
-                        raise UnknownAPIError(f"Unexpected error {response.status}: {await response.text()}")
-            
-            except aiohttp.ClientError as e:
-                raise UnknownAPIError(
-                    message=f"Error al conectar con la API de Meteocat: {str(e)}",
-                    status_code=0,
-                )
-
-            except Exception as ex:
-                raise UnknownAPIError(
-                    message=f"Error inesperado: {str(ex)}",
-                    status_code=0,
-                )
+import aiohttp
+from .const import BASE_URL, MUNICIPIS_LIST_URL
+from .exceptions import BadRequestError, ForbiddenError, TooManyRequestsError, InternalServerError, UnknownAPIError
+
+class MeteocatTown:
+    """Clase para interactuar con la lista de municipios de la API de Meteocat."""
+
+    def __init__(self, api_key: str):
+        """
+        Inicializa la clase MeteocatTown.
+
+        Args:
+            api_key (str): Clave de API para autenticar las solicitudes.
+        """
+        self.api_key = api_key
+        self.headers = {
+            "Content-Type": "application/json",
+            "X-Api-Key": self.api_key,
+        }
+
+    async def get_municipis(self):
+        """
+        Obtiene la lista de municipios desde la API de Meteocat.
+
+        Returns:
+            dict: Datos de los municipios.
+        """
+        url = f"{BASE_URL}{MUNICIPIS_LIST_URL}"
+        async with aiohttp.ClientSession() as session:
+            try:
+                async with session.get(url, headers=self.headers) as response:
+                    if response.status == 200:
+                        return await response.json()
+
+                    # Gestionar errores según el código de estado
+                    if response.status == 400:
+                        raise BadRequestError(await response.json())
+                    elif response.status == 403:
+                        error_data = await response.json()
+                        if error_data.get("message") == "Forbidden":
+                            raise ForbiddenError(error_data)
+                        elif error_data.get("message") == "Missing Authentication Token":
+                            raise ForbiddenError(error_data)
+                    elif response.status == 429:
+                        raise TooManyRequestsError(await response.json())
+                    elif response.status == 500:
+                        raise InternalServerError(await response.json())
+                    else:
+                        raise UnknownAPIError(f"Unexpected error {response.status}: {await response.text()}")
+            
+            except aiohttp.ClientError as e:
+                raise UnknownAPIError(
+                    message=f"Error al conectar con la API de Meteocat: {str(e)}",
+                    status_code=0,
+                )
+
+            except Exception as ex:
+                raise UnknownAPIError(
+                    message=f"Error inesperado: {str(ex)}",
+                    status_code=0,
+                )

package/meteocatpy/townstations.py

@@ -1,99 +1,99 @@
-import aiohttp
-from .stations import MeteocatStations  # Importamos la clase MeteocatStations
-from .const import BASE_URL, STATIONS_MUNICIPI_URL
-from .exceptions import (
-    BadRequestError,
-    ForbiddenError,
-    TooManyRequestsError,
-    InternalServerError,
-    UnknownAPIError,
-)
-
-class MeteocatTownStations:
-    """
-    Clase para interactuar con la API de Meteocat y obtener
-    las estaciones representativas de un municipio para una variable específica.
-    """
-
-    def __init__(self, api_key: str):
-        """
-        Inicializa la clase MeteocatTownStations.
-
-        Args:
-            api_key (str): Clave de API para autenticar las solicitudes.
-        """
-        self.api_key = api_key
-        self.headers = {
-            "Content-Type": "application/json",
-            "X-Api-Key": self.api_key,
-        }
-        self.stations_service = MeteocatStations(api_key)  # Instancia de MeteocatStations
-
-    async def get_town_stations(self, town_id: str, variable_id: str):
-        """
-        Obtiene la lista de estaciones representativas para un municipio y una variable específica,
-        enriqueciendo los datos con el nombre de las estaciones.
-
-        Args:
-            codi_municipi (str): Código del municipio.
-            codi_variable (str): Código de la variable.
-
-        Returns:
-            list: Datos de las estaciones representativas con nombres añadidos.
-        """
-        # Obtener la lista completa de estaciones
-        all_stations = await self.stations_service.get_stations()
-
-        # Crear un diccionario para acceder rápidamente a los nombres por código
-        station_names = {station["codi"]: station["nom"] for station in all_stations}
-
-        # URL para obtener las estaciones del municipio y la variable
-        url = f"{BASE_URL}{STATIONS_MUNICIPI_URL}".format(
-            codi_municipi=town_id, codi_variable=variable_id
-        )
-
-        async with aiohttp.ClientSession() as session:
-            try:
-                async with session.get(url, headers=self.headers) as response:
-                    if response.status == 200:
-                        data = await response.json()
-
-                        # Enriquecer el JSON con los nombres de las estaciones
-                        for town in data:
-                            for variable in town.get("variables", []):
-                                for station in variable.get("estacions", []):
-                                    codi = station["codi"]
-                                    station["nom"] = station_names.get(codi, "Nombre desconocido")
-
-                        return data
-
-                    # Gestionar errores según el código de estado
-                    if response.status == 400:
-                        raise BadRequestError(await response.json())
-                    elif response.status == 403:
-                        error_data = await response.json()
-                        if error_data.get("message") == "Forbidden":
-                            raise ForbiddenError(error_data)
-                        elif error_data.get("message") == "Missing Authentication Token":
-                            raise ForbiddenError(error_data)
-                    elif response.status == 429:
-                        raise TooManyRequestsError(await response.json())
-                    elif response.status == 500:
-                        raise InternalServerError(await response.json())
-                    else:
-                        raise UnknownAPIError(
-                            f"Unexpected error {response.status}: {await response.text()}"
-                        )
-
-            except aiohttp.ClientError as e:
-                raise UnknownAPIError(
-                    message=f"Error al conectar con la API de Meteocat: {str(e)}",
-                    status_code=0,
-                )
-
-            except Exception as ex:
-                raise UnknownAPIError(
-                    message=f"Error inesperado: {str(ex)}",
-                    status_code=0,
-                )
-
+import aiohttp
+from .stations import MeteocatStations  # Importamos la clase MeteocatStations
+from .const import BASE_URL, STATIONS_MUNICIPI_URL
+from .exceptions import (
+    BadRequestError,
+    ForbiddenError,
+    TooManyRequestsError,
+    InternalServerError,
+    UnknownAPIError,
+)
+
+class MeteocatTownStations:
+    """
+    Clase para interactuar con la API de Meteocat y obtener
+    las estaciones representativas de un municipio para una variable específica.
+    """
+
+    def __init__(self, api_key: str):
+        """
+        Inicializa la clase MeteocatTownStations.
+
+        Args:
+            api_key (str): Clave de API para autenticar las solicitudes.
+        """
+        self.api_key = api_key
+        self.headers = {
+            "Content-Type": "application/json",
+            "X-Api-Key": self.api_key,
+        }
+        self.stations_service = MeteocatStations(api_key)  # Instancia de MeteocatStations
+
+    async def get_town_stations(self, town_id: str, variable_id: str):
+        """
+        Obtiene la lista de estaciones representativas para un municipio y una variable específica,
+        enriqueciendo los datos con el nombre de las estaciones.
+
+        Args:
+            codi_municipi (str): Código del municipio.
+            codi_variable (str): Código de la variable.
+
+        Returns:
+            list: Datos de las estaciones representativas con nombres añadidos.
+        """
+        # Obtener la lista completa de estaciones
+        all_stations = await self.stations_service.get_stations()
+
+        # Crear un diccionario para acceder rápidamente a los nombres por código
+        station_names = {station["codi"]: station["nom"] for station in all_stations}
+
+        # URL para obtener las estaciones del municipio y la variable
+        url = f"{BASE_URL}{STATIONS_MUNICIPI_URL}".format(
+            codi_municipi=town_id, codi_variable=variable_id
+        )
+
+        async with aiohttp.ClientSession() as session:
+            try:
+                async with session.get(url, headers=self.headers) as response:
+                    if response.status == 200:
+                        data = await response.json()
+
+                        # Enriquecer el JSON con los nombres de las estaciones
+                        for town in data:
+                            for variable in town.get("variables", []):
+                                for station in variable.get("estacions", []):
+                                    codi = station["codi"]
+                                    station["nom"] = station_names.get(codi, "Nombre desconocido")
+
+                        return data
+
+                    # Gestionar errores según el código de estado
+                    if response.status == 400:
+                        raise BadRequestError(await response.json())
+                    elif response.status == 403:
+                        error_data = await response.json()
+                        if error_data.get("message") == "Forbidden":
+                            raise ForbiddenError(error_data)
+                        elif error_data.get("message") == "Missing Authentication Token":
+                            raise ForbiddenError(error_data)
+                    elif response.status == 429:
+                        raise TooManyRequestsError(await response.json())
+                    elif response.status == 500:
+                        raise InternalServerError(await response.json())
+                    else:
+                        raise UnknownAPIError(
+                            f"Unexpected error {response.status}: {await response.text()}"
+                        )
+
+            except aiohttp.ClientError as e:
+                raise UnknownAPIError(
+                    message=f"Error al conectar con la API de Meteocat: {str(e)}",
+                    status_code=0,
+                )
+
+            except Exception as ex:
+                raise UnknownAPIError(
+                    message=f"Error inesperado: {str(ex)}",
+                    status_code=0,
+                )
+

package/meteocatpy/variables.py

@@ -1,77 +1,77 @@
-import aiohttp
-from diskcache import Cache
-import os
-from .const import BASE_URL, VARIABLES_URL
-from .exceptions import BadRequestError, ForbiddenError, TooManyRequestsError, InternalServerError, UnknownAPIError
-
-class MeteocatVariables:
-    """Clase para interactuar con la lista de variables de la API de Meteocat."""
-
-    def __init__(self, api_key: str, cache_dir: str = None):
-        """
-        Inicializa la clase MeteocatVariables.
-
-        Args:
-            api_key (str): Clave de API para autenticar las solicitudes.
-        """
-        self.api_key = api_key
-        self.headers = {
-            "Content-Type": "application/json",
-            "X-Api-Key": self.api_key,
-        }
-
-        # Configurar la ruta de caché
-        self._cache_dir = cache_dir or ".meteocat_cache"
-        self._cache = Cache(self._cache_dir)
-
-    async def get_variables(self, force_update=False):
-        """
-        Obtiene la lista de variables desde la API de Meteocat. Usa la caché si está disponible.
-
-        Args:
-            force_update (bool): Si es True, fuerza la actualización desde la API.
-
-        Returns:
-            list: Datos de las variables.
-        """
-        # Verificar si las variables están en caché y no se solicita actualización forzada
-        if not force_update and "variables" in self._cache:
-            return self._cache["variables"]
-
-        # Hacer la solicitud a la API para obtener las variables
-        url = f"{BASE_URL}{VARIABLES_URL}"
-        async with aiohttp.ClientSession() as session:
-            try:
-                async with session.get(url, headers=self.headers) as response:
-                    if response.status == 200:
-                        variables = await response.json()
-                        self._cache["variables"] = variables  # Guardar en caché
-                        return variables
-
-                    # Gestionar errores según el código de estado
-                    if response.status == 400:
-                        raise BadRequestError(await response.json())
-                    elif response.status == 403:
-                        error_data = await response.json()
-                        if error_data.get("message") == "Forbidden":
-                            raise ForbiddenError(error_data)
-                        elif error_data.get("message") == "Missing Authentication Token":
-                            raise ForbiddenError(error_data)
-                    elif response.status == 429:
-                        raise TooManyRequestsError(await response.json())
-                    elif response.status == 500:
-                        raise InternalServerError(await response.json())
-                    else:
-                        raise UnknownAPIError(f"Unexpected error {response.status}: {await response.text()}")
-            
-            except aiohttp.ClientError as e:
-                raise UnknownAPIError(
-                    message=f"Error al conectar con la API de Meteocat: {str(e)}",
-                    status_code=0,
-                )
-
-            except Exception as ex:
-                raise UnknownAPIError(
-                    message=f"Error inesperado: {str(ex)}",
-                    status_code=0,
-                )
+import aiohttp
+from diskcache import Cache
+import os
+from .const import BASE_URL, VARIABLES_URL
+from .exceptions import BadRequestError, ForbiddenError, TooManyRequestsError, InternalServerError, UnknownAPIError
+
+class MeteocatVariables:
+    """Clase para interactuar con la lista de variables de la API de Meteocat."""
+
+    def __init__(self, api_key: str, cache_dir: str = None):
+        """
+        Inicializa la clase MeteocatVariables.
+
+        Args:
+            api_key (str): Clave de API para autenticar las solicitudes.
+        """
+        self.api_key = api_key
+        self.headers = {
+            "Content-Type": "application/json",
+            "X-Api-Key": self.api_key,
+        }
+
+        # Configurar la ruta de caché
+        self._cache_dir = os.path.join("custom_components", "meteocat", ".meteocat_cache")
+        self._cache = Cache(self._cache_dir)
+
+    async def get_variables(self, force_update=False):
+        """
+        Obtiene la lista de variables desde la API de Meteocat. Usa la caché si está disponible.
+
+        Args:
+            force_update (bool): Si es True, fuerza la actualización desde la API.
+
+        Returns:
+            list: Datos de las variables.
+        """
+        # Verificar si las variables están en caché y no se solicita actualización forzada
+        if not force_update and "variables" in self._cache:
+            return self._cache["variables"]
+
+        # Hacer la solicitud a la API para obtener las variables
+        url = f"{BASE_URL}{VARIABLES_URL}"
+        async with aiohttp.ClientSession() as session:
+            try:
+                async with session.get(url, headers=self.headers) as response:
+                    if response.status == 200:
+                        variables = await response.json()
+                        self._cache["variables"] = variables  # Guardar en caché
+                        return variables
+
+                    # Gestionar errores según el código de estado
+                    if response.status == 400:
+                        raise BadRequestError(await response.json())
+                    elif response.status == 403:
+                        error_data = await response.json()
+                        if error_data.get("message") == "Forbidden":
+                            raise ForbiddenError(error_data)
+                        elif error_data.get("message") == "Missing Authentication Token":
+                            raise ForbiddenError(error_data)
+                    elif response.status == 429:
+                        raise TooManyRequestsError(await response.json())
+                    elif response.status == 500:
+                        raise InternalServerError(await response.json())
+                    else:
+                        raise UnknownAPIError(f"Unexpected error {response.status}: {await response.text()}")
+            
+            except aiohttp.ClientError as e:
+                raise UnknownAPIError(
+                    message=f"Error al conectar con la API de Meteocat: {str(e)}",
+                    status_code=0,
+                )
+
+            except Exception as ex:
+                raise UnknownAPIError(
+                    message=f"Error inesperado: {str(ex)}",
+                    status_code=0,
+                )