meteocatpy 0.0.7 → 0.0.8

package/meteocatpy/helpers.py

@@ -1,46 +1,46 @@
-"""Meteocat Helpers."""
-
-from datetime import datetime
-from typing import Any
-import re
-import unicodedata
-from zoneinfo import ZoneInfo
-
-TZ_UTC = ZoneInfo("UTC")
-
-
-def dict_nested_value(data: dict[str, Any] | None, keys: list[str] | None) -> Any:
-    """Get value from dict with nested keys."""
-    if keys is None or len(keys) == 0:
-        return None
-    for key in keys or {}:
-        if data is not None:
-            data = data.get(key)
-    return data
-
-
-def get_current_datetime(tz: ZoneInfo = TZ_UTC, replace: bool = True) -> datetime:
-    """Return current datetime in UTC."""
-    cur_dt = datetime.now(tz=tz)
-    if replace:
-        cur_dt = cur_dt.replace(minute=0, second=0, microsecond=0)
-    return cur_dt
-
-
-def parse_api_timestamp(timestamp: str, tz: ZoneInfo = TZ_UTC) -> datetime:
-    """Parse API timestamp into datetime."""
-    return datetime.fromisoformat(timestamp).replace(tzinfo=tz)
-
-
-def slugify(value: str, allow_unicode: bool = False) -> str:
-    """Convert string to a valid file name."""
-    if allow_unicode:
-        value = unicodedata.normalize("NFKC", value)
-    else:
-        value = (
-            unicodedata.normalize("NFKD", value)
-            .encode("ascii", "ignore")
-            .decode("ascii")
-        )
-    value = re.sub(r"[^\w\s]", "-", value.lower())
-    return re.sub(r"[-\s]+", "-", value).strip("-_")
+"""Meteocat Helpers."""
+
+from datetime import datetime
+from typing import Any
+import re
+import unicodedata
+from zoneinfo import ZoneInfo
+
+TZ_UTC = ZoneInfo("UTC")
+
+
+def dict_nested_value(data: dict[str, Any] | None, keys: list[str] | None) -> Any:
+    """Get value from dict with nested keys."""
+    if keys is None or len(keys) == 0:
+        return None
+    for key in keys or {}:
+        if data is not None:
+            data = data.get(key)
+    return data
+
+
+def get_current_datetime(tz: ZoneInfo = TZ_UTC, replace: bool = True) -> datetime:
+    """Return current datetime in UTC."""
+    cur_dt = datetime.now(tz=tz)
+    if replace:
+        cur_dt = cur_dt.replace(minute=0, second=0, microsecond=0)
+    return cur_dt
+
+
+def parse_api_timestamp(timestamp: str, tz: ZoneInfo = TZ_UTC) -> datetime:
+    """Parse API timestamp into datetime."""
+    return datetime.fromisoformat(timestamp).replace(tzinfo=tz)
+
+
+def slugify(value: str, allow_unicode: bool = False) -> str:
+    """Convert string to a valid file name."""
+    if allow_unicode:
+        value = unicodedata.normalize("NFKC", value)
+    else:
+        value = (
+            unicodedata.normalize("NFKD", value)
+            .encode("ascii", "ignore")
+            .decode("ascii")
+        )
+    value = re.sub(r"[^\w\s]", "-", value.lower())
+    return re.sub(r"[-\s]+", "-", value).strip("-_")

package/meteocatpy/stations.py

@@ -1,71 +1,71 @@
-import aiohttp
-from .const import BASE_URL, STATIONS_LIST_URL
-from .exceptions import (
-    BadRequestError,
-    ForbiddenError,
-    TooManyRequestsError,
-    InternalServerError,
-    UnknownAPIError
-)
-
-class MeteocatStations:
-    """
-    Clase para interactuar con la API de Meteocat y obtener la lista de todas las estaciones."""
-
-    def __init__(self, api_key: str):
-        """
-        Inicializa la clase MeteocatStations.
-
-        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_stations(self):
-        """
-        Obtiene la lista de estaciones.
-
-        Returns:
-            dict: Lista de estaciones.
-        """
-        url = f"{BASE_URL}{STATIONS_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, STATIONS_LIST_URL
+from .exceptions import (
+    BadRequestError,
+    ForbiddenError,
+    TooManyRequestsError,
+    InternalServerError,
+    UnknownAPIError
+)
+
+class MeteocatStations:
+    """
+    Clase para interactuar con la API de Meteocat y obtener la lista de todas las estaciones."""
+
+    def __init__(self, api_key: str):
+        """
+        Inicializa la clase MeteocatStations.
+
+        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_stations(self):
+        """
+        Obtiene la lista de estaciones.
+
+        Returns:
+            dict: Lista de estaciones.
+        """
+        url = f"{BASE_URL}{STATIONS_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/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,
+                )