meteocatpy 0.0.7 → 0.0.9

package/meteocatpy/data.py

@@ -1,140 +1,93 @@
-import aiohttp
-import logging
-from datetime import datetime
-from .variables import MeteocatVariables
-from .const import BASE_URL, STATION_DATA_URL
-from .exceptions import (
-    BadRequestError,
-    ForbiddenError,
-    TooManyRequestsError,
-    InternalServerError,
-    UnknownAPIError,
-)
-
-_LOGGER = logging.getLogger(__name__)
-
-class MeteocatStationData:
-    """Clase para interactuar con los datos de estaciones de la API de Meteocat."""
-
-    def __init__(self, api_key: str):
-        """
-        Inicializa la clase MeteocatStationData.
-
-        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.variables = MeteocatVariables(api_key)
-    
-    @staticmethod
-    def get_current_date():
-        """
-        Obtiene la fecha actual en formato numérico.
-
-        Returns:
-            tuple: Año (YYYY), mes (MM), día (DD) como enteros.
-        """
-        now = datetime.now()
-        return now.year, now.month, now.day
-
-    async def get_station_data(self, station_id: str):
-        """
-        Obtiene los datos meteorológicos de una estación desde la API de Meteocat.
-
-        Args:
-            station_id (str): Código de la estación.
-
-        Returns:
-            dict: Datos meteorológicos de la estación.
-        """
-        any, mes, dia = self.get_current_date()  # Calcula la fecha actual
-        url = f"{BASE_URL}{STATION_DATA_URL}".format(
-            codiEstacio=station_id, any=any, mes=f"{mes:02d}", dia=f"{dia:02d}"
-        )
-    
-        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,
-                )
-
-    async def get_station_data_with_variables(self, station_id: str, force_update=False):
-        """
-        Obtiene los datos meteorológicos de una estación, organizados por variables.
-
-        Args:
-            station_id (str): Código de la estación.
-            force_update (bool): Si True, fuerza la actualización de las variables desde la API.
-
-        Returns:
-            dict: Datos organizados por variables.
-        """
-        # Obtener datos de la estación
-        station_data = await self.get_station_data(station_id)
-
-        # Registrar la respuesta para depuración
-        _LOGGER.debug("Datos de la estación (crudos): %s", station_data)
-
-        # Obtener las variables desde el caché o API
-        variables = await self.variables.get_variables(force_update=force_update)
-
-        # Crear una estructura para organizar los datos por variables
-        datos_por_variable = {}
-
-        # Recorrer cada estación en los datos devueltos
-        for estacion in station_data:
-            # Recorrer cada variable dentro de la estación
-            for variable in estacion.get("variables", []):
-                codi_variable = variable.get("codi")
-                variable_info = next((v for v in variables if v["codi"] == codi_variable), None)
-                if variable_info:
-                    nombre_variable = variable_info["nom"]
-                    if nombre_variable not in datos_por_variable:
-                        datos_por_variable[nombre_variable] = []
-
-                    # Agregar las lecturas de la variable
-                    for lectura in variable.get("lectures", []):
-                        datos_por_variable[nombre_variable].append(
-                            {
-                                "data": lectura["data"],
-                                "valor": lectura["valor"],
-                                "estat": lectura.get("estat", ""),
-                                "base_horaria": lectura.get("baseHoraria", ""),
-                            }
-                        )
-
-        return datos_por_variable
+import aiohttp
+import logging
+from datetime import datetime
+from .variables import MeteocatVariables
+from .const import BASE_URL, STATION_DATA_URL
+from .exceptions import (
+    BadRequestError,
+    ForbiddenError,
+    TooManyRequestsError,
+    InternalServerError,
+    UnknownAPIError,
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+class MeteocatStationData:
+    """Clase para interactuar con los datos de estaciones de la API de Meteocat."""
+
+    def __init__(self, api_key: str):
+        """
+        Inicializa la clase MeteocatStationData.
+
+        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.variables = MeteocatVariables(api_key)
+    
+    @staticmethod
+    def get_current_date():
+        """
+        Obtiene la fecha actual en formato numérico.
+
+        Returns:
+            tuple: Año (YYYY), mes (MM), día (DD) como enteros.
+        """
+        now = datetime.now()
+        return now.year, now.month, now.day
+
+    async def get_station_data(self, station_id: str):
+        """
+        Obtiene los datos meteorológicos de una estación desde la API de Meteocat.
+
+        Args:
+            station_id (str): Código de la estación.
+
+        Returns:
+            dict: Datos meteorológicos de la estación.
+        """
+        any, mes, dia = self.get_current_date()  # Calcula la fecha actual
+        url = f"{BASE_URL}{STATION_DATA_URL}".format(
+            codiEstacio=station_id, any=any, mes=f"{mes:02d}", dia=f"{dia:02d}"
+        )
+    
+        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/exceptions.py

@@ -1,35 +1,35 @@
-"""METEOCAT API exceptions."""
-
-from __future__ import annotations
-
-class MeteocatAPIError(Exception):
-    """Clase base para todos los errores de la API de Meteocat."""
-    def __init__(self, message: str, status_code: int, aws_info: dict = None):
-        super().__init__(message)
-        self.status_code = status_code
-        self.aws_info = aws_info
-
-class BadRequestError(MeteocatAPIError):
-    """Error 400: Bad request."""
-    def __init__(self, message: str, aws_info: dict = None):
-        super().__init__(message, 400, aws_info)
-
-class ForbiddenError(MeteocatAPIError):
-    """Error 403: Forbidden."""
-    def __init__(self, message: str, aws_info: dict = None):
-        super().__init__(message, 403, aws_info)
-
-class TooManyRequestsError(MeteocatAPIError):
-    """Error 429: Too many requests."""
-    def __init__(self, message: str, aws_info: dict = None):
-        super().__init__(message, 429, aws_info)
-
-class InternalServerError(MeteocatAPIError):
-    """Error 500: Internal server error."""
-    def __init__(self, message: str, aws_info: dict = None):
-        super().__init__(message, 500, aws_info)
-
-class UnknownAPIError(MeteocatAPIError):
-    """Error desconocido de la API."""
-    def __init__(self, message: str, status_code: int, aws_info: dict = None):
-        super().__init__(message, status_code, aws_info)
+"""METEOCAT API exceptions."""
+
+from __future__ import annotations
+
+class MeteocatAPIError(Exception):
+    """Clase base para todos los errores de la API de Meteocat."""
+    def __init__(self, message: str, status_code: int, aws_info: dict = None):
+        super().__init__(message)
+        self.status_code = status_code
+        self.aws_info = aws_info
+
+class BadRequestError(MeteocatAPIError):
+    """Error 400: Bad request."""
+    def __init__(self, message: str, aws_info: dict = None):
+        super().__init__(message, 400, aws_info)
+
+class ForbiddenError(MeteocatAPIError):
+    """Error 403: Forbidden."""
+    def __init__(self, message: str, aws_info: dict = None):
+        super().__init__(message, 403, aws_info)
+
+class TooManyRequestsError(MeteocatAPIError):
+    """Error 429: Too many requests."""
+    def __init__(self, message: str, aws_info: dict = None):
+        super().__init__(message, 429, aws_info)
+
+class InternalServerError(MeteocatAPIError):
+    """Error 500: Internal server error."""
+    def __init__(self, message: str, aws_info: dict = None):
+        super().__init__(message, 500, aws_info)
+
+class UnknownAPIError(MeteocatAPIError):
+    """Error desconocido de la API."""
+    def __init__(self, message: str, status_code: int, aws_info: dict = None):
+        super().__init__(message, status_code, aws_info)

package/meteocatpy/forecast.py

@@ -1,137 +1,137 @@
-import aiohttp
-from .const import (
-    BASE_URL,
-    MUNICIPIS_HORA_URL,
-    MUNICIPIS_DIA_URL
-)
-from .exceptions import (
-    BadRequestError,
-    ForbiddenError,
-    TooManyRequestsError,
-    InternalServerError,
-    UnknownAPIError
-)
-
-class MeteocatForecast:
-    """Clase para interactuar con las predicciones de la API de Meteocat."""
-
-    def __init__(self, api_key: str):
-        """
-        Inicializa la clase MeteocatForecast.
-
-        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 _fetch_data(self, url: str):
-        """
-        Método genérico para realizar solicitudes a la API.
-
-        Args:
-            url (str): URL de la API a consultar.
-
-        Returns:
-            dict: Respuesta JSON de la API.
-        """
-        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,
-                )
-
-    async def get_prediccion_horaria(self, town_id: str):
-        """
-        Obtiene la predicción horaria a 72 horas para un municipio.
-
-        Args:
-            town_id (str): Código del municipio.
-
-        Returns:
-            dict: Predicción horaria para el municipio.
-        """
-        url = f"{BASE_URL}{MUNICIPIS_HORA_URL.format(codi=town_id)}"
-        return await self._fetch_data(url)
-
-    async def get_prediccion_diaria(self, town_id: str):
-        """
-        Obtiene la predicción diaria a 8 días para un municipio.
-
-        Args:
-            town_id (str): Código del municipio.
-
-        Returns:
-            dict: Predicción diaria para el municipio.
-        """
-        url = f"{BASE_URL}{MUNICIPIS_DIA_URL.format(codi=town_id)}"
-        return await self._fetch_data(url)
-
-    @staticmethod
-    def procesar_prediccion(prediccion_json):
-        """
-        Procesa el JSON de predicción y organiza los datos por variables.
-
-        Args:
-            prediccion_json (dict): JSON devuelto por la API de predicción.
-
-        Returns:
-            dict: Datos organizados por variables.
-        """
-        datos_por_variable = {}
-
-        # Iterar sobre los días en el JSON
-        for dia in prediccion_json.get("dies", []):
-            fecha = dia.get("data")
-
-            for variable, valores in dia.get("variables", {}).items():
-                if "valors" in valores:  # Predicción horaria
-                    for valor in valores["valors"]:
-                        nombre_variable = variable
-                        if nombre_variable not in datos_por_variable:
-                            datos_por_variable[nombre_variable] = []
-                        datos_por_variable[nombre_variable].append({
-                            "fecha": valor["data"],
-                            "valor": valor["valor"],
-                            "unidad": valores.get("unitat", ""),
-                        })
-                else:  # Predicción diaria
-                    nombre_variable = variable
-                    if nombre_variable not in datos_por_variable:
-                        datos_por_variable[nombre_variable] = []
-                    datos_por_variable[nombre_variable].append({
-                        "fecha": fecha,
-                        "valor": valores["valor"],
-                        "unidad": valores.get("unitat", ""),
-                    })
-
-        return datos_por_variable
+import aiohttp
+from .const import (
+    BASE_URL,
+    MUNICIPIS_HORA_URL,
+    MUNICIPIS_DIA_URL
+)
+from .exceptions import (
+    BadRequestError,
+    ForbiddenError,
+    TooManyRequestsError,
+    InternalServerError,
+    UnknownAPIError
+)
+
+class MeteocatForecast:
+    """Clase para interactuar con las predicciones de la API de Meteocat."""
+
+    def __init__(self, api_key: str):
+        """
+        Inicializa la clase MeteocatForecast.
+
+        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 _fetch_data(self, url: str):
+        """
+        Método genérico para realizar solicitudes a la API.
+
+        Args:
+            url (str): URL de la API a consultar.
+
+        Returns:
+            dict: Respuesta JSON de la API.
+        """
+        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,
+                )
+
+    async def get_prediccion_horaria(self, town_id: str):
+        """
+        Obtiene la predicción horaria a 72 horas para un municipio.
+
+        Args:
+            town_id (str): Código del municipio.
+
+        Returns:
+            dict: Predicción horaria para el municipio.
+        """
+        url = f"{BASE_URL}{MUNICIPIS_HORA_URL.format(codi=town_id)}"
+        return await self._fetch_data(url)
+
+    async def get_prediccion_diaria(self, town_id: str):
+        """
+        Obtiene la predicción diaria a 8 días para un municipio.
+
+        Args:
+            town_id (str): Código del municipio.
+
+        Returns:
+            dict: Predicción diaria para el municipio.
+        """
+        url = f"{BASE_URL}{MUNICIPIS_DIA_URL.format(codi=town_id)}"
+        return await self._fetch_data(url)
+
+    @staticmethod
+    def procesar_prediccion(prediccion_json):
+        """
+        Procesa el JSON de predicción y organiza los datos por variables.
+
+        Args:
+            prediccion_json (dict): JSON devuelto por la API de predicción.
+
+        Returns:
+            dict: Datos organizados por variables.
+        """
+        datos_por_variable = {}
+
+        # Iterar sobre los días en el JSON
+        for dia in prediccion_json.get("dies", []):
+            fecha = dia.get("data")
+
+            for variable, valores in dia.get("variables", {}).items():
+                if "valors" in valores:  # Predicción horaria
+                    for valor in valores["valors"]:
+                        nombre_variable = variable
+                        if nombre_variable not in datos_por_variable:
+                            datos_por_variable[nombre_variable] = []
+                        datos_por_variable[nombre_variable].append({
+                            "fecha": valor["data"],
+                            "valor": valor["valor"],
+                            "unidad": valores.get("unitat", ""),
+                        })
+                else:  # Predicción diaria
+                    nombre_variable = variable
+                    if nombre_variable not in datos_por_variable:
+                        datos_por_variable[nombre_variable] = []
+                    datos_por_variable[nombre_variable].append({
+                        "fecha": fecha,
+                        "valor": valores["valor"],
+                        "unidad": valores.get("unitat", ""),
+                    })
+
+        return datos_por_variable