Update app.py

app.py

@@ -1,93 +1,145 @@
 from fastapi import FastAPI, HTTPException, Query
 from fastapi.middleware.cors import CORSMiddleware
-from duckduckgo_search import DDGS
 import requests
+from bs4 import BeautifulSoup
 import uvicorn
+import urllib.parse
 
-app = FastAPI(title="Glimpse Search API", description="API unificada para múltiples motores de búsqueda")
+app = FastAPI(title="Glimpse Scraping API", description="API de Scraping directo para buscadores")
 
-# Habilitar CORS para que tu app frontend pueda consumir esta API sin errores
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["*"], # En producción, puedes cambiar "*" por el dominio de tu app
+    allow_origins=["*"],
     allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],
 )
 
-# Servidores públicos de SearXNG como fallback para los otros motores
-SEARXNG_INSTANCES = [
-    "https://searx.be/search",
-    "https://searx.fmac.network/search",
-    "https://search.mdosch.de/search"
-]
+# User-Agent de un navegador real para evitar bloqueos
+HEADERS = {
+    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+    "Accept-Language": "es-ES,es;q=0.9,en;q=0.8"
+}
+
+def scrape_duckduckgo(query: str):
+    # Usamos la versión HTML plana de DDG que es más fácil de scrapear
+    url = f"https://html.duckduckgo.com/html/?q={urllib.parse.quote(query)}"
+    resp = requests.get(url, headers=HEADERS, timeout=10)
+    resp.raise_for_status()
+    soup = BeautifulSoup(resp.text, 'lxml')
+    
+    results = []
+    for result in soup.select('.result__body'):
+        title_tag = result.select_one('.result__title a')
+        snippet_tag = result.select_one('.result__snippet')
+        
+        if title_tag:
+            # Limpiar la URL de redirección de DDG
+            raw_url = title_tag.get('href', '')
+            clean_url = urllib.parse.unquote(raw_url.replace('//duckduckgo.com/l/?uddg=', '').split('&')[0])
+            
+            results.append({
+                "title": title_tag.text.strip(),
+                "url": clean_url if clean_url.startswith('http') else raw_url,
+                "content": snippet_tag.text.strip() if snippet_tag else ""
+            })
+    return results
+
+def scrape_mojeek(query: str):
+    url = f"https://www.mojeek.com/search?q={urllib.parse.quote(query)}&fmt=html"
+    resp = requests.get(url, headers=HEADERS, timeout=10)
+    resp.raise_for_status()
+    soup = BeautifulSoup(resp.text, 'lxml')
+    
+    results = []
+    for li in soup.select('ul.results-standard > li'):
+        a_tag = li.select_one('a.ob')
+        p_tag = li.select_one('p.s')
+        
+        if a_tag:
+            results.append({
+                "title": a_tag.text.strip(),
+                "url": a_tag.get('href', ''),
+                "content": p_tag.text.strip() if p_tag else ""
+            })
+    return results
+
+def scrape_qwant(query: str):
+    # Usamos Qwant Lite que no requiere renderizado de JavaScript
+    url = f"https://lite.qwant.com/?q={urllib.parse.quote(query)}"
+    resp = requests.get(url, headers=HEADERS, timeout=10)
+    resp.raise_for_status()
+    soup = BeautifulSoup(resp.text, 'lxml')
+    
+    results = []
+    for article in soup.select('article.result'):
+        title_tag = article.select_one('h2 a')
+        snippet_tag = article.select_one('.result-snippet')
+        
+        if title_tag:
+            results.append({
+                "title": title_tag.text.strip(),
+                "url": title_tag.get('href', ''),
+                "content": snippet_tag.text.strip() if snippet_tag else ""
+            })
+    return results
+
+def scrape_brave(query: str):
+    url = f"https://search.brave.com/search?q={urllib.parse.quote(query)}"
+    resp = requests.get(url, headers=HEADERS, timeout=10)
+    resp.raise_for_status()
+    soup = BeautifulSoup(resp.text, 'lxml')
+    
+    results = []
+    for snippet in soup.select('.snippet'):
+        title_tag = snippet.select_one('.heading')
+        link_tag = snippet.select_one('a')
+        desc_tag = snippet.select_one('.snippet-content, .snippet-description')
+        
+        if title_tag and link_tag:
+            results.append({
+                "title": title_tag.text.strip(),
+                "url": link_tag.get('href', ''),
+                "content": desc_tag.text.strip() if desc_tag else ""
+            })
+    return results
 
 @app.get("/")
 def read_root():
-    return {"status": "Glimpse API is running. Use the /search endpoint."}
+    return {"status": "Glimpse Scraping API is running!"}
 
 @app.get("/search")
 def search(
     q: str = Query(..., description="Término de búsqueda"), 
-    engine: str = Query("duckduckgo", description="duckduckgo, brave, startpage, mojeek, qwant")
+    engine: str = Query("duckduckgo", description="duckduckgo, mojeek, qwant, brave")
 ):
-    results = []
     engine = engine.lower()
+    results = []
 
-    # 1. Búsqueda nativa y rápida con DuckDuckGo
-    if engine == "duckduckgo":
-        try:
-            with DDGS() as ddgs:
-                # max_results controla cuántos enlaces devuelves
-                ddg_results = list(ddgs.text(q, max_results=15)) 
-                for r in ddg_results:
-                    results.append({
-                        "title": r.get("title", ""),
-                        "url": r.get("href", ""),
-                        "content": r.get("body", "")
-                    })
-        except Exception as e:
-            raise HTTPException(status_code=500, detail=f"Error en DuckDuckGo: {str(e)}")
-
-    # 2. Búsqueda con Brave, Startpage, Mojeek a través del puente de SearXNG
-    else:
-        # Si enviaste "tapnav", lo mapearemos a algo que Searxng entienda, como qwant
-        if engine == "tapnav":
-            engine = "qwant"
-
-        success = False
-        params = {
-            "q": q,
-            "format": "json",
-            "engines": engine,
-            "language": "es-ES"
-        }
-
-        # Intentar en nuestras instancias de fallback si alguna falla
-        for instance in SEARXNG_INSTANCES:
-            try:
-                resp = requests.get(instance, params=params, timeout=5)
-                resp.raise_for_status()
-                data = resp.json()
-                
-                for r in data.get("results", []):
-                    results.append({
-                        "title": r.get("title", ""),
-                        "url": r.get("url", ""),
-                        "content": r.get("content", "")
-                    })
-                success = True
-                break # Si tuvo éxito, salimos del bucle
-            except Exception as e:
-                print(f"Falló la instancia {instance} para el motor {engine}: {e}")
-                continue
-        
-        if not success:
-            raise HTTPException(status_code=503, detail=f"Todos los servidores proxy para el motor {engine} fallaron temporalmente.")
+    try:
+        if engine == "duckduckgo":
+            results = scrape_duckduckgo(q)
+        elif engine == "mojeek":
+            results = scrape_mojeek(q)
+        elif engine in ["qwant", "tapnav"]:
+            results = scrape_qwant(q)
+        elif engine == "brave":
+            results = scrape_brave(q)
+        elif engine == "startpage":
+            # Startpage bloquea el scraping crudo agresivamente (usa tokens). 
+            # Redirigimos silenciosamente a DuckDuckGo como fallback
+            results = scrape_duckduckgo(q)
+        else:
+            results = scrape_duckduckgo(q)
+            
+    except requests.exceptions.HTTPError as e:
+        if e.response.status_code == 403:
+            raise HTTPException(status_code=403, detail=f"El motor {engine} nos bloqueó (Protección Anti-Bot/CORS).")
+        raise HTTPException(status_code=500, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error al procesar el HTML de {engine}: {str(e)}")
 
-    # Devolvemos exactamente el formato que espera tu HTML
     return {"results": results}
 
 if __name__ == "__main__":
-    # Hugging Face expone los puertos en el 7860 por defecto
     uvicorn.run(app, host="0.0.0.0", port=7860)