summarizer_with_progress.py

from openai import OpenAI
import requests
from dotenv import load_dotenv
import time
import os
import json

load_dotenv()
client = OpenAI()

# Definir parámetros
MODEL = "gpt-4"  # Usa "gpt-4" o "gpt-4-turbo" para optimización de tokens
MAX_TOKENS_PER_CHUNK = 3000  # Límite de tokens por sección
SUMMARY_TOKEN_LIMIT = 100  # Tokens para el resumen de cada sección
PROGRESS_FILE = 'progress.json'  # Archivo para guardar el progreso

def summarize_section(text):
    """Genera un resumen breve de una sección de texto."""
    try:
        response = client.chat.completions.create(
            model=MODEL,
            messages=[
                {"role": "system", "content": "Resume este texto en 400 caracteres o menos."},
                {"role": "user", "content": text}
            ],
            max_tokens=SUMMARY_TOKEN_LIMIT,
            temperature=0.5
        )
        summary = response.choices[0].message.content
        return summary.strip()
    except Exception as e:
        print(f"Error al resumir la sección: {e}")
        return None

def split_text(text, max_tokens):
    """Divide el texto en secciones según el límite de tokens."""
    tokens = text.split()  # Asume que cada palabra cuenta como un token aprox.
    chunks = []
    
    for i in range(0, len(tokens), max_tokens):
        chunk = " ".join(tokens[i:i + max_tokens])
        chunks.append(chunk)

    return chunks

def load_progress():
    """Carga el progreso guardado desde un archivo JSON."""
    if os.path.exists(PROGRESS_FILE):
        with open(PROGRESS_FILE, 'r') as f:
            return json.load(f)
    return None

def save_progress(section_index):
    """Guarda el progreso actual en un archivo JSON."""
    with open(PROGRESS_FILE, 'w') as f:
        json.dump({"last_section": section_index}, f)

def summarize_document(text):
    """Genera un resumen iterativo de un documento largo."""
    # Dividir el texto en secciones manejables
    sections = split_text(text, MAX_TOKENS_PER_CHUNK)
    
    # Cargar progreso si existe
    progress = load_progress()
    start_index = progress['last_section'] if progress else 0

    # Resumir cada sección
    section_summaries = []
    
    for i in range(start_index, len(sections)):
        print(f"Resumiendo sección {i + 1}/{len(sections)}...")
        summary = summarize_section(sections[i])
        
        if summary:
            section_summaries.append(summary)
            save_progress(i + 1)  # Guardar progreso después de resumir una sección
        else:
            print("Error al procesar la sección, reiniciando desde la última sección guardada.")
            break

    # Combinar resúmenes de secciones y resumir el resultado
    combined_summary_text = " ".join(section_summaries)
    
    if combined_summary_text:
        print("Generando el resumen final...")
        final_summary = summarize_section(combined_summary_text)
        return final_summary
    
    return None

def download_text_from_gutenberg(url):
    """Descarga el texto completo desde una URL de Proyecto Gutenberg."""
    print(f"Descargando texto from {url}...")
    response = requests.get(url)
    response.raise_for_status()
    
    # Limpiar el texto para eliminar cabecera y pie de página de Proyecto Gutenberg
    text = response.text

    return text

# Descargar "Moby Dick" de Proyecto Gutenberg
url = "https://www.gutenberg.org/files/2701/2701-0.txt"
texto_largo = download_text_from_gutenberg(url)

# Medir tiempo de ejecución
start_time = time.time()

# Ejecutar el resumen del documento
resumen_final = summarize_document(texto_largo)

# Mostrar resumen final y tiempo transcurrido
if resumen_final:
    print("Resumen final:")
    print(resumen_final)

end_time = time.time()
print(f"Tiempo total de ejecución: {end_time - start_time:.2f} segundos")