meteocatpy 0.0.7

package/pyproject.toml

@@ -0,0 +1,72 @@
+[tool.poetry]
+name = "meteocatpy"
+version = "0.0.7"
+description = "Script para obtener datos meteorológicos de la API de Meteocat"
+authors = ["figorr <jdcuartero@yahoo.es>"]
+license = "Apache-2.0"
+readme = "README.md"
+repository = "https://gitlab.com/figorr/meteocatpy"
+keywords = ['meteocatpy', 'meteocat']
+
+
+[tool.poetry.dependencies]
+python = ">=3.12,<3.13"
+requests = "^2.32.3"
+python-dotenv = "^1.0.1"
+simplejson = "^3.19.3"
+setuptools = "^75.5.0"
+python-semantic-release = "^7.28.1"
+twine = ">=3,<4"
+aiofiles = "^24.1.0"
+voluptuous = "^0.15.2"
+geopy = "^2.4.1"
+tzdata = "^2024.2"
+aiohttp = ">=3.10.11,<4.0.0"
+diskcache = "^5.6.3"
+semantic-release = "^0.1.0"
+
+
+[tool.semantic_release]
+branch = "master"  # Define la rama desde la que se harán los lanzamientos
+version_source = "commit"  # Determina la versión basada en los commits
+version_variable = "meteocatpy/version.py:__version__"  # Ubicación de la variable de versión
+changelog = { file = "CHANGELOG.md" }  # Genera el changelog en el archivo especificado
+upload_to_pypi = false  # Sube automáticamente la versión a PyPI
+ci = false  # Cambiar a false si no usas CI/CD
+
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+
+[tool.poetry.dev-dependencies]
+aresponses = "*"
+detox = "*"
+flake8 = "*"
+mypy = "*"
+pydocstyle = "*"
+pylint = "*"
+pytest-aiohttp = "*"
+pytest-cov = "*"
+python-semantic-release = "^7.28.1"
+tox = "*"
+safety = ">=1.8.7"
+black = { version = ">19.10b0", allow-prereleases = true }
+Sphinx = ">=3.5.0,<7.0.0"
+autoapi = ">=2.0.1"
+sphinx-rtd-theme = "^0.5.1"
+m2r2 = ">=0.2.7"
+tomlkit = ">=0.7.0"
+sphinx-autoapi = ">=1.7.0"
+sphinx-copybutton = ">=0.3.1"
+pipdeptree = "^2.2.1"
+
+
+[tool.poetry.group.dev.dependencies]
+pyupgrade = "^3.4.0"
+pre-commit = "^3.3.1"
+pytest = "^8.3.3"
+pytest-asyncio = "^0.24.0"
+syrupy = "^4.7.2"
+aioresponses = "^0.7.7"

package/releaserc.json

@@ -0,0 +1,18 @@
+{
+    "branches": ["master"],
+    "plugins": [
+      "@semantic-release/commit-analyzer",
+      "@semantic-release/release-notes-generator",
+      "@semantic-release/changelog",
+      [
+        "@semantic-release/exec",
+        {
+          "prepareCmd": "python setup.py sdist bdist_wheel",
+          "publishCmd": "twine upload dist/* -u ${PYPI_USERNAME} -p ${PYPI_PASSWORD}"
+        }
+      ],
+      "@semantic-release/github",
+      "@semantic-release/git"
+    ]
+  }
+  

package/requirements.test.txt

@@ -0,0 +1,3 @@
+pytest
+pytest-cov
+pytest-homeassistant-custom-component

package/setup.cfg

@@ -0,0 +1,64 @@
+[coverage:run]
+source =
+  meteocatpy
+
+[coverage:report]
+exclude_lines =
+    pragma: no cover
+    raise NotImplemented()
+    if __name__ == '__main__':
+    main()
+show_missing = true
+
+[tool:pytest]
+testpaths = tests
+norecursedirs = .git
+asyncio_mode = auto
+addopts =
+    -p syrupy
+    --strict
+    --cov=meteocatpy
+
+[flake8]
+# https://github.com/ambv/black#line-length
+max-line-length = 88
+# E501: line too long
+# W503: Line break occurred before a binary operator
+# E203: Whitespace before ':'
+# D202 No blank lines allowed after function docstring
+# W504 line break after binary operator
+ignore =
+    E501,
+    W503,
+    E203,
+    D202,
+    W504
+
+[isort]
+# https://github.com/timothycrosley/isort
+# https://github.com/timothycrosley/isort/wiki/isort-Settings
+# splits long import on multiple lines indented by 4 spaces
+multi_line_output = 3
+include_trailing_comma=True
+force_grid_wrap=0
+use_parentheses=True
+line_length=88
+indent = "    "
+# by default isort don't check module indexes
+not_skip = __init__.py
+# will group `import x` and `from x import` of the same module.
+force_sort_within_sections = true
+sections = FUTURE,STDLIB,INBETWEENS,THIRDPARTY,FIRSTPARTY,LOCALFOLDER
+default_section = THIRDPARTY
+known_first_party = custom_components,tests
+forced_separate = tests
+combine_as_imports = true
+
+[mypy]
+python_version = 3.7
+ignore_errors = true
+follow_imports = silent
+ignore_missing_imports = true
+warn_incomplete_stub = true
+warn_redundant_casts = true
+warn_unused_configs = true

package/setup.py

@@ -0,0 +1,10 @@
+from setuptools import setup
+
+# Leer la versión desde el archivo version.py
+with open("meteocatpy/version.py") as f:
+    exec(f.read())  # Ejecuta el archivo version.py para cargar la variable __version__
+
+setup(
+    name="meteocatpy",
+    version=__version__,  # Usa la versión cargada dinámicamente # type: ignore
+)

package/tests/data_test.py

@@ -0,0 +1,122 @@
+import os
+import pytest
+from aioresponses import aioresponses
+from meteocatpy.data import MeteocatStationData
+from meteocatpy.exceptions import (
+    BadRequestError,
+    ForbiddenError,
+    TooManyRequestsError,
+    InternalServerError,
+    UnknownAPIError,
+)
+from meteocatpy.const import BASE_URL, STATION_DATA_URL
+from dotenv import load_dotenv
+
+# Cargar variables desde el archivo .env
+load_dotenv()
+
+# Obtener los valores del archivo .env
+API_KEY = os.getenv("METEOCAT_API_KEY")
+STATION_CODI_TEST = os.getenv("STATION_CODI_TEST")
+
+# Asegúrate de que las variables estén definidas
+assert API_KEY, "API Key is required"
+assert STATION_CODI_TEST, "Station codi test is required"
+
+@pytest.mark.asyncio
+async def test_get_station_data():
+    # Simular la respuesta de la API
+    test_url = f"{BASE_URL}{STATION_DATA_URL}".format(
+        codiEstacio=STATION_CODI_TEST, any=2024, mes="12", dia="04"
+    )
+    mock_response = {
+        "lectures": [
+            {"codi_variable": 32, "data": "2024-12-04T12:00:00Z", "valor": 15.2},
+            {"codi_variable": 33, "data": "2024-12-04T12:00:00Z", "valor": 80},
+        ]
+    }
+
+    with aioresponses() as mock:
+        mock.get(test_url, payload=mock_response)
+
+        station_data = MeteocatStationData(API_KEY)
+        result = await station_data.get_station_data(STATION_CODI_TEST)
+
+        assert result == mock_response
+
+
+@pytest.mark.asyncio
+async def test_get_station_data_with_variables(mocker):
+    # Simular la respuesta de la API y las variables
+    test_url = f"{BASE_URL}{STATION_DATA_URL}".format(
+        codiEstacio=STATION_CODI_TEST, any=2024, mes="12", dia="04"
+    )
+    mock_station_response = {
+        "lectures": [
+            {"codi_variable": 32, "data": "2024-12-04T12:00:00Z", "valor": 15.2},
+            {"codi_variable": 33, "data": "2024-12-04T12:00:00Z", "valor": 80},
+        ]
+    }
+    mock_variables_response = [
+        {"codi": 32, "nom": "Temperatura"},
+        {"codi": 33, "nom": "Humedad relativa"},
+    ]
+
+    # Mockear la llamada a la API y las variables
+    with aioresponses() as mock:
+        mock.get(test_url, payload=mock_station_response)
+        mocker.patch(
+            "meteocatpy.data.MeteocatVariables.get_variables",
+            return_value=mock_variables_response,
+        )
+
+        station_data = MeteocatStationData(API_KEY)
+        result = await station_data.get_station_data_with_variables(STATION_CODI_TEST)
+
+        # Validar los datos organizados por variables
+        expected_result = {
+            "Temperatura": [
+                {
+                    "data": "2024-12-04T12:00:00Z",
+                    "valor": 15.2,
+                    "estat": "",
+                    "base_horaria": "",
+                }
+            ],
+            "Humedad relativa": [
+                {
+                    "data": "2024-12-04T12:00:00Z",
+                    "valor": 80,
+                    "estat": "",
+                    "base_horaria": "",
+                }
+            ],
+        }
+        assert result == expected_result
+
+
+@pytest.mark.asyncio
+async def test_get_station_data_errors():
+    test_url = f"{BASE_URL}{STATION_DATA_URL}".format(
+        codiEstacio=STATION_CODI_TEST, any=2024, mes="12", dia="04"
+    )
+
+    # Simular errores de la API
+    with aioresponses() as mock:
+        mock.get(test_url, status=400, payload={"message": "Bad Request"})
+        station_data = MeteocatStationData(API_KEY)
+
+        with pytest.raises(BadRequestError):
+            await station_data.get_station_data(STATION_CODI_TEST)
+
+        mock.get(test_url, status=403, payload={"message": "Forbidden"})
+        with pytest.raises(ForbiddenError):
+            await station_data.get_station_data(STATION_CODI_TEST)
+
+        mock.get(test_url, status=429, payload={"message": "Too Many Requests"})
+        with pytest.raises(TooManyRequestsError):
+            await station_data.get_station_data(STATION_CODI_TEST)
+
+        mock.get(test_url, status=500, payload={"message": "Internal Server Error"})
+        with pytest.raises(InternalServerError):
+            await station_data.get_station_data(STATION_CODI_TEST)

package/tests/import_test.py

@@ -0,0 +1,18 @@
+def test_imports():
+    from meteocatpy import (
+        MeteocatTown,
+        MeteocatForecast,
+        MeteocatSymbols,
+        MeteocatStations,
+        MeteocatTownStations,
+        MeteocatStationData,
+        MeteocatVariables,
+    )
+
+    assert MeteocatTown is not None
+    assert MeteocatForecast is not None
+    assert MeteocatSymbols is not None
+    assert MeteocatStations is not None
+    assert MeteocatTownStations is not None
+    assert MeteocatStationData is not None
+    assert MeteocatVariables is not None

package/tests/integration_test_complete.py

@@ -0,0 +1,77 @@
+import os
+import pytest
+import json
+from dotenv import load_dotenv
+from meteocatpy.town import MeteocatTown
+from meteocatpy.forecast import MeteocatForecast
+
+# Cargar variables desde el archivo .env
+load_dotenv()
+
+# Obtener los valores del archivo .env
+API_KEY = os.getenv("METEOCAT_API_KEY")
+MUNICIPI_TEST = os.getenv("MUNICIPI_TEST")
+MUNICIPI_CODI_TEST = os.getenv("MUNICIPI_CODI_TEST")
+
+# Asegúrate de que las variables estén definidas
+assert API_KEY, "API Key is required"
+assert MUNICIPI_TEST, "Municipi test is required"
+assert MUNICIPI_CODI_TEST, "Municipi codi test is required"
+
+@pytest.mark.asyncio
+async def test_municipis():
+    # Crear una instancia de MeteocatTown con la API Key
+    town_client = MeteocatTown(API_KEY)
+
+    # Obtener los municipios
+    municipios_data = await town_client.get_municipis()
+
+    # Crear la carpeta si no existe
+    os.makedirs('tests/files', exist_ok=True)
+    
+    # Guardar los datos de los municipios en un archivo JSON
+    with open('tests/files/municipis.json', 'w', encoding='utf-8') as f:
+        json.dump(municipios_data, f, ensure_ascii=False, indent=4)
+    
+    # Verificar que los municipios no estén vacíos
+    assert municipios_data, "Municipis data is empty"
+    
+    # Verificar que el municipio de prueba esté en la lista
+    municipi_names = [m['nom'] for m in municipios_data]
+    assert MUNICIPI_TEST in municipi_names, f"{MUNICIPI_TEST} not found in municipis list"
+
+@pytest.mark.asyncio
+async def test_predict_horaria():
+    # Crear una instancia de MeteocatForecast con la API Key
+    forecast_client = MeteocatForecast(API_KEY)
+
+    # Obtener la predicción horaria para el municipio de prueba
+    prediccion_hora = await forecast_client.get_prediccion_horaria(MUNICIPI_CODI_TEST)
+
+    # Crear la carpeta si no existe
+    os.makedirs('tests/files', exist_ok=True)
+    
+    # Guardar la predicción horaria en un archivo JSON
+    with open('tests/files/predict_hora.json', 'w', encoding='utf-8') as f:
+        json.dump(prediccion_hora, f, ensure_ascii=False, indent=4)
+    
+    # Verificar que la predicción horaria no esté vacía
+    assert prediccion_hora, "Prediccion horaria is empty"
+
+@pytest.mark.asyncio
+async def test_predict_diaria():
+    # Crear una instancia de MeteocatForecast con la API Key
+    forecast_client = MeteocatForecast(API_KEY)
+
+    # Obtener la predicción diaria para el municipio de prueba
+    prediccion_dia = await forecast_client.get_prediccion_diaria(MUNICIPI_CODI_TEST)
+
+    # Crear la carpeta si no existe
+    os.makedirs('tests/files', exist_ok=True)
+    
+    # Guardar la predicción diaria en un archivo JSON
+    with open('tests/files/predict_dia.json', 'w', encoding='utf-8') as f:
+        json.dump(prediccion_dia, f, ensure_ascii=False, indent=4)
+    
+    # Verificar que la predicción diaria no esté vacía
+    assert prediccion_dia, "Prediccion diaria is empty"

package/tests/integration_test_forecast.py

@@ -0,0 +1,54 @@
+import os
+import pytest
+import json
+from dotenv import load_dotenv
+from meteocatpy.forecast import MeteocatForecast
+
+# Cargar variables desde el archivo .env
+load_dotenv()
+
+# Obtener los valores del archivo .env
+API_KEY = os.getenv("METEOCAT_API_KEY")
+MUNICIPI_TEST = os.getenv("MUNICIPI_TEST")
+MUNICIPI_CODI_TEST = os.getenv("MUNICIPI_CODI_TEST")
+
+# Asegúrate de que las variables estén definidas
+assert API_KEY, "API Key is required"
+assert MUNICIPI_TEST, "Municipi test is required"
+assert MUNICIPI_CODI_TEST, "Municipi codi test is required"
+
+@pytest.mark.asyncio
+async def test_predict_horaria():
+    # Crear una instancia de MeteocatForecast con la API Key
+    forecast_client = MeteocatForecast(API_KEY)
+
+    # Obtener la predicción horaria para el municipio de prueba
+    prediccion_hora = await forecast_client.get_prediccion_horaria(MUNICIPI_CODI_TEST)
+
+    # Crear la carpeta si no existe
+    os.makedirs('tests/files', exist_ok=True)
+    
+    # Guardar la predicción horaria en un archivo JSON
+    with open('tests/files/predict_hora.json', 'w', encoding='utf-8') as f:
+        json.dump(prediccion_hora, f, ensure_ascii=False, indent=4)
+    
+    # Verificar que la predicción horaria no esté vacía
+    assert prediccion_hora, "Prediccion horaria is empty"
+
+@pytest.mark.asyncio
+async def test_predict_diaria():
+    # Crear una instancia de MeteocatForecast con la API Key
+    forecast_client = MeteocatForecast(API_KEY)
+
+    # Obtener la predicción diaria para el municipio de prueba
+    prediccion_dia = await forecast_client.get_prediccion_diaria(MUNICIPI_CODI_TEST)
+
+    # Crear la carpeta si no existe
+    os.makedirs('tests/files', exist_ok=True)
+    
+    # Guardar la predicción diaria en un archivo JSON
+    with open('tests/files/predict_dia.json', 'w', encoding='utf-8') as f:
+        json.dump(prediccion_dia, f, ensure_ascii=False, indent=4)
+    
+    # Verificar que la predicción diaria no esté vacía
+    assert prediccion_dia, "Prediccion diaria is empty"

package/tests/integration_test_station_data.py

@@ -0,0 +1,34 @@
+import os
+import pytest
+import json
+from dotenv import load_dotenv
+from meteocatpy.data import MeteocatStationData
+
+# Cargar variables desde el archivo .env
+load_dotenv()
+
+# Obtener los valores del archivo .env
+API_KEY = os.getenv("METEOCAT_API_KEY")
+STATION_CODI_TEST = os.getenv("STATION_CODI_TEST")
+
+# Asegúrate de que las variables estén definidas
+assert API_KEY, "API Key is required"
+assert STATION_CODI_TEST, "Station codi test is required"
+
+@pytest.mark.asyncio
+async def test_stations_data():
+    # Crear una instancia de MeteocatStationData con la API Key
+    data_client = MeteocatStationData(API_KEY)
+
+    # Obtener los datos de la estación
+    station_data = await data_client.get_station_data(STATION_CODI_TEST)
+
+    # Crear la carpeta si no existe
+    os.makedirs('tests/files', exist_ok=True)
+    
+    # Guardar los datos de las estaciones en un archivo JSON
+    with open(f'tests/files/station_{STATION_CODI_TEST}_data.json', 'w', encoding='utf-8') as f:
+        json.dump(station_data, f, ensure_ascii=False, indent=4)
+    
+    # Verificar que los datos no estén vacíos
+    assert station_data, "Estaciones data is empty"

package/tests/integration_test_stations.py

@@ -0,0 +1,32 @@
+import os
+import pytest
+import json
+from dotenv import load_dotenv
+from meteocatpy.stations import MeteocatStations
+
+# Cargar variables desde el archivo .env
+load_dotenv()
+
+# Obtener los valores del archivo .env
+API_KEY = os.getenv("METEOCAT_API_KEY")
+
+# Asegúrate de que las variables estén definidas
+assert API_KEY, "API Key is required"
+
+@pytest.mark.asyncio
+async def test_stations():
+    # Crear una instancia de MeteocatStations con la API Key
+    stations_client = MeteocatStations(API_KEY)
+
+    # Obtener las estaciones
+    stations_data = await stations_client.get_stations()
+
+    # Crear la carpeta si no existe
+    os.makedirs('tests/files', exist_ok=True)
+    
+    # Guardar los datos de las estaciones en un archivo JSON
+    with open('tests/files/stations.json', 'w', encoding='utf-8') as f:
+        json.dump(stations_data, f, ensure_ascii=False, indent=4)
+    
+    # Verificar que los municipios no estén vacíos
+    assert stations_data, "Estaciones data is empty"

package/tests/integration_test_symbols.py

@@ -0,0 +1,68 @@
+import os
+import pytest
+import json
+from dotenv import load_dotenv
+from meteocatpy.symbols import MeteocatSymbols
+
+# Cargar variables desde el archivo .env
+load_dotenv()
+
+# Obtener los valores del archivo .env
+API_KEY = os.getenv("METEOCAT_API_KEY")
+
+# Asegúrate de que las variables estén definidas
+assert API_KEY, "API Key is required"
+
+@pytest.mark.asyncio
+async def test_simbols():
+    # Crear una instancia de MeteocatSymbols con la API Key
+    symbols_client = MeteocatSymbols(API_KEY)
+
+    # Obtener los símbolos
+    simbolos_data = await symbols_client.fetch_symbols()
+
+    # Verificar la estructura de los datos obtenidos
+    print("Estructura de los datos obtenidos:")
+    print(simbolos_data)  # Esto te mostrará si realmente es una lista de categorías
+
+    # Crear la carpeta si no existe
+    os.makedirs('tests/files', exist_ok=True)
+    
+    # Guardar el JSON completo original
+    with open('tests/files/simbols.json', 'w', encoding='utf-8') as f:
+        json.dump(simbolos_data, f, ensure_ascii=False, indent=4)
+
+    # Verificar que los símbolos no estén vacíos
+    assert simbolos_data, "Simbols data is empty"
+    
+    # Iterar sobre las categorías y guardar cada una en su propio archivo
+    for category in simbolos_data:
+        if "valors" in category:  # Asegurarse de que tenga "valors"
+            category_name = category['nom']  # Nombre de la categoría (e.g., "cel", "mar", etc.)
+            
+            # Reemplazar los espacios por guiones bajos en el nombre de la categoría
+            category_name_safe = category_name.replace(' ', '_')
+            
+            # Nombre del archivo con el prefijo "simbols_"
+            category_file_name = f'tests/files/simbols_{category_name_safe}.json'
+            
+            # Guardar la categoría y sus valores en un archivo JSON
+            category_data = {
+                "nom": category_name,
+                "descripcio": category["descripcio"],
+                "valors": category["valors"]
+            }
+
+            with open(category_file_name, 'w', encoding='utf-8') as f:
+                json.dump(category_data, f, ensure_ascii=False, indent=4)
+    
+    # Asegurarse de que se hayan creado los archivos correctamente
+    for category in simbolos_data:
+        if "valors" in category:
+            category_name = category['nom']
+            
+            # Reemplazar los espacios por guiones bajos también al verificar
+            category_name_safe = category_name.replace(' ', '_')
+            
+            category_file_name = f'tests/files/simbols_{category_name_safe}.json'
+            assert os.path.exists(category_file_name), f"File for category {category_name} was not created"

package/tests/integration_test_town.py

@@ -0,0 +1,32 @@
+import os
+import pytest
+import json
+from dotenv import load_dotenv
+from meteocatpy.town import MeteocatTown
+
+# Cargar variables desde el archivo .env
+load_dotenv()
+
+# Obtener los valores del archivo .env
+API_KEY = os.getenv("METEOCAT_API_KEY")
+
+# Asegúrate de que las variables estén definidas
+assert API_KEY, "API Key is required"
+
+@pytest.mark.asyncio
+async def test_municipis():
+    # Crear una instancia de MeteocatTown con la API Key
+    town_client = MeteocatTown(API_KEY)
+
+    # Obtener los municipios
+    municipios_data = await town_client.get_municipis()
+
+    # Crear la carpeta si no existe
+    os.makedirs('tests/files', exist_ok=True)
+    
+    # Guardar los datos de los municipios en un archivo JSON
+    with open('tests/files/municipis.json', 'w', encoding='utf-8') as f:
+        json.dump(municipios_data, f, ensure_ascii=False, indent=4)
+    
+    # Verificar que los municipios no estén vacíos
+    assert municipios_data, "Municipis data is empty"

package/tests/integration_test_town_stations.py

@@ -0,0 +1,36 @@
+import os
+import pytest
+import json
+from dotenv import load_dotenv
+from meteocatpy.townstations import MeteocatTownStations
+
+# Cargar variables desde el archivo .env
+load_dotenv()
+
+# Obtener los valores del archivo .env
+API_KEY = os.getenv("METEOCAT_API_KEY")
+MUNICIPI_CODI_TEST = os.getenv("MUNICIPI_CODI_TEST")
+VARIABLE_CODI_TEST = os.getenv("VARIABLE_CODI_TEST")
+
+# Asegúrate de que las variables estén definidas
+assert API_KEY, "API Key is required"
+assert MUNICIPI_CODI_TEST, "Municipi codi test is required"
+assert VARIABLE_CODI_TEST, "Variable codi test is required"
+
+@pytest.mark.asyncio
+async def test_town_stations():
+    # Crear una instancia de MeteocatTownStations con la API Key
+    town_stations_client = MeteocatTownStations(API_KEY)
+
+    # Obtener la lista de estaciones del municipio usando el código de municipio de prueba y la variable de prueba
+    town_stations_data = await town_stations_client.get_town_stations(MUNICIPI_CODI_TEST, VARIABLE_CODI_TEST)
+
+    # Crear la carpeta si no existe
+    os.makedirs('tests/files', exist_ok=True)
+    
+    # Guardar la lista de estaciones del municipio en un archivo JSON
+    with open(f'tests/files/stations_{MUNICIPI_CODI_TEST}_{VARIABLE_CODI_TEST}.json', 'w', encoding='utf-8') as f:
+        json.dump(town_stations_data, f, ensure_ascii=False, indent=4)
+    
+    # Verificar que la lista de estaciones del municipio no esté vacía
+    assert town_stations_data, "Estaciones data is empty"

package/tests/integration_test_variables.py

@@ -0,0 +1,32 @@
+import os
+import pytest
+import json
+from dotenv import load_dotenv
+from meteocatpy.variables import MeteocatVariables
+
+# Cargar variables desde el archivo .env
+load_dotenv()
+
+# Obtener los valores del archivo .env
+API_KEY = os.getenv("METEOCAT_API_KEY")
+
+# Asegúrate de que las variables estén definidas
+assert API_KEY, "API Key is required"
+
+@pytest.mark.asyncio
+async def test_variables():
+    # Crear una instancia de MeteocatVariables con la API Key
+    variables_client = MeteocatVariables(API_KEY)
+
+    # Obtener las variables
+    variables_data = await variables_client.get_variables()
+
+    # Crear la carpeta si no existe
+    os.makedirs('tests/files', exist_ok=True)
+    
+    # Guardar los datos de las variables en un archivo JSON
+    with open('tests/files/variables.json', 'w', encoding='utf-8') as f:
+        json.dump(variables_data, f, ensure_ascii=False, indent=4)
+    
+    # Verificar que las variables no estén vacías
+    assert variables_data, "Variables data is empty"