Update app.py

app.py

@@ -1,12 +1,14 @@
-import streamlit as st
 from dotenv import load_dotenv
+import streamlit as st
 import os
 import google.generativeai as genai
-from style import styles
-from prompts import create_instruction
-from consciousness_levels import CONSCIOUSNESS_LEVELS
-
-st.set_page_config(page_title="Generador de Cliente Ideal", page_icon="👤", layout="wide")
+import random
+import datetime                    
+from streamlit import session_state as state
+from angles import angles
+from formulas.webinar_formulas import webinar_formulas
+from formulas.webinar_name_formulas import webinar_name_formulas
+from formulas.angles_webinar_names import angles_webinar_names
 
 # Cargar las variables de entorno
 load_dotenv()
@@ -14,319 +16,509 @@ load_dotenv()
 # Configurar la API de Google
 genai.configure(api_key=os.getenv("GOOGLE_API_KEY"))
 
-# Inicializar variables de estado en session_state si no existen
-if 'perfil_cliente' not in st.session_state:
-    st.session_state.perfil_cliente = None
-if 'producto' not in st.session_state:
-    st.session_state.producto = ""
-if 'habilidades' not in st.session_state:
-    st.session_state.habilidades = ""
-if 'creatividad' not in st.session_state:
-    st.session_state.creatividad = 1.0
-# Update the default format in session state
-if 'formato' not in st.session_state:
-    st.session_state.formato = "Jung's_Avatar"  # Changed from previous format name
-if 'nivel_conciencia' not in st.session_state:
-    # Usar el primer nivel del diccionario como valor predeterminado
-    first_key = list(CONSCIOUSNESS_LEVELS.keys())[0]
-    st.session_state.nivel_conciencia = first_key.replace("_", " ")
-
-# Función para generar el perfil de cliente ideal
-@st.cache_resource
-def get_model(temperature):
-    generation_config = {
+# Create a reusable function for the UI input section
+def create_input_section(col, audience_key, product_key, formula_options, formula_key):
+    audience = col.text_input("¿Quién es tu público objetivo?", placeholder="Ejemplo: Emprendedores digitales", key=audience_key)
+    product = col.text_input("¿Sobre qué tema es tu webinar?", placeholder="Ejemplo: Marketing en redes sociales", key=product_key)
+    
+    selected_formula_key = col.selectbox(
+        "Selecciona un framework de webinar" if "script" in audience_key else "Selecciona una fórmula para tus nombres de webinar",
+        options=list(formula_options.keys()),
+        key=formula_key
+    )
+    
+    return audience, product, selected_formula_key
+
+# Create a reusable function for generation and display
+def generate_and_display(col, generator_func, audience, product, temperature, selected_formula, **kwargs):
+    if validate_inputs(audience, product):
+        try:
+            with col:
+                with st.spinner("Generando contenido...", show_time=True):
+                    # Extract only the parameters that the generator function accepts
+                    if generator_func.__name__ == "generate_webinar_script":
+                        generated_content = generator_func(
+                            audience=audience,
+                            topic=product,
+                            temperature=temperature,
+                            selected_formula=selected_formula
+                        )
+                    else:
+                        generated_content = generator_func(
+                            audience=audience,
+                            topic=product,
+                            temperature=temperature,
+                            selected_formula=selected_formula,
+                            **kwargs
+                        )
+                
+                # For webinar scripts, add download buttons
+                if "script" in kwargs.get("content_type", ""):
+                    timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+                    st.download_button(
+                        label="DESCARGAR GUION DE MI WEBINAR",
+                        data=generated_content,
+                        file_name=f"guion_webinar_{timestamp}.md",
+                        mime="text/markdown",
+                        key="download_top"
+                    )
+                
+                st.subheader("Tu " + ("guión de webinar:" if "script" in kwargs.get("content_type", "") else "nombres de webinar:"))
+                st.markdown(generated_content)
+                
+                # Add bottom download button for scripts
+                if "script" in kwargs.get("content_type", ""):
+                    st.download_button(
+                        label="DESCARGAR GUION DE MI WEBINAR",
+                        data=generated_content,
+                        file_name=f"guion_webinar_{timestamp}.md",
+                        mime="text/markdown",
+                        key="download_bottom"
+                    )
+        except ValueError as e:
+            col.error(f"Error: {str(e)}")
+    else:
+        col.error("Por favor, proporciona el público objetivo y el tema del webinar.")
+
+# Función para crear la configuración del modelo (evita duplicación)
+def create_model_config(temperature):
+    return {
         "temperature": temperature,
+        "top_p": 0.65,
+        "top_k": 360,
+        "max_output_tokens": 8196,
     }
-    return genai.GenerativeModel('gemini-2.0-flash', generation_config=generation_config)
 
-# REMOVED: The format selection dropdown that was here
+# Función para inicializar el modelo
+def initialize_model(temperature):
+    config = create_model_config(temperature)
+    return genai.GenerativeModel(
+        model_name="gemini-2.0-flash",
+        generation_config=config,
+    )
+
+# Refactored model interaction function to reduce duplication
+def generate_content(prompt_instructions, temperature):
+    model = initialize_model(temperature)
+    chat_session = model.start_chat(
+        history=[
+            {
+                "role": "user",
+                "parts": [prompt_instructions],
+            },
+        ]
+    )
+    response = chat_session.send_message("Generate the content following exactly the provided instructions. All content must be in Spanish.")
+    return response.text
 
-def generate_buyer_persona(product, skills, target_audience, temperature, consciousness_level="Ninguno", format_type="Jung's_Avatar"):
-    if not product or not skills:
-        return "Por favor, completa los campos de producto y habilidades."
+# Función para generar nombres de webinars
+def generate_webinar_names(number_of_names, target_audience, product, temperature, selected_formula, selected_angle=None):
+    # Incluir las instrucciones del sistema en el prompt principal
+    system_prompt = """You are a world-class copywriter, with expertise in crafting compelling webinar titles that immediately capture the audience's attention and drive registrations.
+
+FORMAT RULES:
+- Each webinar name must start with number and period
+- One webinar name per line
+- No explanations or categories
+- Add a line break between each name
+- Avoid unnecessary : symbols
+- Each webinar name must be a complete and intriguing title
+- WRITE ALL WEBINAR NAMES IN SPANISH
+
+FORMAT EXAMPLE:
+1. Nombre del Webinar 1.
+
+2. Nombre del Webinar 2.
+
+3. Nombre del Webinar 3.
+
+4. Nombre del Webinar 4.
+
+5. Nombre del Webinar 5.
+
+IMPORTANT:
+- Each webinar name must be unique and memorable
+- Avoid clichés and generalities
+- Maintain an intriguing but credible tone
+- Adapt speaking language from the audience
+- Focus on transformative benefits
+- Follow the selected formula structure
+- WRITE ALL WEBINAR NAMES IN SPANISH"""
+
+    # Iniciar el prompt con las instrucciones del sistema
+    webinar_names_instruction = f"{system_prompt}\n\n"
     
-    try:
-        model = get_model(temperature)
-        instruction = create_instruction(
-            format_type=format_type,
-            product_service=product,
-            skills=skills,
-            consciousness_level=consciousness_level,
-            target_audience=target_audience,
-            gender=None  # Adding gender parameter with None as default
-        )
-        
-        # Añadir instrucción explícita para respuesta en español
-        instruction += "\n\nIMPORTANTE: La respuesta debe estar completamente en español."
-        
-        response = model.generate_content([instruction], generation_config={"temperature": temperature})
-        return response.parts[0].text if response and response.parts else "Error generando el perfil de cliente ideal."
-    except Exception as e:
-        return f"Error al generar el perfil: {str(e)}"
-
-# Modificar la función update_profile para que no use spinner
-def update_profile():
-    # Solo actualizar la variable de sesión
-    st.session_state.submitted = True
-
-# Leer el contenido del archivo manual.md si existe
-try:
-    with open("manual.md", "r", encoding="utf-8") as file:
-        manual_content = file.read()
-    # Mostrar el contenido del manual en el sidebar
-    st.sidebar.markdown(manual_content)
-except FileNotFoundError:
-    st.sidebar.warning("Manual not found. Please create a manual.md file.")
-except Exception as e:
-    st.sidebar.error(f"Error loading manual: {str(e)}")
-
-# Ocultar elementos de la interfaz
-st.markdown(styles["main_layout"], unsafe_allow_html=True)
-
-# Centrar el título y el subtítulo
-st.markdown("<h1 style='text-align: center;'>Generador de Perfil de Cliente Ideal</h1>", unsafe_allow_html=True)
-st.markdown("<h4 style='text-align: center;'>Crea un perfil detallado de tu cliente ideal basado en tu producto y habilidades.</h4>", unsafe_allow_html=True)
-
-# Añadir CSS personalizado para el botón
-st.markdown(styles["button"], unsafe_allow_html=True)
-# Añadir CSS personalizado para el botón de descarga
-st.markdown(styles["download_button"], unsafe_allow_html=True)
-
-# Crear columnas
-col1, col2 = st.columns([1, 2])  
-
-# Columna de entrada
-with col1:
-    product = st.text_area("¿Qué producto o servicio ofreces?", 
-                          value=st.session_state.producto,
-                          placeholder="Ejemplo: Curso de Inglés",
-                          key="producto_input",
-                          height=70)
-    st.session_state.producto = product
+    # Añadir instrucciones de ángulo solo si no es "NINGUNO" y se proporcionó un ángulo
+    if selected_angle and selected_angle != "NINGUNO":
+        webinar_names_instruction += f"""
+MAIN ANGLE: {selected_angle}
+SPECIFIC ANGLE INSTRUCTIONS:
+{angles_webinar_names[selected_angle]["instruction"]}
+
+IMPORTANT: The {selected_angle} angle should be applied as a "style layer" over the formula structure:
+1. Keep the base structure of the formula intact
+2. Apply the tone and style of the {selected_angle} angle
+3. Ensure that each element of the formula reflects the angle
+4. The angle affects "how" it is said, not "what" is said
+
+SUCCESSFUL EXAMPLES OF THE {selected_angle} ANGLE:
+"""
+        for example in angles_webinar_names[selected_angle]["examples"]:
+            webinar_names_instruction += f"- {example}\n"
     
-    skills = st.text_area("¿Cuáles son tus habilidades principales?", 
-                             value=st.session_state.habilidades,
-                             placeholder="Ejemplo: Enseñanza, comunicación, diseño de contenidos",
-                             key="habilidades_input",
-                             height=70)
-    st.session_state.habilidades = skills
+    # Instrucciones específicas para la tarea
+    webinar_names_instruction += (
+        f"\nYour task is to create {number_of_names} irresistible webinar names for {target_audience} "
+        f"that instantly capture attention and generate registrations for a webinar about {product}. "
+        f"Focus on awakening genuine interest and communicating the value they will get by registering."
+        f"\n\n"
+        f"IMPORTANT: Carefully study these examples of the selected formula. "
+        f"Each example represents the style and structure to follow"
+        f":\n\n"
+    )
     
-    # Botón para generar - Movido arriba del acordeón
-    submit = st.button("CREAR MI CLIENTE IDEAL SOÑADO ➤➤", on_click=update_profile)
+    # Agregar ejemplos aleatorios de la fórmula (keeping examples in Spanish)
+    random_examples = random.sample(selected_formula['examples'], min(5, len(selected_formula['examples'])))
+    webinar_names_instruction += "EXAMPLES OF THE FORMULA TO FOLLOW:\n"
+    for i, example in enumerate(random_examples, 1):
+        webinar_names_instruction += f"{i}. {example}\n"
     
-    # Crear un acordeón para las opciones de personalización
-    with st.expander("Personaliza Tu Cliente Ideal Soñado"):
-        # Nuevo campo para público objetivo
-        if 'publico_objetivo' not in st.session_state:
-            st.session_state.publico_objetivo = ""
-        
-        target_audience = st.text_area("¿Cuál es tu público objetivo? (opcional)", 
-                                      value=st.session_state.publico_objetivo,
-                                      placeholder="Ejemplo: Profesionales entre 25-40 años interesados en desarrollo personal",
-                                      key="publico_objetivo_input",
-                                      height=70)
-        st.session_state.publico_objetivo = target_audience
-        
-        # Selector de formato
-        from format.format import buyer_persona_formats
-        
-        # Usar directamente las claves del diccionario sin filtrar
-        format_type = st.selectbox(
-            "Formato del perfil",
-            options=list(buyer_persona_formats.keys()),
-            format_func=lambda x: x.capitalize(),
-            index=list(buyer_persona_formats.keys()).index(st.session_state.formato) if st.session_state.formato in buyer_persona_formats else 0,
-            help="Selecciona el formato en el que se presentará el perfil del cliente ideal"
+    # Instrucciones específicas (translated to English)
+    webinar_names_instruction += "\nSPECIFIC INSTRUCTIONS:\n"
+    webinar_names_instruction += "1. Maintain the same structure and length as the previous examples\n"
+    webinar_names_instruction += "2. Use the same tone and writing style\n"
+    webinar_names_instruction += "3. Replicate the phrase construction patterns\n"
+    webinar_names_instruction += "4. Preserve the level of specificity and detail\n"
+    webinar_names_instruction += f"5. Adapt the content for {target_audience} while maintaining the essence of the examples\n\n"
+    webinar_names_instruction += f"FORMULA TO FOLLOW:\n{selected_formula['description']}\n\n"
+    webinar_names_instruction += f"""
+GENERATE NOW:
+Create {number_of_names} webinar names that faithfully follow the style and structure of the examples shown.
+"""
+
+    # Enviar el mensaje al modelo
+    # Use the common generate_content function
+    return generate_content(webinar_names_instruction, temperature)
+
+def generate_webinar_script(audience, topic, temperature, selected_formula):
+    model = initialize_model(temperature)
+    
+    # Incluir las instrucciones del sistema en el prompt principal
+    system_prompt = f"""You are a collaborative team of world-class experts working together to create an exceptional webinar script that converts audience into customers.
+
+THE EXPERT TEAM:
+
+1. MASTER WEBINAR STRATEGIST:
+   - Expert in webinar frameworks and conversion strategies
+   - Trained in the Perfect Webinar methodology by Russell Brunson
+   - Ensures the script follows the selected framework structure precisely
+   - Focuses on strategic placement of key conversion elements
+
+2. ELITE DIRECT RESPONSE COPYWRITER:
+   - Trained by Gary Halbert, Gary Bencivenga, and David Ogilvy
+   - Creates compelling hooks, stories, and persuasive elements
+   - Crafts irresistible calls to action that drive conversions
+   - Ensures the language resonates with the target audience
+
+3. AUDIENCE PSYCHOLOGY SPECIALIST:
+   - Expert in understanding audience motivations and objections
+   - Creates content that builds genuine connection and trust
+   - Identifies and addresses hidden fears and desires
+   - Ensures the content feels personal and relevant
+
+4. STORYTELLING MASTER:
+   - Creates compelling narratives that illustrate key points
+   - Develops relatable examples and case studies
+   - Ensures stories support the transformation being offered
+   - Makes complex concepts accessible through narrative
+
+5. WEBINAR ENGAGEMENT EXPERT:
+   - Specializes in maintaining audience attention throughout
+   - Creates interactive elements and engagement hooks
+   - Develops compelling transitions between sections
+   - Ensures the webinar flows naturally and keeps interest high
+
+AUDIENCE UNDERSTANDING:
+You understand how real people interact with webinar content:
+- They quickly lose interest if the content feels generic or corporate
+- They only stay engaged when the content feels personal and sparks genuine curiosity
+- They respond to messages that seem delivered by a real person, not a corporation
+- They engage with content that hooks them from the first line and maintains interest throughout
+
+FORMAT RULES:
+- Create a complete webinar script with clear sections and subsections
+- Include specific talking points for each section
+- Write in a conversational, engaging tone
+- Include persuasive elements and calls to action
+- Follow the selected webinar framework structure exactly
+- WRITE THE ENTIRE SCRIPT IN SPANISH
+- DO NOT include any introductory text or explanations about the script
+- Start directly with the webinar content
+
+IMPORTANT:
+- The script must be comprehensive and ready to use
+- Include specific examples and stories relevant to the topic
+- Maintain a persuasive but authentic tone
+- Adapt language to match the target audience
+- Focus on transformative benefits and clear value proposition
+- Follow the selected formula structure precisely
+- WRITE THE ENTIRE SCRIPT IN SPANISH
+- DO NOT include phrases like "Aquí tienes un guion completo" or any other meta-commentary
+
+COLLABORATIVE PROCESS:
+As a team of experts, you will:
+
+1. Analyze the framework '{selected_formula['description']}' to understand its core principles
+2. Identify how to best adapt this framework for {audience} learning about {topic}
+3. Determine the most effective storytelling opportunities within the framework
+4. Create persuasive language that resonates with {audience}
+5. Ensure the script maintains engagement throughout
+6. Adapt the content to be accessible to beginners while still valuable to experienced individuals
+7. Follow the exact structure provided in the framework
+
+Each expert will contribute their specialized knowledge to create a cohesive, compelling script that:
+- Follows the exact structure of the selected framework
+- Engages the audience from start to finish
+- Addresses audience pain points and desires
+- Presents {topic} in a clear, compelling way
+- Drives conversions through strategic calls to action"""
+
+    # Iniciar el prompt con las instrucciones del sistema
+    webinar_script_instruction = f"{system_prompt}\n\n"
+    
+    # Instrucciones específicas para la tarea
+    webinar_script_instruction += (
+        f"\nYour task is to create a complete webinar script IN SPANISH for {audience} "
+        f"about {topic} that is persuasive and converts the audience into customers. "
+        f"The script must follow exactly the structure of the framework '{selected_formula['description']}' "
+        f"and must include all the necessary elements for a successful webinar."
+        f"\n\n"
+    )
+
+    # Estructura del webinar
+    webinar_script_instruction += "WEBINAR STRUCTURE TO FOLLOW:\n"
+    for i, step in enumerate(selected_formula['structure'], 1):
+        webinar_script_instruction += f"{i}. {step}\n"
+
+    # Ejemplos de webinars exitosos
+    webinar_script_instruction += "\n\nEXAMPLES OF SUCCESSFUL WEBINARS WITH THIS STRUCTURE:\n"
+    for i, example in enumerate(selected_formula['examples'], 1):
+        webinar_script_instruction += f"{i}. {example}\n"
+
+    # Instrucciones específicas
+    webinar_script_instruction += f"""
+SPECIFIC INSTRUCTIONS:
+1. Create a complete script that follows exactly the provided structure
+2. Include persuasive elements and clear calls to action
+3. Adapt the language and examples specifically for {audience}
+4. Focus on the transformative benefits of {topic}
+5. Include relevant stories and examples that reinforce your points
+6. Use a conversational but professional tone
+7. Make sure each section fulfills its specific purpose in the framework
+8. IMPORTANT: Write the entire script in Spanish
+
+GENERATE NOW:
+Create a complete webinar script following faithfully the structure of the selected framework.
+"""
+
+    # Enviar el mensaje al modelo
+    chat_session = model.start_chat(
+        history=[
+            {
+                "role": "user",
+                "parts": [webinar_script_instruction],
+            },
+        ]
+    )
+    response = chat_session.send_message("Generate the webinar script IN NEUTRAL SPANISH following exactly the provided structure. All content must be in neutral Spanish (not Spain Spanish).")
+    
+    return response.text
+
+# Función para validar entradas (evita duplicación)
+def validate_inputs(audience, product):
+    has_audience = audience.strip() != ""
+    has_product = product.strip() != ""
+    return has_audience and has_product
+
+# Update the load_css function comment to be more descriptive
+def load_css():
+    css_path = "styles/styles.css"
+    if os.path.exists(css_path):
+        try:
+            with open(css_path, "r") as f:
+                st.markdown(f"<style>{f.read()}</style>", unsafe_allow_html=True)
+        except Exception as e:
+            st.warning(f"Error al cargar el archivo CSS: {str(e)}")
+    else:
+        st.warning(f"No se encontró el archivo CSS en {css_path}")
+
+# Create a reusable function for custom buttons
+# At the top of your file, define the styles dictionary
+styles = {
+    "button": """
+        <style>
+        div.stButton > button:first-child {
+            background-color: #FF4B4B;
+            color: white;
+            font-weight: bold;
+            padding: 0.5rem 1rem;
+            border-radius: 0.5rem;
+            border: none;
+            transition: all 0.3s;
+        }
+        div.stButton > button:hover {
+            background-color: #FF2525;
+            transform: translateY(-2px);
+            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+        }
+        </style>
+    """,
+    "download_button": """
+        <style>
+        div.stDownloadButton > button:first-child {
+            background-color: #4CAF50;
+            color: white;
+            font-weight: bold;
+            padding: 0.5rem 1rem;
+            border-radius: 0.5rem;
+            border: none;
+            transition: all 0.3s;
+        }
+        div.stDownloadButton > button:hover {
+            background-color: #45a049;
+            transform: translateY(-2px);
+            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+        }
+        </style>
+    """
+}
+
+# Then modify your create_custom_button function to be much simpler:
+def create_custom_button(label, button_key):
+    # Apply the button style once at the beginning of your app
+    # (You can move this to your main app code if you prefer)
+    st.markdown(styles["button"], unsafe_allow_html=True)
+    
+    # Just return a regular Streamlit button
+    return st.button(label, key=button_key)
+
+# Modify the page config section to include the CSS loading
+st.set_page_config(page_title="Perfect Webinar Framework", layout="wide")
+load_css()
+
+# Leer el contenido del archivo manual.md
+with open("manual.md", "r", encoding="utf-8") as file:
+    manual_content = file.read()
+
+# Mostrar el contenido del manual en el sidebar
+st.sidebar.markdown(manual_content)
+
+# Crear pestañas para la interfaz
+tab1, tab2 = st.tabs(["Guiones de Webinar", "Nombres de Webinar"])
+
+# Primera pestaña - Generador de Guiones de Webinar
+with tab1:
+    tab1.subheader("Script Webinar")
+    
+    # Crear columnas para la interfaz
+    col1, col2 = tab1.columns([1, 2])
+    
+    # Columna de entrada usando la función reutilizable
+    with col1:
+        webinar_script_audience, webinar_script_product, selected_webinar_formula_key = create_input_section(
+            col1, 
+            "webinar_script_audience", 
+            "webinar_script_product", 
+            webinar_formulas, 
+            "webinar_formula"
         )
-        st.session_state.formato = format_type
         
-        # Nivel de creatividad con slider
-        temperature = st.slider("Nivel de creatividad", 
-                               min_value=0.0, 
-                               max_value=2.0, 
-                               value=st.session_state.creatividad, 
-                               step=0.1,
-                               key="creatividad_slider")
-        st.session_state.creatividad = temperature
+        # Usar la función reutilizable para crear el botón personalizado
+        submit_webinar_script = create_custom_button("Generar Guión de Webinar", "generate_webinar_script")
         
-        # Selector de nivel de conciencia
-        consciousness_options = []
-        for i, key in enumerate(CONSCIOUSNESS_LEVELS.keys(), 1):
-            # Replace underscores with spaces in the key
-            display_name = key.replace("_", " ")
-            consciousness_options.append(f"Nivel {i} - {display_name}")
+        # Opciones avanzadas
+        with st.expander("Personaliza tu guión de webinar"):
+            webinar_script_temperature = st.slider("Creatividad", min_value=0.0, max_value=2.0, value=1.0, step=0.1, key="webinar_script_temp")
         
-        nivel_conciencia_display = st.selectbox(
-            "Nivel de conciencia del cliente ideal",
-            consciousness_options,
-            index=0,
-            help="Selecciona el nivel de conciencia en el que se encuentra tu cliente ideal"
+        selected_webinar_formula = webinar_formulas[selected_webinar_formula_key]
+    
+    # Generar y mostrar el guión usando la función reutilizable
+    if submit_webinar_script:
+        generate_and_display(
+            col2,
+            generate_webinar_script,
+            webinar_script_audience,
+            webinar_script_product,
+            webinar_script_temperature,
+            selected_webinar_formula,
+            content_type="script"
+        )
+
+# Segunda pestaña - Generador de Nombres de Webinar
+with tab2:
+    tab2.subheader("Nombres de Webinar")
+    
+    # Crear columnas para la interfaz
+    col1, col2 = tab2.columns([1, 2])
+    
+    # Columna de entrada usando la función reutilizable
+    with col1:
+        webinar_name_audience, webinar_name_product, selected_webinar_name_formula_key = create_input_section(
+            col1, 
+            "webinar_name_audience", 
+            "webinar_name_product", 
+            webinar_name_formulas, 
+            "webinar_name_formula"
         )
         
-        # Extract the original key from the display name
-        level_number = nivel_conciencia_display.split(" - ")[0].replace("Nivel ", "")
-        original_key = list(CONSCIOUSNESS_LEVELS.keys())[int(level_number) - 1]
-        nivel_conciencia = original_key.replace("_", " ")
+        number_of_names = st.selectbox("Número de nombres", options=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10], index=4, key="number_of_names")
         
-        # Get the description from the CONSCIOUSNESS_LEVELS dictionary
-        if original_key in CONSCIOUSNESS_LEVELS:
-            nivel_info = CONSCIOUSNESS_LEVELS[original_key]["estado_mental"]
-            st.info(f"**{nivel_conciencia}**: {nivel_info}")
-            
-        st.session_state.nivel_conciencia = nivel_conciencia
-
-# Columna de resultados
-with col2:
-    # Verificar si se ha enviado el formulario
-    if 'submitted' in st.session_state and st.session_state.submitted:
-        if st.session_state.producto and st.session_state.habilidades:
-            with st.spinner("Creando tu Cliente Ideal Soñado..."):
-                # Generar el perfil del cliente
-                buyer_persona = generate_buyer_persona(
-                    st.session_state.producto,
-                    st.session_state.habilidades,
-                    st.session_state.publico_objetivo,
-                    st.session_state.creatividad,
-                    st.session_state.nivel_conciencia,
-                    st.session_state.formato
-                )
-                
-                # Mejorar la limpieza del perfil para eliminar estructuras JSON/diccionario
-                if isinstance(buyer_persona, str):
-                    import re
-                    import json
-                    
-                    # Eliminar marcadores de código markdown como ```json, ```python, etc.
-                    buyer_persona = re.sub(r'```[a-z]*\n', '', buyer_persona)
-                    buyer_persona = re.sub(r'```', '', buyer_persona)
-                    
-                    # Intentar detectar y limpiar formato JSON
-                    if '{' in buyer_persona and '}' in buyer_persona:
-                        # Intentar extraer solo el contenido textual, eliminando estructuras JSON
-                        # Primero, intentar encontrar el JSON completo
-                        json_pattern = r'(\{.*?\})'
-                        json_matches = re.findall(json_pattern, buyer_persona, re.DOTALL)
-                        
-                        if json_matches:
-                            for json_match in json_matches:
-                                # Intentar extraer el contenido real del JSON
-                                try:
-                                    # Reemplazar el JSON con una cadena vacía
-                                    buyer_persona = buyer_persona.replace(json_match, '')
-                                except:
-                                    pass
-                        
-                        # Limpiar líneas que parecen ser parte de un diccionario
-                        lines = buyer_persona.split('\n')
-                        cleaned_lines = []
-                        for line in lines:
-                            # Omitir líneas que parecen ser claves de diccionario
-                            if not re.match(r'^\s*["\']?[a-zA-Z_]+["\']?\s*:', line):
-                                cleaned_lines.append(line)
-                        
-                        buyer_persona = '\n'.join(cleaned_lines)
-                        
-                        # Eliminar llaves sueltas y corchetes
-                        buyer_persona = re.sub(r'[{}[\]]', '', buyer_persona)
-                        
-                        # Eliminar comillas y dos puntos que parecen ser de un diccionario
-                        buyer_persona = re.sub(r'["\']\s*:\s*["\']', '', buyer_persona)
-                        
-                        # Eliminar "template", "description", "example" y otras palabras clave comunes en el formato
-                        keywords = ["template", "description", "example", "Nivel de conciencia"]
-                        for keyword in keywords:
-                            buyer_persona = re.sub(rf'["\']?{keyword}["\']?\s*:\s*["\']?', '', buyer_persona)
-                        
-                        # Eliminar comillas sueltas
-                        buyer_persona = re.sub(r'^\s*["\']|["\']$', '', buyer_persona)
-                    
-                    # Normalizar espacios en blanco y sangrías
-                    lines = buyer_persona.split('\n')
-                    cleaned_lines = []
-                    for line in lines:
-                        # Eliminar sangrías excesivas pero mantener estructura básica
-                        cleaned_line = line.strip()
-                        if cleaned_line:  # Solo agregar líneas no vacías
-                            cleaned_lines.append(cleaned_line)
-                    
-                    # Unir las líneas con saltos de línea adecuados
-                    buyer_persona = '\n'.join(cleaned_lines)
-                    
-                    # Eliminar espacios en blanco adicionales
-                    buyer_persona = re.sub(r'\n\s*\n', '\n\n', buyer_persona)
-                    buyer_persona = buyer_persona.strip()
-                    
-                    # Al inicio del archivo, junto con las otras inicializaciones
-                    if 'perfil_cliente_plain' not in st.session_state:
-                        st.session_state.perfil_cliente_plain = None
-                    
-                    # Guardar versión sin formato antes de aplicar estilos HTML
-                    st.session_state.perfil_cliente_plain = buyer_persona
-                    
-                    # Convertir los asteriscos de formato Markdown a HTML para una correcta visualización
-                    # Convertir **texto** a <strong>texto</strong>
-                    buyer_persona = re.sub(r'\*\*(.*?)\*\*', r'<strong>\1</strong>', buyer_persona)
-                    # Convertir *texto* a <em>texto</em>
-                    buyer_persona = re.sub(r'\*(.*?)\*', r'<em>\1</em>', buyer_persona)
-                    
-                    # Mejorar el formato HTML para una mejor visualización
-                    buyer_persona = """
-                    <div style="line-height: 1.3; text-align: left;">
-                        {}
-                    </div>
-                    """.format(buyer_persona.replace('\n', '<br><br>'))
-                
-                # Guardar en session_state
-                st.session_state.perfil_cliente = buyer_persona
-                # Resetear el estado de envío
-                st.session_state.submitted = False
-                
-            # Mostrar resultados
-            if not isinstance(st.session_state.perfil_cliente, str):
-                st.error("Error al generar el perfil de cliente ideal")
-            else:
-                # Crear un contenedor para el resultado
-                result_container = st.container()
-                
-                # Aplicar estilos del contenedor
-                st.markdown(styles["results_container"], unsafe_allow_html=True)
-                
-                with result_container:
-                    # Mostrar el título
-                    st.markdown("<div class='results-title'>Tu Cliente Ideal</div>", unsafe_allow_html=True)
-                    
-                    # Mostrar el contenido como HTML para asegurar el formato correcto
-                    st.markdown(st.session_state.perfil_cliente, unsafe_allow_html=True)
-                
-                # Opción para descargar
-                # En la sección de descarga anterior, asegurarse de usar la versión plain si existe
-                st.download_button(
-                    label="DESCARGAR MI CLIENTE SOÑADO ➤➤",
-                    data=st.session_state.perfil_cliente_plain if st.session_state.perfil_cliente_plain else st.session_state.perfil_cliente,
-                    file_name="cliente_ideal.txt",
-                    mime="text/plain"
-                )
+        # Usar la función reutilizable para crear el botón personalizado
+        submit_webinar_names = create_custom_button("Generar Nombres de Webinar", "generate_webinar_names")
+
+        # Opciones avanzadas
+        with st.expander("Personaliza tus nombres de webinar"):
+            webinar_name_temperature = st.slider("Creatividad", min_value=0.0, max_value=2.0, value=1.0, step=0.1, key="webinar_name_temp")
+
+            # Configurar opciones de ángulo
+            angle_keys = ["NINGUNO"] + sorted([key for key in angles_webinar_names.keys() if key != "NINGUNO"])
+            selected_angle = st.selectbox(
+                "Selecciona el ángulo para tus nombres",
+                options=angle_keys,
+                key="webinar_name_angle"
+            )
+
+        selected_webinar_name_formula = webinar_name_formulas[selected_webinar_name_formula_key]
+
+    # Generar y mostrar los nombres usando la función reutilizable
+    if submit_webinar_names:
+        generate_and_display(
+            col2,
+            generate_webinar_names,
+            webinar_name_audience,
+            webinar_name_product,
+            webinar_name_temperature,
+            selected_webinar_name_formula,
+            content_type="names",
+            number_of_names=number_of_names,
+            selected_angle=selected_angle if selected_angle != "NINGUNO" else None
+        )
+        if validate_inputs(webinar_name_audience, webinar_name_product):
+            try:
+                with col2:
+                    with st.spinner("Generando tus nombres de webinar...", show_time=True):
+                        generated_webinar_names = generate_webinar_names(
+                            number_of_names,
+                            webinar_name_audience,
+                            webinar_name_product,
+                            webinar_name_temperature,
+                            selected_webinar_name_formula,
+                            selected_angle if selected_angle != "NINGUNO" else None
+                        )
+                    st.subheader("Tus nombres de webinar:")
+                    st.markdown(generated_webinar_names)
+            except ValueError as e:
+                col2.error(f"Error: {str(e)}")
         else:
-            st.warning("Por favor, completa los campos de producto y habilidades antes de generar el perfil.")
-    # Mostrar resultados anteriores si existen
-    elif st.session_state.perfil_cliente:
-        # Crear un contenedor para el resultado
-        result_container = st.container()
-        
-        # Aplicar estilos del contenedor
-        st.markdown(styles["results_container"], unsafe_allow_html=True)
-        
-        with result_container:
-            # Mostrar el título
-            st.markdown("<div class='results-title'>Tu Cliente Ideal</div>", unsafe_allow_html=True)
-            
-            # Mostrar el contenido como HTML para asegurar el formato correcto
-            st.markdown(st.session_state.perfil_cliente, unsafe_allow_html=True)
-        
-        # Opción para descargar
-        st.download_button(
-            label="DESCARGAR MI CLIENTE SOÑADO ➤➤",
-            data=st.session_state.perfil_cliente,
-            file_name="cliente_ideal.txt",
-            mime="text/plain"
-        )
+            col2.error("Por favor, proporciona el público objetivo y el tema del webinar.")
+