Update app.py

app.py

@@ -1,180 +1,149 @@
 import gradio as gr
 from groq import Groq
 import openai
-import google.generativeai as genai
 import requests
 import json
+from google import genai
+from google.genai import types
 from googleapiclient.discovery import build
-from PIL import Image
-from io import BytesIO
 
 
-# Función para inicializar el cliente de Groq con la API key proporcionada
-def create_groq_client(api_key):
-    return Groq(api_key=api_key)
-
-# Función para verificar la API de Groq
+# ---- VERIFICACIÓN GROQ ----
 def verificar_api_groq(api_key):
-    client = create_groq_client(api_key)
-    messages = [
-        {"role": "user", "content": "Hola"}
-    ]
-
     try:
+        client = Groq(api_key=api_key)
         completion = client.chat.completions.create(
-            messages=messages,
-            model="llama3-70b-8192",
-            temperature=0.7,
-            max_tokens=200,
-            top_p=0.9,
-            stream=False
+            model="openai/gpt-oss-20b",
+            messages=[{"role": "user", "content": "hola"}],
+            temperature=1,
+            max_completion_tokens=50,
+            top_p=1,
+            reasoning_effort="medium",
+            stream=False,
+            stop=None
         )
-        return True  # API válida
-    except Exception:
-        return False  # API inválida
 
-# Función para verificar la API de OpenAI
+        # Verifica que haya texto en la respuesta
+        if completion.choices and completion.choices[0].message.content:
+            return True
+        return False
+    except Exception as e:
+        print("Error en Groq:", e)
+        return False
+
+
+# ---- VERIFICACIÓN GEMINI (nuevo SDK google-genai) ----
+def verificar_api_gemini(api_key):
+    try:
+        client = genai.Client(api_key=api_key)
+        model = "gemini-2.5-pro"
+
+        contents = [
+            types.Content(
+                role="user",
+                parts=[types.Part.from_text(text="Hola")]
+            )
+        ]
+
+        generate_content_config = types.GenerateContentConfig(
+            thinking_config=types.ThinkingConfig(thinking_budget=-1)
+        )
+
+        # No usamos streaming para solo testear
+        response = client.models.generate_content(
+            model=model,
+            contents=contents,
+            config=generate_content_config
+        )
+
+        # Si hay texto, la API es válida
+        return bool(response.candidates and response.candidates[0].content.parts[0].text.strip())
+    except Exception as e:
+        print("Error en Gemini:", e)
+        return False
+
+
+# ---- RESTO DE FUNCIONES IGUALES ----
 def verificar_api_openai(api_key):
     openai.api_key = api_key
     try:
         response = openai.ChatCompletion.create(
             model="gpt-3.5-turbo",
-            messages=[
-                {"role": "user", "content": "Hola"}
-            ],
+            messages=[{"role": "user", "content": "Hola"}],
             max_tokens=50,
             temperature=0.7
         )
-        return True  # API válida
-    except openai.OpenAIError:
-        return False  # API inválida
+        return True
     except Exception:
-        return False  # API inválida
+        return False
 
-# Función para verificar la API de Google Gemini
-def verificar_api_gemini(api_key):
-    try:
-        # Configurar la API de Google Gemini
-        genai.configure(api_key=api_key)
-        model = genai.GenerativeModel('gemini-1.5-pro')
-        response = model.generate_content("Test message")
-        return response is not None  # API válida si hay respuesta
-    except Exception:
-        return False  # API inválida
 
-# Función para verificar la API de OpenRouter
 def verificar_api_openrouter(api_key):
     url = "https://openrouter.ai/api/v1/chat/completions"
-    headers = {
-        "Authorization": f"Bearer {api_key}",
-        "Content-Type": "application/json"
-    }
+    headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
     data = {
         "model": "google/gemma-2-9b-it:free",
-        "messages": [
-            {
-                "role": "user",
-                "content": "What is the meaning of life?"
-            }
-        ]
+        "messages": [{"role": "user", "content": "What is the meaning of life?"}]
     }
 
     try:
-        response = requests.post(url, headers=headers, data=json.dumps(data))
-        if response.status_code == 200:
-            return True  # API válida
-        else:
-            return False  # API inválida
+        r = requests.post(url, headers=headers, data=json.dumps(data))
+        return r.status_code == 200
     except Exception:
-        return False  # API inválida
+        return False
+
 
-# Función para verificar la API de YouTube
 def verificar_api_youtube(api_key):
     try:
-        # Configurar el cliente de la API de YouTube
         youtube = build("youtube", "v3", developerKey=api_key)
-
-        # Realizar una solicitud de búsqueda para comprobar si la API funciona
-        search_response = youtube.search().list(
-            q="test",
-            part="snippet",
-            maxResults=1
-        ).execute()
-
-        # Si se obtiene una respuesta sin errores, la API es válida
-        return bool(search_response.get("items", []))
+        resp = youtube.search().list(q="test", part="snippet", maxResults=1).execute()
+        return bool(resp.get("items", []))
     except Exception:
-        return False  # API inválida
+        return False
+
 
-# Función para verificar la API de Pexels
 def verificar_api_pexels(api_key):
     try:
         url = "https://api.pexels.com/v1/search"
-        headers = {
-            "Authorization": api_key
-        }
-        params = {
-            "query": "nature",
-            "per_page": 1
-        }
-
-        response = requests.get(url, headers=headers, params=params)
-
-        # Si la respuesta es exitosa, la API es válida
-        if response.status_code == 200:
-            data = response.json()
-            return "photos" in data and len(data["photos"]) > 0
-        else:
-            return False  # API inválida
+        headers = {"Authorization": api_key}
+        params = {"query": "nature", "per_page": 1}
+        r = requests.get(url, headers=headers, params=params)
+        if r.status_code == 200:
+            d = r.json()
+            return "photos" in d and len(d["photos"]) > 0
+        return False
     except Exception:
-        return False  # API inválida
+        return False
+
 
-# Función para verificar la API de Google Places
 def verificar_api_google_places(api_key):
     try:
         url = "https://maps.googleapis.com/maps/api/place/textsearch/json"
-        params = {
-            "query": "restaurants",
-            "location": "0,0",
-            "radius": 1000,
-            "key": api_key
-        }
-
-        response = requests.get(url, params=params)
-
-        # Si la respuesta es exitosa, la API es válida
-        if response.status_code == 200:
-            data = response.json()
-            return "results" in data and len(data["results"]) > 0
-        else:
-            return False  # API inválida
+        params = {"query": "restaurants", "location": "0,0", "radius": 1000, "key": api_key}
+        r = requests.get(url, params=params)
+        if r.status_code == 200:
+            d = r.json()
+            return "results" in d and len(d["results"]) > 0
+        return False
     except Exception:
-        return False  # API inválida
+        return False
+
 
-# Función para verificar la API de Unsplash
 def verificar_api_unsplash(api_key):
     try:
         url = "https://api.unsplash.com/search/photos"
-        headers = {
-            "Authorization": f"Client-ID {api_key}"
-        }
-        params = {
-            "query": "nature",
-            "per_page": 1
-        }
-
-        response = requests.get(url, headers=headers, params=params)
-
-        # Si la respuesta es exitosa, la API es válida
-        if response.status_code == 200:
-            data = response.json()
-            return "results" in data and len(data["results"]) > 0
-        else:
-            return False  # API inválida
+        headers = {"Authorization": f"Client-ID {api_key}"}
+        params = {"query": "nature", "per_page": 1}
+        r = requests.get(url, headers=headers, params=params)
+        if r.status_code == 200:
+            d = r.json()
+            return "results" in d and len(d["results"]) > 0
+        return False
     except Exception:
-        return False  # API inválida
+        return False
 
-# Función general para verificar una lista de API keys
+
+# ---- VERIFICADOR GENERAL ----
 def verificar_apis(api_keys_text, api_type):
     api_keys = api_keys_text.strip().split("\n")
     apis_validas = []
@@ -204,28 +173,29 @@ def verificar_apis(api_keys_text, api_type):
         else:
             continue
 
-        # Clasificar las APIs en válidas o inválidas
         if es_valida:
             apis_validas.append(api_key)
         else:
             apis_invalidas.append(api_key)
 
-    # Formatear el resultado final con las secciones separadas
-    resultado_final = "✅ APIs válidas:\n" + "\n".join(apis_validas) + "\n\n⛔ APIs inválidas:\n" + "\n".join(apis_invalidas)
+    resultado_final = (
+        "✅ APIs válidas:\n" + "\n".join(apis_validas) +
+        "\n\n⛔ APIs inválidas:\n" + "\n".join(apis_invalidas)
+    )
     return resultado_final
 
-# Interfaz de Gradio
+
+# ---- INTERFAZ ----
 iface = gr.Interface(
     fn=verificar_apis,
     inputs=[
-        gr.Textbox(label="API Keys (una por línea)", lines=10, placeholder="Introduce cada API key en una línea diferente..."),
+        gr.Textbox(label="API Keys (una por línea)", lines=10, placeholder="Introduce cada API key..."),
         gr.Radio(["Groq", "OpenAI", "Google Gemini", "OpenRouter", "YouTube", "Pexels", "Google Places", "Unsplash"], label="Tipo de API")
     ],
     outputs="text",
-    title="Verificación de Múltiples APIs (Groq, OpenAI, Google Gemini, OpenRouter, YouTube, Pexels, Google Places, Unsplash)",
-    description="Ingresa una lista de API keys (una por línea) y selecciona el tipo de API para verificar cuáles están disponibles."
+    title="Verificación de APIs (Groq, OpenAI, Gemini, etc.)",
+    description="Comprueba si tus API keys siguen activas y funcionando."
 )
 
-# Ejecutar la interfaz en Hugging Face Space
 if __name__ == "__main__":
     iface.launch()