Skip to content
TheChatArchiveThe Chat Archive
gpt-4o-2024-08-06· OpenAIAi2 WildChat-4.8M (AI2)

convierte este codigo para que pueda ser llamada desde otros ficheros python como…

  1. User

    convierte este codigo para que pueda ser llamada desde otros ficheros python como libreria y pasandole la url y que devuelva el texto tanto si es de pdf como de texto: "import requests from bs4 import BeautifulSoup import PyPDF2 from io import BytesIO

    def check_url_content_type(url): try: # Realizar una solicitud HEAD para obtener solo los encabezados response = requests.head(url, allow_redirects=True) content_type = response.headers.get('Content-Type', '').lower()

        # Determinar el tipo de contenido
        if 'application/pdf' in content_type:
            return 'pdf'
        elif 'text/html' in content_type:
            return 'html'
        else:
            return 'other'
    
    except requests.exceptions.RequestException as e:
        print(f'Error al realizar la solicitud: {e}')
        return None
    

    Definir la variable con la URL

    url = 'https://artsanddivinityfacultyjournal.wp.st-andrews.ac.uk/files/2022/10/A-surprising-gap_-The-usage-of-Pazuzu-and-Lamashtu-amulets-in-Mesopotamian-birthing-practices.pdf'

    Definir los headers para la solicitud

    headers = { 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36', 'Accept-Language': 'en-US,en;q=0.9', # Puedes agregar más headers si es necesario }

    try: # Realizar la solicitud a la URL con headers response = requests.get(url, headers=headers) #content type print(response.headers['content-type']) content_type = check_url_content_type(url)

    # Verificar que la solicitud fue exitosa
    response.raise_for_status()  # Esto lanzará un error si la solicitud falló
    
    if content_type == 'html':
        # Analizar el contenido de la página HTML
        soup = BeautifulSoup(response.text, 'html.parser')
    
        # Extraer el texto
        text = soup.get_text()
    
        # Limpiar y dar formato al texto para que sea legible
        formatted_text = '\n'.join([line.strip() for line in text.splitlines() if line.strip()])
    
        # Mostrar el texto por pantalla
        print(formatted_text)
        print("\n")
    
    elif content_type == 'pdf':
        # Leer el contenido del PDF
        pdf_file = BytesIO(response.content)
        pdf_reader = PyPDF2.PdfReader(pdf_file)
    
        # Extraer texto de cada página
        pdf_text = ''
        for page in pdf_reader.pages:
            # si la longitud de pdf_text es mayor a 1000000, cortar el texto
            if len(pdf_text) > 100000:
                break
            pdf_text += page.extract_text()
    
        # Mostrar el texto extraído del PDF
        print(pdf_text)
                
    

    except requests.exceptions.RequestException as e: print(f'Error al realizar la solicitud: {e}')

    except Exception as e: print(f'Ocurrió un error: {e}')"

  2. Assistant

    Para convertir el código que proporcionaste en una función que se puede llamar desde otros archivos de Python, necesitas encapsular el comportamiento en una función que acepte una URL como argumento y que devuelva el texto en lugar de imprimirlo. Aquí te muestro cómo podrías hacerlo:

    import requests
    from bs4 import BeautifulSoup
    import PyPDF2
    from io import BytesIO
    
    def fetch_text_from_url(url):
        """
        Obtiene el texto de una URL que puede ser un documento HTML o PDF.
        
        :param url: Una cadena que representa la URL de la que se desea obtener el texto.
        :return: Una tupla (tipo_de_contenido, texto) donde 'tipo_de_contenido' es 'html', 'pdf' o 'other',
                 y 'texto' es el texto extraído o un mensaje de error.
        """
        
        def check_url_content_type(url):
            try:
                response = requests.head(url, allow_redirects=True)
                content_type = response.headers.get('Content-Type', '').lower()
                
                if 'application/pdf' in content_type:
                    return 'pdf'
                elif 'text/html' in content_type:
                    return 'html'
                else:
                    return 'other'
            except requests.exceptions.RequestException as e:
                return None
    
        headers = {
            'User-Agent': ('Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 '
                           '(KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36'),
            'Accept-Language': 'en-US,en;q=0.9',
        }
    
        try:
            response = requests.get(url, headers=headers)
            response.raise_for_status()
            
            content_type = check_url_content_type(url)
    
            if content_type == 'html':
                soup = BeautifulSoup(response.text, 'html.parser')
                text = soup.get_text()
                formatted_text = '\n'.join([line.strip() for line in text.splitlines() if line.strip()])
                return 'html', formatted_text
    
            elif content_type == 'pdf':
                pdf_file = BytesIO(response.content)
                pdf_reader = PyPDF2.PdfReader(pdf_file)
    
                pdf_text = ''
                for page in pdf_reader.pages:
                    if len(pdf_text) > 100000:
                        break
                    pdf_text += page.extract_text()
                return 'pdf', pdf_text
    
            else:
                return 'other', 'Tipo de contenido no soportado o desconocido.'
    
        except requests.exceptions.RequestException as e:
            return 'error', f'Error al realizar la solicitud: {e}'
    
        except Exception as e:
            return 'error', f'Ocurrió un error: {e}'
    

    Con esto, ahora puedes usar la función fetch_text_from_url y pasarle cualquier URL para extraer el texto sea de un archivo HTML o PDF. La función devuelve el tipo de contenido y el texto extraído. Puedes importar esta función desde otro archivo de Python y utilizarla de la siguiente manera:

    from tu_modulo import fetch_text_from_url
    
    url = 'https://example.com/yourfile.pdf'  # Reemplaza con la URL deseada
    tipo, texto = fetch_text_from_url(url)
    print(tipo)
    print(texto)
    
  3. User

    y ahora que he creado lo anterior, como sustituirias este codigo para que lo llame, estan en la misma carpeta: ""import random import time import unicodedata import requests from bs4 import BeautifulSoup from duckduckgo_search import DDGS from dateutil import parser as date_parser import re

    from extractText import obtener_fecha_publicacion

    def generar_texto(mensajes, model='openai', seed=random.randint(1, 1000000), system_message=None): base_url = "https://text.pollinations.ai/"

    # Construir el cuerpo de la solicitud
    payload = {
        "messages": mensajes,
        "model": model,
        "seed": seed,
        # Eliminar 'jsonMode' para manejar respuestas como texto plano
        # "jsonMode": False  # Comentar o eliminar si no es necesario
    }
    headers = {'Content-Type': 'application/json'}
    
    try:
        response = requests.post(base_url, headers=headers, json=payload)
        response.raise_for_status()
        
        # Procesar la respuesta como texto plano
        generated_text = response.text.strip()
        
        return generated_text
    except requests.exceptions.HTTPError as http_err:
        print(f"Error HTTP: {http_err}")
        print(f"Contenido de la respuesta: {response.text}")
    except requests.exceptions.RequestException as req_err:
        print(f"Error en la solicitud: {req_err}")
    except Exception as e:
        print(f"Ocurrió un error: {e}")
    
    return None
    

    def obtener_multilinea_input(): print("Escribe tu texto (escribe 'FIN' en una línea sola para finalizar):") lines = [] while True: try: line = input() if line.strip().upper() == "FIN": # Termina cuando detecta 'FIN' break lines.append(line) except EOFError: break return "\n".join(lines) # Une las líneas con saltos de línea

    def es_texto_legible(texto, umbral=0.95): if not texto: return False caracteres_legibles = sum(c.isprintable() for c in texto) ratio = caracteres_legibles / len(texto) return ratio >= umbral

    def obtener_texto_pagina(url): try: headers = {'User-Agent': 'Mozilla/5.0'} response = requests.get(url, headers=headers) response.raise_for_status() response.encoding = response.apparent_encoding # Asegura una codificación adecuada

        soup = BeautifulSoup(response.text, 'html.parser')
        fecha_publicacion = obtener_fecha_publicacion(soup)
    
        for script_or_style in soup(['script', 'style', 'noscript', 'iframe']):
            script_or_style.decompose()
    
        texto = soup.get_text(separator=' ', strip=True)
    
        if not es_texto_legible(texto):
            print(f'Contenido no legible en {url}, se omitirá.')
            return '', None
    
    
        # Obtiene solo los 100000 primeros caracteres
        if len(texto) > 100000:
            texto = texto[:100000]
    
    
        return texto, fecha_publicacion
    except Exception as e:
        print(f'Error al obtener {url}: {e}')
        return '', None
    

    def extraer_terminos_busqueda(texto_respuesta): """ Extrae las frases o términos de búsqueda del texto de respuesta del LLM que aparecen después de "Internet:SI" o "Internet: SI", sin importar la cantidad de saltos de línea.

    Args:
        texto_respuesta (str): Texto completo de la respuesta del LLM.
    
    Returns:
        list: Lista de términos o frases extraídas.
    """
    terminos = []
    
    # Define un patrón para encontrar "Internet:SI" o "Internet: SI" con un punto opcional al final
    patron_seccion = re.compile(
        r'Internet\s*:\s*S[IÍ]\.?(.*)',
        re.IGNORECASE | re.DOTALL
    )
    
    # Busca la sección que coincide con el patrón
    match = patron_seccion.search(texto_respuesta)
    
    if match:
        # Captura todo el texto después de "Internet:SI" o "Internet: SI"
        seccion = match.group(1)
        # Depuración: Imprimir la sección encontrada
        print(f"Sección encontrada después de 'Internet:SI':\n{seccion}\n")
    
        # Busca todas las frases entre comillas en la sección capturada
        # Admite comillas rectas dobles, simples, tipográficas y backticks
        terminos_en_seccion = re.findall(r'["“”‘’\'`](.*?)["“”‘’\'`]', seccion)
    
        # Limpia y agrega los términos encontrados
        terminos = [termino.strip() for termino in terminos_en_seccion if termino.strip()]
    
        # Depuración: Imprimir los términos extraídos
        print(f"Términos extraídos: {terminos}\n")
    else:
        print("No se encontró la sección 'Internet:SI' en la respuesta del LLM.\n")
    
    return terminos
    

    def realizar_busqueda_y_obtener_texto(consultas): contenidos = '' fecha_inicio = date_parser.parse('2000-10-06') # Fecha de inicio fecha_fin = date_parser.parse('2025-05-01') # Fecha de fin

    with DDGS() as buscador:
        for consulta in consultas:
            print(f'Buscando información para: {consulta}')
            resultados = buscador.text(consulta, safesearch='Off',timelimit='y', max_results=5)
            
            for resultado in resultados:
                url = resultado.get('href') or resultado.get('url')
                titulo = resultado.get('title')
                if url and titulo:
                    print(f'Obteniendo contenido de: {url}')
                    texto, fecha_publicacion = obtener_texto_pagina(url)
                    
                    # Verificar si la fecha de publicación está dentro del rango
                    """ if fecha_publicacion:
                        fecha_publicacion = fecha_publicacion.replace(tzinfo=None)
                        if fecha_inicio <= fecha_publicacion <= fecha_fin:
                    """    
                    contenidos += (
                        f'URL: {url}\n'
                        f'Título: {titulo}\n'
                        f'Fecha de publicación: {fecha_publicacion}\n\n'
                        f'{texto}\n{"-"*80}\n\n'                    
                        )
                    """
                        else:
                            print(f'Artículo fuera del rango de fechas: {fecha_publicacion}')
                    else:
                        print('Fecha de publicación no encontrada, se omite el artículo.') """
                else:
                    print('Resultado incompleto, se omite.')
    return contenidos
    

    def quitar_acentos(texto): """ Elimina los acentos de una cadena de texto. """ texto_normalizado = unicodedata.normalize('NFD', texto) texto_sin_acentos = ''.join( caracter for caracter in texto_normalizado if unicodedata.category(caracter) != 'Mn' ) return texto_sin_acentos

    def chat(): print("¡Bienvenido al Chat AI! Escribe 'salir' para terminar la conversación.")

    # Inicializar la lista de mensajes con el mensaje de sistema
    mensajes = []
    system_msg = "Eres un asistente AI experto en análisis de preguntas y respuestas detalladas."
    mensajes.append({"role": "system", "content": system_msg})
    
    ai_response_count = 0  # Contador de respuestas de la AI
    
    while True:
        print("\nTú (ingresa 'salir' para terminar):")
        pregunta = obtener_multilinea_input()
        
        if pregunta.lower().strip() in ['salir', 'exit', 'quit']:
            print("Chat finalizado. ¡Hasta luego!")
            break
        
        if not pregunta.strip():
            print("Por favor, ingresa una pregunta válida.")
            continue
        
        # Añadir el mensaje del usuario al historial
        mensajes.append({"role": "user", "content": pregunta})
        
        if ai_response_count < 1:
            # **Fase 1: Análisis de la Pregunta**
            analisis_prompt = (
               "Analiza el siguiente prompt y describe los pasos para obtener el "
                "mejor resultado para realizarlo. También responde con el siguiente formato literal(no utilices otro formato) "
                "'Internet:SI' o 'Internet:NO' si se podría beneficiar mejor la respuesta de "
                "la web. Si la respuesta es sí, añade al final de la respuesta los términos "
                "o frases en inglés que buscarías en la web para obtener más información con el siguiente "
                "formato 'Término o frase:'. La petición del usuario es: \"" + pregunta + "\". "
    

    ) mensajes.append({"role": "user", "content": analisis_prompt}) # Añade el prompt de análisis al historial

            # Generar el análisis basado en el historial
            analisis = generar_texto(mensajes, system_message=system_msg)
            
            
    
            if analisis:
                # Normalizar la cadena
                analisis_normalizado = quitar_acentos(analisis).upper()
                print(f"\n[Análisis]: {analisis}\n")
                # Añadir el análisis del asistente al historial
                mensajes.append({"role": "assistant", "content": analisis})
                
                # **Fase 1.1: Comprobar si necesitamos Internet**
                # buscamos el formato 'Internet:SI' o 'Internet:NO' en el texto de respuesta
                texto_adicional = None
                if 'INTERNET:SI' in analisis_normalizado or 'INTERNET: SI' in analisis_normalizado:
                    print("AI: Necesitamos Internet")
                    print('Extrayendo términos de búsqueda del análisis.')
                    
                    # Extraer los términos de búsqueda del análisis
                    terminos_busqueda = extraer_terminos_busqueda(analisis)
                    
                    if terminos_busqueda:
                        print(f'Términos extraídos: {terminos_busqueda}')
                        print('Buscando información adicional usando los términos extraídos.')
                        # Realizar búsquedas utilizando los términos extraídos
                        texto_adicional = realizar_busqueda_y_obtener_texto(terminos_busqueda)
                    else:
                        print("No se pudieron extraer términos de búsqueda. Continuando sin búsquedas adicionales.")
                else:
                    print("AI: No necesitamos Internet")
    
                # **Fase 2: Responder Basado en el Análisis**
                ejecucion_prompt = (
                    f"Siguiendo estos pasos:\n{analisis}\n"
                    "Responde detalladamente a la petición del usuario original: \"" + pregunta + "\". "
                )
                if texto_adicional:
                    ejecucion_prompt += " Contexto adicional: "+ texto_adicional + ". "
    
                if texto_adicional:
                    print(f"\n[Datos Internet (añadir referencia si se ha usado)]: {texto_adicional}\n")
                
                # Añadir el prompt de ejecución al historial
                mensajes.append({"role": "user", "content": ejecucion_prompt})  # Añade el prompt de ejecución al historial
                
                # Generar la respuesta basada en el análisis
                respuesta = generar_texto(mensajes, system_message=system_msg)
                
                if respuesta:
                    # Mostrar la respuesta del asistente
                    print(f"AI Respuesta: {respuesta}")
                    # Añadir la respuesta del asistente al historial
                    mensajes.append({"role": "assistant", "content": respuesta})
                    ai_response_count += 1  # Incrementar el contador después de una interacción completa
                else:
                    print("AI: No se pudo generar la respuesta basada en el análisis.")
            else:
                print("AI: No se pudo realizar el análisis de la pregunta.")
        else:
            # **Modo Directo: Sin Análisis ni Búsquedas**
            print("Modo directo activado. Respondiendo sin análisis previo ni búsquedas en internet.")
            
            # Generar la respuesta directamente
            respuesta = generar_texto(mensajes, system_message=system_msg)
            
            if respuesta:
                # Mostrar la respuesta del asistente
                print(f"AI Respuesta: {respuesta}")
                # Añadir la respuesta del asistente al historial
                mensajes.append({"role": "assistant", "content": respuesta})
            else:
                print("AI: No se pudo generar la respuesta directa.")
    

    if name == "main": chat()""

  4. Assistant

    Para modificar el código que proporcionaste y reemplazar la lógica que obtendría el texto de una página web mediante la función de biblioteca que escribiste anteriormente, necesitarás importar y llamar a la función fetch_text_from_url que habías creado. Aquí te muestro cómo hacer estas modificaciones:

    Primero, asegúrate de que tu función fetch_text_from_url esté en un archivo llamado mi_modulo.py en la misma carpeta que el script principal.

    Luego, puedes ajustar el código para importar y utilizar esta función. Sustituiré la parte del código que se encarga de obtener texto de una página web. Aquí está el código modificado:

    import random
    import time
    import unicodedata
    import requests
    from bs4 import BeautifulSoup
    from duckduckgo_search import DDGS
    from dateutil import parser as date_parser
    import re
    
    # Importa la función que creaste
    from mi_modulo import fetch_text_from_url
    
    def generar_texto(mensajes, model='openai', seed=random.randint(1, 1000000), system_message=None):
        base_url = "https://text.pollinations.ai/"
        
        payload = {
            "messages": mensajes,
            "model": model,
            "seed": seed,
        }
        headers = {'Content-Type': 'application/json'}
        
        try:
            response = requests.post(base_url, headers=headers, json=payload)
            response.raise_for_status()
            
            generated_text = response.text.strip()
            return generated_text
        except requests.exceptions.HTTPError as http_err:
            print(f"Error HTTP: {http_err}")
            print(f"Contenido de la respuesta: {response.text}")
        except requests.exceptions.RequestException as req_err:
            print(f"Error en la solicitud: {req_err}")
        except Exception as e:
            print(f"Ocurrió un error: {e}")
        
        return None
    
    def obtener_multilinea_input():
        print("Escribe tu texto (escribe 'FIN' en una línea sola para finalizar):")
        lines = []
        while True:
            try:
                line = input()
                if line.strip().upper() == "FIN":
                    break
                lines.append(line)
            except EOFError:
                break
        return "\n".join(lines)
    
    def es_texto_legible(texto, umbral=0.95):
        if not texto:
            return False
        caracteres_legibles = sum(c.isprintable() for c in texto)
        ratio = caracteres_legibles / len(texto)
        return ratio >= umbral
    
    def extraer_terminos_busqueda(texto_respuesta):
        terminos = []
        patron_seccion = re.compile(r'Internet\s*:\s*S[IÍ]\.?(.*)', re.IGNORECASE | re.DOTALL)
        match = patron_seccion.search(texto_respuesta)
    
        if match:
            seccion = match.group(1)
            print(f"Sección encontrada después de 'Internet:SI':\n{seccion}\n")
            terminos_en_seccion = re.findall(r'["“”‘’\'`](.*?)["“”‘’\'`]', seccion)
            terminos = [termino.strip() for termino in terminos_en_seccion if termino.strip()]
            print(f"Términos extraídos: {terminos}\n")
        else:
            print("No se encontró la sección 'Internet:SI' en la respuesta del LLM.\n")
    
        return terminos
    
    def realizar_busqueda_y_obtener_texto(consultas):
        contenidos = ''
        fecha_inicio = date_parser.parse('2000-10-06')
        fecha_fin = date_parser.parse('2025-05-01')
    
        with DDGS() as buscador:
            for consulta in consultas:
                print(f'Buscando información para: {consulta}')
                resultados = buscador.text(consulta, safesearch='Off', timelimit='y', max_results=5)
                
                for resultado in resultados:
                    url = resultado.get('href') or resultado.get('url')
                    titulo = resultado.get('title')
                    if url and titulo:
                        print(f'Obteniendo contenido de: {url}')
                        
                        tipo_contenido, texto = fetch_text_from_url(url)  # Llamar a la función directamente
                        fecha_publicacion = None  # Como tu lógica de obtención de fecha necesita ajustes
    
                        if not es_texto_legible(texto):
                            print(f'Contenido no legible en {url}, se omitirá.')
                            continue
    
                        if len(texto) > 100000:
                            texto = texto[:100000]
    
                        contenidos += (
                            f'URL: {url}\n'
                            f'Título: {titulo}\n'
                            f'Fecha de publicación: {fecha_publicacion}\n\n'
                            f'{texto}\n{"-"*80}\n\n'
                        )
                    else:
                        print('Resultado incompleto, se omite.')
        return contenidos
    
    def quitar_acentos(texto):
        texto_normalizado = unicodedata.normalize('NFD', texto)
        texto_sin_acentos = ''.join(
            caracter for caracter in texto_normalizado
            if unicodedata.category(caracter) != 'Mn'
        )
        return texto_sin_acentos
    
    def chat():
        print("¡Bienvenido al Chat AI! Escribe 'salir' para terminar la conversación.")
        
        mensajes = []
        system_msg = "Eres un asistente AI experto en análisis de preguntas y respuestas detalladas."
        mensajes.append({"role": "system", "content": system_msg})
        
        ai_response_count = 0
        
        while True:
            print("\nTú (ingresa 'salir' para terminar):")
            pregunta = obtener_multilinea_input()
            
            if pregunta.lower().strip() in ['salir', 'exit', 'quit']:
                print("Chat finalizado. ¡Hasta luego!")
                break
            
            if not pregunta.strip():
                print("Por favor, ingresa una pregunta válida.")
                continue
            
            mensajes.append({"role": "user", "content": pregunta})
            
            if ai_response_count < 1:
                analisis_prompt = (
                    "Analiza el siguiente prompt y describe los pasos para obtener el "
                    "mejor resultado para realizarlo. También responde con el siguiente formato literal(no utilices otro formato) "
                    "'Internet:SI' o 'Internet:NO' si se podría beneficiar mejor la respuesta de "
                    "la web. Si la respuesta es sí, añade al final de la respuesta los términos "
                    "o frases en inglés que buscarías en la web para obtener más información con el siguiente "
                    "formato 'Término o frase:'. La petición del usuario es: \"" + pregunta + "\"."
                )
                mensajes.append({"role": "user", "content": analisis_prompt})
                analisis = generar_texto(mensajes, system_message=system_msg)
                
                if analisis:
                    analisis_normalizado = quitar_acentos(analisis).upper()
                    print(f"\n[Análisis]: {analisis}\n")
                    mensajes.append({"role": "assistant", "content": analisis})
                    
                    texto_adicional = None
                    if 'INTERNET:SI' in analisis_normalizado or 'INTERNET: SI' in analisis_normalizado:
                        print("AI: Necesitamos Internet")
                        terminos_busqueda = extraer_terminos_busqueda(analisis)
                        
                        if terminos_busqueda:
                            print(f'Términos extraídos: {terminos_busqueda}')
                            print('Buscando información adicional usando los términos extraídos.')
                            texto_adicional = realizar_busqueda_y_obtener_texto(terminos_busqueda)
                        else:
                            print("No se pudieron extraer términos de búsqueda. Continuando sin búsquedas adicionales.")
                    else:
                        print("AI: No necesitamos Internet")
                    
                    ejecucion_prompt = (
                        f"Siguiendo estos pasos:\n{analisis}\n"
                        "Responde detalladamente a la petición del usuario original: \"" + pregunta + "\"."
                    )
                    if texto_adicional:
                        ejecucion_prompt += " Contexto adicional: "+ texto_adicional + ". "
                    
                    if texto_adicional:
                        print(f"\n[Datos Internet (añadir referencia si se ha usado)]: {texto_adicional}\n")
                    
                    mensajes.append({"role": "user", "content": ejecucion_prompt})
                    respuesta = generar_texto(mensajes, system_message=system_msg)
                    
                    if respuesta:
                        print(f"AI Respuesta: {respuesta}")
                        mensajes.append({"role": "assistant", "content": respuesta})
                        ai_response_count += 1
                    else:
                        print("AI: No se pudo generar la respuesta basada en el análisis.")
                else:
                    print("AI: No se pudo realizar el análisis de la pregunta.")
            else:
                print("Modo directo activado. Respondiendo sin análisis previo ni búsquedas en internet.")
                respuesta = generar_texto(mensajes, system_message=system_msg)
                
                if respuesta:
                    print(f"AI Respuesta: {respuesta}")
                    mensajes.append({"role": "assistant", "content": respuesta})
                else:
                    print("AI: No se pudo generar la respuesta directa.")
    
    if __name__ == "__main__":
        chat()
    

    Este ejemplo reemplaza la obtención de texto de una página web usando BeautifulSoup con una llamada a fetch_text_from_url, lo cual simplifica mucho la obtención del contenido, ya que ahora puede manejar automáticamente tanto HTML como PDF. Asegúrate de tener el archivo mi_modulo.py con la función de extracción que creaste previamente en la misma carpeta para que la importación funcione correctamente.

  5. User

    lo que quiero ahora es que si muestra ahora: "No se pudieron extraer términos de búsqueda. Continuando sin búsquedas adicionales." quiero modificarlo que solo muestre que no se pudieron extraer terminos y que pida al usuario que los introduzca los terminos separados por coma, y estos son procesados tal cual vienen y que el metodo los separe por comas

  6. Assistant

    Para implementar este cambio, puedes reemplazar la parte del código que maneja la falta de términos de búsqueda con un bloque que solicite al usuario que introduzca los términos manualmente. Luego puedes procesar la entrada del usuario para separar los términos con base en las comas. Aquí está cómo podrías hacerlo:

    import random
    import time
    import unicodedata
    import requests
    from bs4 import BeautifulSoup
    from duckduckgo_search import DDGS
    from dateutil import parser as date_parser
    import re
    from mi_modulo import fetch_text_from_url
    
    def generar_texto(mensajes, model='openai', seed=random.randint(1, 1000000), system_message=None):
        base_url = "https://text.pollinations.ai/"
        
        payload = {
            "messages": mensajes,
            "model": model,
            "seed": seed,
        }
        headers = {'Content-Type': 'application/json'}
        
        try:
            response = requests.post(base_url, headers=headers, json=payload)
            response.raise_for_status()
            
            generated_text = response.text.strip()
            return generated_text
        except requests.exceptions.HTTPError as http_err:
            print(f"Error HTTP: {http_err}")
            print(f"Contenido de la respuesta: {response.text}")
        except requests.exceptions.RequestException as req_err:
            print(f"Error en la solicitud: {req_err}")
        except Exception as e:
            print(f"Ocurrió un error: {e}")
        
        return None
    
    def obtener_multilinea_input():
        print("Escribe tu texto (escribe 'FIN' en una línea sola para finalizar):")
        lines = []
        while True:
            try:
                line = input()
                if line.strip().upper() == "FIN":
                    break
                lines.append(line)
            except EOFError:
                break
        return "\n".join(lines)
    
    def es_texto_legible(texto, umbral=0.95):
        if not texto:
            return False
        caracteres_legibles = sum(c.isprintable() for c in texto)
        ratio = caracteres_legibles / len(texto)
        return ratio >= umbral
    
    def extraer_terminos_busqueda(texto_respuesta):
        terminos = []
        patron_seccion = re.compile(r'Internet\s*:\s*S[IÍ]\.?(.*)', re.IGNORECASE | re.DOTALL)
        match = patron_seccion.search(texto_respuesta)
    
        if match:
            seccion = match.group(1)
            print(f"Sección encontrada después de 'Internet:SI':\n{seccion}\n")
            terminos_en_seccion = re.findall(r'["“”‘’\'`](.*?)["“”‘’\'`]', seccion)
            terminos = [termino.strip() for termino in terminos_en_seccion if termino.strip()]
            print(f"Términos extraídos: {terminos}\n")
        else:
            print("No se encontró la sección 'Internet:SI' en la respuesta del LLM.\n")
    
        return terminos
    
    def solicitar_terminos_usuario():
        """Solicitar términos de búsqueda al usuario como una cadena separada por comas."""
        print("Por favor, introduce los términos de búsqueda separados por comas:")
        entrada_usuario = input("Términos: ")
        terminos = [termino.strip() for termino in entrada_usuario.split(',') if termino.strip()]
        return terminos
    
    def realizar_busqueda_y_obtener_texto(consultas):
        contenidos = ''
        fecha_inicio = date_parser.parse('2000-10-06')
        fecha_fin = date_parser.parse('2025-05-01')
    
        with DDGS() as buscador:
            for consulta in consultas:
                print(f'Buscando información para: {consulta}')
                resultados = buscador.text(consulta, safesearch='Off', timelimit='y', max_results=5)
                
                for resultado in resultados:
                    url = resultado.get('href') or resultado.get('url')
                    titulo = resultado.get('title')
                    if url and titulo:
                        print(f'Obteniendo contenido de: {url}')
                        
                        tipo_contenido, texto = fetch_text_from_url(url)
                        fecha_publicacion = None
    
                        if not es_texto_legible(texto):
                            print(f'Contenido no legible en {url}, se omitirá.')
                            continue
    
                        if len(texto) > 100000:
                            texto = texto[:100000]
    
                        contenidos += (
                            f'URL: {url}\n'
                            f'Título: {titulo}\n'
                            f'Fecha de publicación: {fecha_publicacion}\n\n'
                            f'{texto}\n{"-"*80}\n\n'
                        )
                    else:
                        print('Resultado incompleto, se omite.')
        return contenidos
    
    def quitar_acentos(texto):
        texto_normalizado = unicodedata.normalize('NFD', texto)
        texto_sin_acentos = ''.join(
            caracter for caracter in texto_normalizado
            if unicodedata.category(caracter) != 'Mn'
        )
        return texto_sin_acentos
    
    def chat():
        print("¡Bienvenido al Chat AI! Escribe 'salir' para terminar la conversación.")
        
        mensajes = []
        system_msg = "Eres un asistente AI experto en análisis de preguntas y respuestas detalladas."
        mensajes.append({"role": "system", "content": system_msg})
        
        ai_response_count = 0
        
        while True:
            print("\nTú (ingresa 'salir' para terminar):")
            pregunta = obtener_multilinea_input()
            
            if pregunta.lower().strip() in ['salir', 'exit', 'quit']:
                print("Chat finalizado. ¡Hasta luego!")
                break
            
            if not pregunta.strip():
                print("Por favor, ingresa una pregunta válida.")
                continue
            
            mensajes.append({"role": "user", "content": pregunta})
            
            if ai_response_count < 1:
                analisis_prompt = (
                    "Analiza el siguiente prompt y describe los pasos para obtener el "
                    "mejor resultado para realizarlo. También responde con el siguiente formato literal(no utilices otro formato) "
                    "'Internet:SI' o 'Internet:NO' si se podría beneficiar mejor la respuesta de "
                    "la web. Si la respuesta es sí, añade al final de la respuesta los términos "
                    "o frases en inglés que buscarías en la web para obtener más información con el siguiente "
                    "formato 'Término o frase:'. La petición del usuario es: \"" + pregunta + "\"."
                )
                mensajes.append({"role": "user", "content": analisis_prompt})
                analisis = generar_texto(mensajes, system_message=system_msg)
                
                if analisis:
                    analisis_normalizado = quitar_acentos(analisis).upper()
                    print(f"\n[Análisis]: {analisis}\n")
                    mensajes.append({"role": "assistant", "content": analisis})
                    
                    texto_adicional = None
                    if 'INTERNET:SI' in analisis_normalizado or 'INTERNET: SI' in analisis_normalizado:
                        print("AI: Necesitamos Internet")
                        terminos_busqueda = extraer_terminos_busqueda(analisis)
                        
                        if not terminos_busqueda:
                            print("No se pudieron extraer términos de búsqueda.")
                            terminos_busqueda = solicitar_terminos_usuario()
    
                        if terminos_busqueda:
                            print(f'Términos a buscar: {terminos_busqueda}')
                            texto_adicional = realizar_busqueda_y_obtener_texto(terminos_busqueda)
                        else:
                            print("No se proporcionaron términos de búsqueda. Continuando sin búsquedas adicionales.")
                    else:
                        print("AI: No necesitamos Internet")
                    
                    ejecucion_prompt = (
                        f"Siguiendo estos pasos:\n{analisis}\n"
                        "Responde detalladamente a la petición del usuario original: \"" + pregunta + "\"."
                    )
                    if texto_adicional:
                        ejecucion_prompt += " Contexto adicional: "+ texto_adicional + ". "
                    
                    if texto_adicional:
                        print(f"\n[Datos Internet (añadir referencia si se ha usado)]: {texto_adicional}\n")
                    
                    mensajes.append({"role": "user", "content": ejecucion_prompt})
                    respuesta = generar_texto(mensajes, system_message=system_msg)
                    
                    if respuesta:
                        print(f"AI Respuesta: {respuesta}")
                        mensajes.append({"role": "assistant", "content": respuesta})
                        ai_response_count += 1
                    else:
                        print("AI: No se pudo generar la respuesta basada en el análisis.")
                else:
                    print("AI: No se pudo realizar el análisis de la pregunta.")
            else:
                print("Modo directo activado. Respondiendo sin análisis previo ni búsquedas en internet.")
                respuesta = generar_texto(mensajes, system_message=system_msg)
                
                if respuesta:
                    print(f"AI Respuesta: {respuesta}")
                    mensajes.append({"role": "assistant", "content": respuesta})
                else:
                    print("AI: No se pudo generar la respuesta directa.")
    
    if __name__ == "__main__":
        chat()
    

    Con esta modificación, si no se pueden extraer términos de búsqueda, el programa pedirá al usuario que ingrese manualmente los términos, los cuales deben ser separados por comas. Estos términos luego serán procesados para realizar las búsquedas adicionales.