Update app.py

app.py

@@ -1,257 +1,161 @@
 import gradio as gr
-import requests
+import aiohttp
+import asyncio
 import urllib.parse
 import re
 import xmltodict
 
-# Función para obtener sugerencias de DuckDuckGo
-def fetch_duckduckgo_suggestions(query, lang_code="es"):
+# Función asíncrona para obtener sugerencias de DuckDuckGo
+async def fetch_duckduckgo_suggestions(session, query, lang_code="es"):
     encoded_query = urllib.parse.quote(query)
     url = f"https://duckduckgo.com/ac/?q={encoded_query}&kl={lang_code}"
-    response = requests.get(url)
-    if response.status_code == 200:
-        try:
-            data = response.json()
-            return [item['phrase'] for item in data]
-        except ValueError:
-            print("Error decodificando JSON de DuckDuckGo")
-            return []
-    else:
+    async with session.get(url) as response:
+        if response.status == 200:
+            try:
+                data = await response.json()
+                return [item['phrase'] for item in data]
+            except ValueError:
+                return []
         return []
 
-# Función para obtener sugerencias de Google
-def fetch_google_suggestions(query, lang_code="es"):
+# Función asíncrona para obtener sugerencias de Google
+async def fetch_google_suggestions(session, query, lang_code="es"):
     encoded_query = urllib.parse.quote(query)
     url = f"http://suggestqueries.google.com/complete/search?client=firefox&hl={lang_code}&q={encoded_query}"
-    response = requests.get(url)
-    if response.status_code == 200:
-        try:
-            return response.json()[1]
-        except ValueError:
-            print("Error decodificando JSON de Google")
-            return []
-    else:
+    async with session.get(url) as response:
+        if response.status == 200:
+            try:
+                return (await response.json())[1]
+            except ValueError:
+                return []
         return []
 
-# Función para obtener sugerencias de YouTube
-def fetch_youtube_suggestions(query, lang_code="es"):
+# Función asíncrona para obtener sugerencias de YouTube
+async def fetch_youtube_suggestions(session, query, lang_code="es"):
     encoded_query = urllib.parse.quote(query)
     url = f"http://suggestqueries.google.com/complete/search?client=youtube&hl={lang_code}&q={encoded_query}"
-    response = requests.get(url)
-    
-    if response.status_code == 200:
-        try:
-            # Extraer las sugerencias del formato window.google.ac.h(["..."])
-            match = re.search(r'window\.google\.ac\.h\(\["[^"]*",\[(.*?)\],', response.text)
-            if match:
-                suggestions_data = match.group(1)
-                # Extraemos las sugerencias
-                suggestions = re.findall(r'\["([^"]+)"', suggestions_data)
-                return suggestions
-            else:
-                print("No se encontraron sugerencias en el formato esperado.")
+    async with session.get(url) as response:
+        if response.status == 200:
+            try:
+                text = await response.text()
+                match = re.search(r'window\.google\.ac\.h\(\["[^"]*",\[(.*?)\],', text)
+                if match:
+                    suggestions_data = match.group(1)
+                    suggestions = re.findall(r'\["([^"]+)"', suggestions_data)
+                    return suggestions
+                return []
+            except Exception:
                 return []
-        except Exception as e:
-            print(f"Error procesando la respuesta de YouTube: {e}")
-            return []
-    else:
         return []
 
-# Función para obtener sugerencias de Bing
-def fetch_bing_suggestions(query, market="en-US"):
+# Función asíncrona para obtener sugerencias de Bing
+async def fetch_bing_suggestions(session, query, market="en-US"):
     url = "https://api.bing.com/qsml.aspx"
     params = {
         "Market": market,
         "query": query
     }
-    headers = {
-        "User-agent": "Mozilla/5.0"
-    }
-    response = requests.get(url, params=params, headers=headers)
-    
-    if response.status_code == 200:
-        try:
-            obj = xmltodict.parse(response.content)
-            suggestList = []
-            if 'SearchSuggestion' in obj and obj['SearchSuggestion']['Section']:
+    async with session.get(url, params=params) as response:
+        if response.status == 200:
+            try:
+                obj = xmltodict.parse(await response.text())
                 suggestions = obj['SearchSuggestion']['Section']['Item']
                 if isinstance(suggestions, list):
-                    for s in suggestions:
-                        suggestList.append(s['Text'])
+                    return [s['Text'] for s in suggestions]
                 elif isinstance(suggestions, dict):
-                    suggestList.append(suggestions['Text'])
-            return suggestList
-        except Exception as e:
-            print(f"Error procesando la respuesta de Bing: {e}")
-            return []
-    else:
+                    return [suggestions['Text']]
+                return []
+            except Exception:
+                return []
         return []
 
-# Función para obtener sugerencias de Amazon
-def fetch_amazon_suggestions(query, market_id="ATVPDKIKX0DER", alias="aps"):
+# Función asíncrona para obtener sugerencias de Amazon
+async def fetch_amazon_suggestions(session, query, market_id="ATVPDKIKX0DER", alias="aps"):
     url = "https://completion.amazon.com/api/2017/suggestions"
     params = {
         "mid": market_id,
         "alias": alias,
         "prefix": query
     }
-    response = requests.get(url, params=params)
-    
-    if response.status_code == 200:
-        try:
-            data = response.json()
-            # Extraemos las sugerencias desde el JSON bajo la clave 'suggestions'
-            return [item['value'] for item in data.get('suggestions', [])]
-        except ValueError:
-            print("Error decodificando JSON de Amazon")
-            return []
-    else:
+    async with session.get(url, params=params) as response:
+        if response.status == 200:
+            try:
+                data = await response.json()
+                return [item['value'] for item in data.get('suggestions', [])]
+            except ValueError:
+                return []
         return []
 
-# Función para expandir la palabra clave
+# Expansión de palabra clave: stopwords, prefijos/sufijos y variantes semánticas
 def expand_keyword(keyword):
-    expanded_keywords = [keyword]
-    for letter in 'abcdefghijklmnopqrstuvwxyz*_':
-        expanded_keywords.append(keyword + " " + letter)
-        expanded_keywords.append(letter + " " + keyword)
-    return expanded_keywords
-
-# Función principal
-def main(keyword):
-    expanded_keywords = expand_keyword(keyword)
-    all_suggestions = {}
-    google_suggestions_all = []
-    duckduckgo_suggestions_all = []
-    youtube_suggestions_all = []
-    bing_suggestions_all = []
-    amazon_suggestions_all = []
-
-    # Obtener sugerencias de DuckDuckGo
-    for exp_keyword in expanded_keywords:
-        suggestions = fetch_duckduckgo_suggestions(exp_keyword)
-        duckduckgo_suggestions_all.extend(suggestions)  # Agregar todas las sugerencias
-        for suggestion in suggestions:
-            if suggestion in all_suggestions:
-                all_suggestions[suggestion] += 1
-            else:
-                all_suggestions[suggestion] = 1
+    expanded_keywords = {keyword}
 
-    # Obtener sugerencias de Google
-    for exp_keyword in expanded_keywords:
-        suggestions = fetch_google_suggestions(exp_keyword)
-        google_suggestions_all.extend(suggestions)  # Agregar todas las sugerencias
-        for suggestion in suggestions:
-            if suggestion in all_suggestions:
-                all_suggestions[suggestion] += 1
-            else:
-                all_suggestions[suggestion] = 1
+    stopwords = ['de', 'para', 'con', 'en', 'y', 'o', 'sin', 'por', 'al']
+    prefixes = ['comprar', 'mejor', 'oferta', 'precio', 'barato']
+    suffixes = ['online', 'gratis', '2023', 'calidad', 'fácil', 'rápido']
 
-    # Obtener sugerencias de YouTube
-    for exp_keyword in expanded_keywords:
-        suggestions = fetch_youtube_suggestions(exp_keyword)
-        youtube_suggestions_all.extend(suggestions)  # Agregar todas las sugerencias
-        for suggestion in suggestions:
-            if suggestion in all_suggestions:
-                all_suggestions[suggestion] += 1
-            else:
-                all_suggestions[suggestion] = 1
+    # Combinaciones con letras, stopwords, prefijos y sufijos
+    for word in stopwords:
+        expanded_keywords.add(f"{keyword} {word}")
+        expanded_keywords.add(f"{word} {keyword}")
 
-    # Obtener sugerencias de Bing
-    for exp_keyword in expanded_keywords:
-        suggestions = fetch_bing_suggestions(exp_keyword)
-        bing_suggestions_all.extend(suggestions)
-        for suggestion in suggestions:
-            if suggestion in all_suggestions:
-                all_suggestions[suggestion] += 1
-            else:
-                all_suggestions[suggestion] = 1
+    for prefix in prefixes:
+        expanded_keywords.add(f"{prefix} {keyword}")
 
-    # Obtener sugerencias de Amazon
-    for exp_keyword in expanded_keywords:
-        suggestions = fetch_amazon_suggestions(exp_keyword)
-        amazon_suggestions_all.extend(suggestions)
-        for suggestion in suggestions:
-            if suggestion in all_suggestions:
-                all_suggestions[suggestion] += 1
-            else:
-                all_suggestions[suggestion] = 1
+    for suffix in suffixes:
+        expanded_keywords.add(f"{keyword} {suffix}")
 
-    # Filtrar las top 10 de cada plataforma con su número de repeticiones
-    google_top_10 = list(set(google_suggestions_all))[:10]
-    duckduckgo_top_10 = list(set(duckduckgo_suggestions_all))[:10]
-    youtube_top_10 = list(set(youtube_suggestions_all))[:10]
-    bing_top_10 = list(set(bing_suggestions_all))[:10]
-    amazon_top_10 = list(set(amazon_suggestions_all))[:10]
+    # Generar variantes de plurales y singulares
+    if not keyword.endswith('s'):
+        expanded_keywords.add(f"{keyword}s")
 
-    # Ordenar y filtrar las sugerencias más frecuentes combinadas
-    sorted_suggestions = sorted(all_suggestions.items(), key=lambda item: item[1], reverse=True)
-    combined_top_10_suggestions = [sug for sug, freq in sorted_suggestions if freq >= 2][:10]
-    suggestions_str = ", ".join(combined_top_10_suggestions)
-
-    # Crear la lista de todas las palabras clave con su número de repeticiones
-    all_suggestions_str = "<ul>"
-    for suggestion, freq in sorted_suggestions:
-        all_suggestions_str += f"<li>{suggestion} - {freq} repeticiones</li>"
-    all_suggestions_str += "</ul>"
-
-    # Crear el HTML de salida con un botón de copia
-    html_output = f"""
-    <div>
-        <b>Sugerencias combinadas de Google, DuckDuckGo, YouTube, Bing y Amazon (Top 10 combinadas):</b> <span id='suggestions_text'>{suggestions_str}</span>
-        <button class="lg secondary svelte-cmf5ev" style="font-size: small; padding: 2px; color: #808080ba; border: none; margin-left: 5px;" 
-        onclick='navigator.clipboard.writeText(document.getElementById("suggestions_text").innerText).then(() => alert("Texto copiado al portapapeles"))'>&nbsp;✂&nbsp;</button>
-    </div>
-
-    <h4>Top 10 Sugerencias de Google:</h4>
-    <ul>
-    """
-    for suggestion in google_top_10:
-        freq = all_suggestions[suggestion]
-        html_output += f"<li>{suggestion} ({freq})</li>"
-    html_output += "</ul>"
+    # Errores tipográficos comunes
+    if len(keyword) > 2:
+        expanded_keywords.add(keyword[:-1])  # Eliminamos una letra al final
+        expanded_keywords.add(keyword + keyword[-1])  # Duplicamos la última letra
 
-    html_output += """
-    <h4>Top 10 Sugerencias de DuckDuckGo:</h4>
-    <ul>
-    """
-    for suggestion in duckduckgo_top_10:
-        freq = all_suggestions[suggestion]
-        html_output += f"<li>{suggestion} ({freq})</li>"
-    html_output += "</ul>"
+    return list(expanded_keywords)
 
-    html_output += """
-    <h4>Top 10 Sugerencias de YouTube:</h4>
-    <ul>
-    """
-    for suggestion in youtube_top_10:
-        freq = all_suggestions[suggestion]
-        html_output += f"<li>{suggestion} ({freq})</li>"
-    html_output += "</ul>"
+# Función principal asíncrona para obtener todas las sugerencias
+async def main_async(keyword):
+    expanded_keywords = expand_keyword(keyword)
+    all_suggestions = {}
 
-    html_output += """
-    <h4>Top 10 Sugerencias de Bing:</h4>
-    <ul>
-    """
-    for suggestion in bing_top_10:
-        freq = all_suggestions[suggestion]
-        html_output += f"<li>{suggestion} ({freq})</li>"
-    html_output += "</ul>"
+    async with aiohttp.ClientSession() as session:
+        tasks = []
+        for exp_keyword in expanded_keywords:
+            tasks.append(fetch_google_suggestions(session, exp_keyword))
+            tasks.append(fetch_duckduckgo_suggestions(session, exp_keyword))
+            tasks.append(fetch_youtube_suggestions(session, exp_keyword))
+            tasks.append(fetch_bing_suggestions(session, exp_keyword))
+            tasks.append(fetch_amazon_suggestions(session, exp_keyword))
+        
+        results = await asyncio.gather(*tasks)
+
+    # Procesar los resultados
+    for result in results:
+        if result:
+            for suggestion in result:
+                if suggestion in all_suggestions:
+                    all_suggestions[suggestion] += 1
+                else:
+                    all_suggestions[suggestion] = 1
+
+    # Ordenar las sugerencias por su número de repeticiones
+    sorted_suggestions = sorted(all_suggestions.items(), key=lambda item: item[1], reverse=True)
+    
+    return sorted_suggestions
 
-    html_output += """
-    <h4>Top 10 Sugerencias de Amazon:</h4>
-    <ul>
-    """
-    for suggestion in amazon_top_10:
-        freq = all_suggestions[suggestion]
-        html_output += f"<li>{suggestion} ({freq})</li>"
+# Función de Gradio para mostrar los resultados
+def main(keyword):
+    suggestions = asyncio.run(main_async(keyword))
+    
+    # Crear el HTML de salida con el número de repeticiones
+    html_output = "<h4>Lista completa de palabras clave con su número de repeticiones:</h4><ul>"
+    for suggestion, freq in suggestions:
+        html_output += f"<li>{suggestion} - {freq} repeticiones</li>"
     html_output += "</ul>"
 
-    # Agregar la lista completa de todas las palabras clave
-    html_output += """
-    <h4>Lista completa de palabras clave con su número de repeticiones:</h4>
-    """
-    html_output += all_suggestions_str
-
     return html_output
 
 # Interfaz de Gradio
@@ -259,9 +163,9 @@ iface = gr.Interface(
     fn=main,
     inputs="text",
     outputs="html",
-    title="<div style='margin:0 auto;text-align:center'><div style='margin:0 auto;text-align:center'><img style='width:100px;display: inline-table;margin-bottom:-10px' src='https://artxeweb.com/media/files/search.jpg'><p>Sugerencias Combinadas de Google, DuckDuckGo, YouTube, Bing y Amazon</p></div>",
-    description="<p style='margin-bottom:10px;text-align:center;background: #ffffff; padding: 8px; border-radius: 8px; border-width: 1px; border: solid 1px #e5e7eb;'>Ingrese una palabra clave para obtener sugerencias de búsqueda relacionadas de Google, DuckDuckGo, YouTube, Bing y Amazon. Se mostrarán las 10 primeras sugerencias combinadas y también las 10 principales de cada plataforma por separado.</p>",
-    article="<div style='margin-top:10px'><p style='text-align: center !important; background: #ffffff; padding: 5px 30px; border-radius: 8px; border-width: 1px; border: solid 1px #e5e7eb; width: fit-content; margin: auto;'>Desarrollada por <a style='text-decoration: none !important; color: #e12a31 !important;' href='https://artxeweb.com'>© Artxe Web</a></p></div>"
+    title="Sugerencias Combinadas de Google, DuckDuckGo, YouTube, Bing y Amazon",
+    description="Ingrese una palabra clave para obtener sugerencias de búsqueda relacionadas de varias plataformas. Las sugerencias se ordenan por su número de repeticiones.",
+    article="Desarrollada por © Artxe Web"
 )
 
 iface.launch()