app.py

from dotenv import load_dotenv
import streamlit as st
import os
import google.generativeai as genai
import random

# Cargar las variables de entorno
load_dotenv()

# Configurar la API de Google
genai.configure(api_key=os.getenv("GOOGLE_API_KEY"))

# Función para obtener una mención del producto de manera probabilística
def get_random_product_mention():
    mentions = ["Directa", "Indirecta", "Metafórica"]
    probabilities = [0.35, 0.25, 0.40]
    return random.choices(mentions, probabilities)[0]

# Función para crear el texto introductorio aleatorio
def generate_intro_text():
    intros = [
        "Y si a ti te gustaría aprender todo esto…",
        "Así que si lo que quieres es llevarte todo, entonces...",
        "Es momento de tomar el control de tu futuro.",
        "No dejes pasar esta oportunidad única para mejorar tu vida.",
        "Ahora tienes la oportunidad de hacer algo increíble.",
        "El primer paso hacia tus sueños está frente a ti.",
        "No lo pienses más, el cambio comienza aquí y ahora."
    ]
    return random.choice(intros)

# Crear la instrucción de mención basada en la opción seleccionada
def get_mention_instruction(product_mention, product):
    if product_mention == "Directa":
        return f"Introduce directamente el producto '{product}' como la solución clara al problema que enfrenta el lector."
    elif product_mention == "Indirecta":
        return f"Referencia sutilmente el producto '{product}' como una posible solución al problema del lector sin nombrarlo explícitamente."
    elif product_mention == "Metafórica":
        return f"Introduce el producto '{product}' usando una metáfora, conectándolo simbólicamente a la solución que necesita el lector."
    return ""

# Función para generar postdata (refuerzo del CTA)
def generate_postdata(target_audience, product, call_to_action, temperature, theme_or_focus):
    # Instrucción para la generación de postdata
    postdata_instruction = (
        f"Eres un experto copywriter especializado en escribir mensajes persuasivos. "
        f"Tu tarea es generar {number_of_ctas} postdatas en forma de listado, que refuercen el llamado a la acción '{call_to_action}' para el público objetivo '{target_audience}', "
        f"relacionado con el producto '{product}'. Las postdatas deben de comenzar siempre con 'P.D.' y debe reforzar la urgencia o deseo de tomar acción. No des explicaciones de nada acerca de las postdatas, ni como las creaste."
        f"La postdata debe ser breve, clara y persuasiva, y no debe ser una repetición del CTA. "
        f"El tema o enfoque para la postdata es '{theme_or_focus}'."
        "Ejemplos de postdata incluyen:\n"
        "P.D. No te pierdas la oportunidad de transformar tu futuro, te esperamos en el evento\n"
        "P.D. Recuerda que las plazas son limitadas, inscríbete ahora antes de que se agoten"
    )

    # Configuración del modelo para generar la postdata
    generation_config = {
        "temperature": temperature,
        "top_p": 0.85,
        "top_k": 128,
        "max_output_tokens": 8196,
        "response_mime_type": "text/plain",
    }

    model = genai.GenerativeModel(
        model_name="gemini-1.5-flash",
        generation_config=generation_config,
        system_instruction=postdata_instruction
    )

    # Generar la postdata
    try:
        response = model.generate_content([postdata_instruction])
        generated_postdata = response.candidates[0].content.parts[0].text.strip()
        return generated_postdata
    except Exception as e:
        raise ValueError(f"Error al generar la postdata: {str(e)}")

# Ejemplos de llamados a la acción por tipo
cta_types = {
    "directos": [
        "asiste a nuestro webinar para convertirte en un padre amoroso.",
        "regístrate en nuestro curso para mejorar tu habilidad en ventas.",
        "comienza ahora para acceder a contenido exclusivo que transformará tu negocio."
    ],
    "urgencia": [
        "inscríbete ahora antes de que se agoten las plazas para el evento.",
        "actúa rápido y comienza tu proceso de transformación hoy mismo."
    ],
    "descuento": [
        "aprovecha este descuento especial y empieza a aprender con nosotros.",
        "obtén un descuento exclusivo al registrarte hoy."
    ],
    "exclusividad": [
        "conviértete en parte de nuestro grupo exclusivo de miembros.",
        "disfruta de acceso único a herramientas premium con tu suscripción."
    ],
    "beneficio_claro": [
        "mejora tu productividad en solo una semana.",
        "transforma tu vida y tus resultados con nuestra metodología probada."
    ],
    "personalización": [
        "descubre cómo puedes personalizar tu experiencia con nuestro curso.",
        "elige las opciones que mejor se adapten a tus necesidades y comienza hoy."
    ]
}

# Función para que el modelo elija automáticamente el tipo de CTA y el CTA específico
def get_random_cta():
    cta_type = random.choice(list(cta_types.keys()))  # Selección aleatoria del tipo de CTA
    cta = random.choice(cta_types[cta_type])  # Selección aleatoria del CTA dentro del tipo
    return cta

# Función para generar llamados a la acción
def generate_ctas(number_of_ctas, target_audience, product, call_to_action, temperature):
    product_mention = get_random_product_mention()
    mention_instruction = get_mention_instruction(product_mention, product)

    # Configuración del modelo
    generation_config = {
        "temperature": temperature,  
        "top_p": 0.85,       
        "top_k": 128,        
        "max_output_tokens": 2048,
        "response_mime_type": "text/plain",
    }

    model = genai.GenerativeModel(
        model_name="gemini-1.5-flash",  
        generation_config=generation_config,  
        system_instruction=(
            f"Eres un experto copywriter especializado en escribir mensajes persuasivos para promover {product} a {target_audience}. "
            "Tu tarea es ayudarme a escribir llamados a la acción (CTA) para que tomen una acción específica, no des ninguna explicación, solo contesta lo que se te pide. "
            f"como {call_to_action}. Asegúrate de que cada llamado a la acción siga la estructura 'Acción + conector + Valor'."
        )
    )

    selected_types = random.sample(list(cta_types.keys()), min(number_of_ctas, len(cta_types)))
    ctas_instruction = (
        f"Tu tarea es crear {number_of_ctas} llamados a la acción efectivos dirigidos a {target_audience}, "
        f"para promover {call_to_action} usa la siguiente mención: {mention_instruction}."
    )

    try:
        response = model.generate_content([ctas_instruction])
        generated_ctas = response.candidates[0].content.parts[0].text.strip()
        return generated_ctas
    except Exception as e:
        raise ValueError(f"Error al generar los CTA: {str(e)}")

# Configurar la interfaz de usuario con Streamlit
st.set_page_config(page_title="QuickPrompt", layout="wide")

st.markdown("<h1 style='text-align: center;'>Quick Prompt</h1>", unsafe_allow_html=True)
st.markdown("<h4 style='text-align: center;'>Transforma tu mensaje en llamados de acción que inspiren a tu audiencia a tomar decisiones al instante.</h4>", unsafe_allow_html=True)

# Añadir CSS personalizado para el botón
st.markdown("""
    <style>
    div.stButton > button {
        background-color: #FFCC00;
        color: black;
        width: 90%;
        height: 60px;
        font-weight: bold;
        font-size: 22px;
        text-transform: uppercase;
        border: 1px solid #000000;
        border-radius: 8px;
        display: block;
        margin: 0 auto;
    }
    div.stButton > button:hover {
        background-color: #FFD700;
        color: black;
    }
    </style>
""", unsafe_allow_html=True)

# Crear columnas
col1, col2 = st.columns([1, 2])

# Columnas de entrada
with col1:
    target_audience = st.text_input("¿Quién es tu público objetivo?", placeholder="Ejemplo: Estudiantes Universitarios")
    product = st.text_input("¿Qué producto tienes en mente?", placeholder="Ejemplo: Curso de Inglés")
    call_to_action = st.text_input("¿Qué acción deseas que tomen?", placeholder="Ejemplo: Inscribirse al curso")
    theme_or_focus = st.text_input("Tema o enfoque para la postdata", placeholder="Ejemplo: urgencia, beneficio, descuento")
    number_of_ctas = st.selectbox("Número de llamados a la acción", options=[1, 2, 3, 4, 5], index=2)
    temperature = st.slider("Creatividad", min_value=0.0, max_value=2.0, value=0.8, step=0.1)

    # Botón de enviar
    submit = st.button("Generar Llamados a la Acción")

# Mostrar los llamados a la acción generados
if submit:
    if target_audience and product and call_to_action:
        try:
            intro_text = generate_intro_text()  # Generar el texto introductorio
            generated_ctas = generate_ctas(number_of_ctas, target_audience, product, call_to_action, temperature)
            # Generar la postdata
            postdata = generate_postdata(target_audience, product, call_to_action, temperature, theme_or_focus)
            
            col2.markdown(f"""
                <div style="border: 1px solid #000000; padding: 5px; border-radius: 8px; background-color: #ffffff;">
                    <h4>{intro_text}</h4>
                    <p>{generated_ctas}</p>
                    <p><strong>{postdata}</strong></p>  <!-- Mostramos la postdata aquí -->
                </div>
            """, unsafe_allow_html=True)

        except ValueError as e:
            col2.error(f"Error: {str(e)}")
        except Exception as e:
            col2.error(f"Error inesperado: {str(e)}")
    else:
        col2.error("Por favor, proporciona el público objetivo, el producto y la acción.")