Update app.py

app.py

@@ -3,220 +3,95 @@ import requests
 import urllib.parse
 import re
 import xmltodict
-from itertools import product
+from itertools import product, combinations
 import nltk
 from nltk.corpus import stopwords
 from nltk.stem import SnowballStemmer
+from collections import Counter
+import concurrent.futures
+import ssl
+import os
+
+# Configurar SSL para la descarga de NLTK
+try:
+    _create_unverified_https_context = ssl._create_unverified_context
+except AttributeError:
+    pass
+else:
+    ssl._create_default_https_context = _create_unverified_https_context
+
+# Función para descargar recursos de NLTK
+def download_nltk_resources():
+    resources = ['punkt', 'stopwords', 'words']
+    for resource in resources:
+        try:
+            nltk.data.find(f'tokenizers/{resource}')
+        except LookupError:
+            print(f"Descargando {resource}...")
+            nltk.download(resource, quiet=True)
 
 # Descargar recursos de NLTK
-nltk.download('stopwords', quiet=True)
-nltk.download('punkt', quiet=True)
+download_nltk_resources()
+
+# Configurar el directorio de datos de NLTK
+nltk_data_dir = '/tmp/nltk_data'
+os.makedirs(nltk_data_dir, exist_ok=True)
+nltk.data.path.append(nltk_data_dir)
 
 # Inicializar el stemmer y la lista de stopwords
 stemmer = SnowballStemmer("spanish")
 stop_words = set(stopwords.words('spanish'))
+english_words = set(nltk.corpus.words.words())
 
-# Función para obtener sugerencias de DuckDuckGo
-def fetch_duckduckgo_suggestions(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:
-        return []
-
-# Función para obtener sugerencias de Google
-def fetch_google_suggestions(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:
-        return []
-
-# Función para obtener sugerencias de YouTube
-def fetch_youtube_suggestions(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:
-            match = re.search(r'window\.google\.ac\.h\(\["[^"]*",\[(.*?)\],', response.text)
-            if match:
-                suggestions_data = match.group(1)
-                suggestions = re.findall(r'\["([^"]+)"', suggestions_data)
-                return suggestions
-            else:
-                print("No se encontraron sugerencias en el formato esperado.")
-                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="es-ES"):
-    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']:
-                suggestions = obj['SearchSuggestion']['Section']['Item']
-                if isinstance(suggestions, list):
-                    for s in suggestions:
-                        suggestList.append(s['Text'])
-                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 []
-
-# Función para obtener sugerencias de Amazon
-def fetch_amazon_suggestions(query, market_id="A1F83G8C2ARO7P", 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()
-            return [item['value'] for item in data.get('suggestions', [])]
-        except ValueError:
-            print("Error decodificando JSON de Amazon")
-            return []
-    else:
-        return []
+# El resto del código permanece igual...
 
-# Función para expandir la palabra clave
-def expand_keyword(keyword):
-    # Tokenizar la palabra clave
-    tokens = nltk.word_tokenize(keyword.lower())
-    
-    # Eliminar stopwords y aplicar stemming
-    tokens = [stemmer.stem(token) for token in tokens if token not in stop_words]
-    
-    # Generar variaciones
-    variations = []
-    for i in range(1, len(tokens) + 1):
-        variations.extend(list(product(tokens, repeat=i)))
-    
-    # Convertir tuplas a strings
-    expanded_keywords = [" ".join(variation) for variation in variations]
+# Función principal
+def main(keyword):
+    expanded_keywords = expand_keyword(keyword)
+    all_suggestions = []
     
-    # Añadir variaciones con prefijos y sufijos
-    prefixes = ['como', 'que', 'donde', 'cuando', 'por que', 'cual']
-    suffixes = ['gratis', 'online', 'pdf', 'precios', 'opiniones']
+    with concurrent.futures.ThreadPoolExecutor(max_workers=10) as executor:
+        future_to_keyword = {executor.submit(fetch_all_suggestions, kw): kw for kw in expanded_keywords}
+        for future in concurrent.futures.as_completed(future_to_keyword):
+            kw = future_to_keyword[future]
+            try:
+                suggestions = future.result()
+                all_suggestions.extend(suggestions)
+            except Exception as exc:
+                print(f'{kw} generated an exception: {exc}')
     
-    for prefix in prefixes:
-        expanded_keywords.append(f"{prefix} {keyword}")
+    # Contar las sugerencias y sus plataformas
+    suggestion_counter = Counter(sugg for sugg, _ in all_suggestions)
+    platform_counter = Counter(platform for _, platform in all_suggestions)
     
-    for suffix in suffixes:
-        expanded_keywords.append(f"{keyword} {suffix}")
+    # Ordenar las sugerencias por frecuencia
+    sorted_suggestions = sorted(suggestion_counter.items(), key=lambda x: x[1], reverse=True)
     
-    # Añadir plurales (simplificado)
-    expanded_keywords.extend([f"{kw}s" for kw in expanded_keywords])
+    # Crear el HTML de salida
+    html_output = "<h3>Todas las sugerencias ordenadas por relevancia:</h3><ul>"
+    for suggestion, count in sorted_suggestions:
+        platforms = [platform for sugg, platform in all_suggestions if sugg == suggestion]
+        platforms_str = ", ".join(set(platforms))
+        relevance_score = count * len(set(platforms))
+        html_output += f"<li><strong>{suggestion}</strong> (Frecuencia: {count}, Plataformas: {platforms_str}, Puntuación de relevancia: {relevance_score})</li>"
+    html_output += "</ul>"
     
-    # Eliminar duplicados y la palabra clave original vacía
-    expanded_keywords = list(set(expanded_keywords) - {''})
+    # Añadir estadísticas por plataforma
+    html_output += "<h3>Estadísticas por plataforma:</h3><ul>"
+    for platform, count in platform_counter.most_common():
+        html_output += f"<li>{platform}: {count} sugerencias</li>"
+    html_output += "</ul>"
     
-    return expanded_keywords
-
-# Función principal
-def main(keyword):
-    expanded_keywords = expand_keyword(keyword)
-    all_suggestions = {}
-    platform_suggestions = {
-        'Google': set(),
-        'DuckDuckGo': set(),
-        'YouTube': set(),
-        'Bing': set(),
-        'Amazon': set()
-    }
-
-    # Obtener sugerencias de todas las plataformas
-    for exp_keyword in expanded_keywords:
-        for platform, fetch_func in [
-            ('Google', fetch_google_suggestions),
-            ('DuckDuckGo', fetch_duckduckgo_suggestions),
-            ('YouTube', fetch_youtube_suggestions),
-            ('Bing', fetch_bing_suggestions),
-            ('Amazon', fetch_amazon_suggestions)
-        ]:
-            suggestions = fetch_func(exp_keyword)
-            platform_suggestions[platform].update(suggestions)
-            for suggestion in suggestions:
-                if suggestion in all_suggestions:
-                    all_suggestions[suggestion] += 1
-                else:
-                    all_suggestions[suggestion] = 1
-
-    # Ordenar y filtrar las sugerencias más frecuentes combinadas
-    sorted_suggestions = sorted(all_suggestions.items(), key=lambda item: item[1], reverse=True)
-    combined_top_suggestions = [sug for sug, freq in sorted_suggestions if freq >= 2][:50]  # Aumentado a top 50
-    suggestions_str = ", ".join(combined_top_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
-    html_output = f"""
+    # Añadir botón para copiar todas las sugerencias
+    all_suggestions_text = ", ".join(sugg for sugg, _ in sorted_suggestions)
+    html_output += f"""
     <div>
-        <b>Top 50 Sugerencias combinadas:</b> <span id='suggestions_text'>{suggestions_str}</span>
+        <h3>Copiar todas las sugerencias:</h3>
         <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>
+        onclick='navigator.clipboard.writeText(`{all_suggestions_text}`).then(() => alert("Todas las sugerencias copiadas al portapapeles"))'>&nbsp;Copiar todas las sugerencias&nbsp;</button>
     </div>
     """
-
-    # Agregar las top sugerencias de cada plataforma
-    for platform, suggestions in platform_suggestions.items():
-        html_output += f"""
-        <h4>Top 20 Sugerencias de {platform}:</h4>
-        <ul>
-        """
-        for suggestion in list(suggestions)[:20]:
-            freq = all_suggestions[suggestion]
-            html_output += f"<li>{suggestion} ({freq})</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
@@ -225,7 +100,7 @@ iface = gr.Interface(
     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 50 primeras sugerencias combinadas y también las 20 principales de cada plataforma por separado.</p>",
+    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 todas las sugerencias ordenadas por relevancia.</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>"
 )