app.py

from smolagents import CodeAgent, DuckDuckGoSearchTool, HfApiModel, load_tool, tool
import datetime
import requests
import pytz
import yaml
import os
import nltk
from bs4 import BeautifulSoup
from nltk.tokenize import sent_tokenize
from tools.final_answer import FinalAnswerTool
from Gradio_UI import GradioUI

# Descargar tokenizer de NLTK si no está disponible
nltk.download("punkt")

# Configurar el modelo de resumen desde Hugging Face en SmolAgents
model = HfApiModel(
    max_tokens=2096,
    temperature=0.5,
    model_id="facebook/bart-large-cnn",  # Modelo de resumen
    custom_role_conversions=None,
)

@tool

def summarize_text(text):
    """Usa una API de Hugging Face para resumir texto."""
    API_URL = "https://api-inference.huggingface.co/models/facebook/bart-large-cnn"
    headers = {"Authorization": f"Bearer TU_HUGGINGFACE_API_KEY"}

    payload = {
        "inputs": text,
        "parameters": {"max_length": 150, "min_length": 50, "do_sample": False},
    }

    response = requests.post(API_URL, headers=headers, json=payload)
    
    if response.status_code == 200:
        return response.json()[0]["summary_text"]
    else:
        return "Error en el resumen"

@tool
def scrape_webpage(url: str, tag: str = "p", class_name: str = None) -> dict:
    """Extrae contenido de una página web según una etiqueta HTML y clase opcional.

    Args:
        url: URL de la página a scrapear.
        tag: Etiqueta HTML a extraer (por defecto <p>).
        class_name: Clase CSS opcional para filtrar resultados.

    Returns:
        Un diccionario con el contenido extraído.
    """
    try:
        headers = {"User-Agent": "Mozilla/5.0"}
        response = requests.get(url, headers=headers)
        response.raise_for_status()

        soup = BeautifulSoup(response.text, "html.parser")

        if class_name:
            elements = soup.find_all(tag, class_=class_name)
        else:
            elements = soup.find_all(tag)

        extracted_data = [element.get_text(strip=True) for element in elements]

        return {"url": url, "scraped_data": extracted_data[:20]}  # Limita a 20 resultados

    except requests.exceptions.RequestException as e:
        return {"error": f"Error al acceder a la URL: {str(e)}"}
    except Exception as e:
        return {"error": f"Error inesperado: {str(e)}"}


@tool
def extract_metadata_from_url(url: str) -> dict:
    """Extrae todos los metadatos de una página web.

    Args:
        url: La URL de la página web a analizar.

    Returns:
        Un diccionario con los metadatos encontrados.
    """
    try:
        headers = {"User-Agent": "Mozilla/5.0"}
        response = requests.get(url, headers=headers)
        response.raise_for_status()

        soup = BeautifulSoup(response.text, "html.parser")

        metadata = {}
        for meta in soup.find_all("meta"):
            if "name" in meta.attrs and "content" in meta.attrs:
                metadata[meta["name"]] = meta["content"]
            elif "property" in meta.attrs and "content" in meta.attrs:
                metadata[meta["property"]] = meta["content"]

        return metadata if metadata else {"error": "No se encontraron metadatos en la página."}

    except requests.exceptions.RequestException as e:
        return {"error": f"Error al acceder a la URL: {str(e)}"}

@tool
def save_scraped_data_as_markdown(scraped_data: dict, filename: str = None) -> str:
    """
    Guarda el contenido scrapeado en un archivo Markdown bien formateado.

    Args:
        scraped_data (dict): Diccionario que contiene:
            - 'url' (str): La URL de la página de la cual se extrajo el contenido.
            - 'scraped_data' (list[str]): Lista de fragmentos de texto extraídos.
        filename (str, optional): Nombre del archivo Markdown de salida. Si no se proporciona, se genera uno usando la fecha y hora actual.

    Returns:
        str: Mensaje indicando si el archivo se guardó correctamente o si ocurrió algún error.
    """
    try:
        url = scraped_data.get("url", "Unknown")
        content_list = scraped_data.get("scraped_data", [])

        if not content_list:
            return "No data available to save in Markdown."

        formatted_content = "\n\n".join(content_list)

        # Construir el contenido Markdown
        markdown_content = f"# Content extracted from {url}\n\n"
        markdown_content += "## Full Content\n\n"
        markdown_content += formatted_content

        # Generar un nombre de archivo con timestamp si no se proporciona
        if not filename:
            timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
            filename = f"scraped_{timestamp}.md"

        with open(filename, "w", encoding="utf-8") as file:
            file.write(markdown_content)

        return f"Scraped content has been saved in {filename}"

    except Exception as e:
        return f"Error generating Markdown file: {str(e)}"


@tool
def get_current_time_in_timezone(timezone: str) -> str:
    """Devuelve la hora actual en una zona horaria específica.

    Args:
        timezone: Una cadena que representa una zona horaria válida (ej. 'America/New_York').

    Returns:
        La hora local actual en la zona horaria especificada.
    """
    try:
        tz = pytz.timezone(timezone)
        local_time = datetime.datetime.now(tz).strftime("%Y-%m-%d %H:%M:%S")
        return f"La hora local actual en {timezone} es: {local_time}"
    except Exception as e:
        return f"Error obteniendo la hora para la zona horaria '{timezone}': {str(e)}"


final_answer = FinalAnswerTool()

# Import tool from Hub
image_generation_tool = load_tool("agents-course/text-to-image", trust_remote_code=True)

with open("prompts.yaml", "r") as stream:
    prompt_templates = yaml.safe_load(stream)

agent = CodeAgent(
    model=model,
    tools=[
        final_answer,
        extract_metadata_from_url,
        scrape_webpage,
        save_scraped_data_as_markdown,  # Se añade la nueva herramienta al agente
    ],
    max_steps=6,
    verbosity_level=1,
    grammar=None,
    planning_interval=None,
    name=None,
    description=None,
    prompt_templates=prompt_templates,
)

GradioUI(agent).launch()