Update app.py

app.py

@@ -10,7 +10,6 @@ import base64
 import textwrap
 from dotenv import load_dotenv
 from openai import OpenAI  # Updated OpenAI client
-from elevenlabs import ElevenLabs  # Official ElevenLabs SDK import
 
 # Load environment variables
 load_dotenv()
@@ -19,8 +18,6 @@ load_dotenv()
 openai_client = OpenAI(api_key=os.getenv("OPENAI_API_KEY")) if os.getenv("OPENAI_API_KEY") else None
 ELEVENLABS_API_KEY = os.getenv("ELEVENLABS_API_KEY")
 
-eleven_client = ElevenLabs(api_key=ELEVENLABS_API_KEY) if ELEVENLABS_API_KEY else None
-
 # =============================
 # UPDATED AGENT IMPLEMENTATION (OpenAI v1.x compatible)
 # =============================
@@ -29,18 +26,25 @@ class TopicAgent:
     def generate_outline(self, topic, duration, difficulty):
         if not openai_client:
             return self._mock_outline(topic, duration, difficulty)
+            
         try:
             response = openai_client.chat.completions.create(
                 model="gpt-4-turbo",
                 messages=[
-                    {"role": "system", "content": "You're an expert corporate trainer creating comprehensive AI workshop outlines."},
-                    {"role": "user", "content": (
-                        f"Create a detailed {duration}-hour {difficulty} workshop outline on {topic}. "
-                        "Include: 4-6 modules with specific learning objectives, hands-on exercises, "
-                        "and real-world case studies. Format as JSON with keys: "
-                        "{'topic', 'duration', 'difficulty', 'goals', 'modules': ["
-                        "{'title', 'duration', 'learning_objectives', 'case_study', 'exercises'}]}"
-                    )}
+                    {
+                        "role": "system",
+                        "content": "You're an expert corporate trainer creating comprehensive AI workshop outlines."
+                    },
+                    {
+                        "role": "user",
+                        "content": (
+                            f"Create a detailed {duration}-hour {difficulty} workshop outline on {topic}. "
+                            "Include: 4-6 modules with specific learning objectives, hands-on exercises, "
+                            "and real-world case studies. Format as JSON with keys: "
+                            "{'topic', 'duration', 'difficulty', 'goals', 'modules': ["
+                            "{'title', 'duration', 'learning_objectives', 'case_study', 'exercises'}]}"
+                        )
+                    }
                 ],
                 temperature=0.3,
                 max_tokens=1500,
@@ -48,9 +52,9 @@ class TopicAgent:
             )
             return json.loads(response.choices[0].message.content)
         except Exception as e:
-            st.error(f"Outline generation error: {e}")
+            st.error(f"Outline generation error: {str(e)}")
             return self._mock_outline(topic, duration, difficulty)
-
+    
     def _mock_outline(self, topic, duration, difficulty):
         return {
             "topic": topic,
@@ -98,18 +102,25 @@ class ContentAgent:
     def generate_content(self, outline):
         if not openai_client:
             return self._mock_content(outline)
+            
         try:
             response = openai_client.chat.completions.create(
                 model="gpt-4-turbo",
                 messages=[
-                    {"role": "system", "content": "You're a corporate training content developer creating detailed workshop materials."},
-                    {"role": "user", "content": (
-                        f"Expand this workshop outline into comprehensive content: {json.dumps(outline)}. "
-                        "For each module, include: detailed script (3-5 paragraphs), speaker notes (bullet points), "
-                        "3 quiz questions with explanations, and exercise instructions. Format as JSON with keys: "
-                        "{'workshop_title', 'modules': [{'title', 'script', 'speaker_notes', 'quiz': ["
-                        "{'question', 'options', 'answer', 'explanation'}], 'exercise_instructions'}]}"
-                    )}
+                    {
+                        "role": "system",
+                        "content": "You're a corporate training content developer creating detailed workshop materials."
+                    },
+                    {
+                        "role": "user",
+                        "content": (
+                            f"Expand this workshop outline into comprehensive content: {json.dumps(outline)}. "
+                            "For each module, include: detailed script (3-5 paragraphs), speaker notes (bullet points), "
+                            "3 quiz questions with explanations, and exercise instructions. Format as JSON with keys: "
+                            "{'workshop_title', 'modules': [{'title', 'script', 'speaker_notes', 'quiz': ["
+                            "{'question', 'options', 'answer', 'explanation'}], 'exercise_instructions'}]}"
+                        )
+                    }
                 ],
                 temperature=0.4,
                 max_tokens=2000,
@@ -117,9 +128,9 @@ class ContentAgent:
             )
             return json.loads(response.choices[0].message.content)
         except Exception as e:
-            st.error(f"Content generation error: {e}")
+            st.error(f"Content generation error: {str(e)}")
             return self._mock_content(outline)
-
+    
     def _mock_content(self, outline):
         return {
             "workshop_title": f"Mastering {outline['topic']}",
@@ -133,10 +144,12 @@ class ContentAgent:
                         "Discuss token limitations and their impact"
                     ],
                     "quiz": [
-                        {"question": "What's the most important element of a good prompt?",
-                         "options": ["Length", "Specificity", "Complexity", "Creativity"],
-                         "answer": "Specificity",
-                         "explanation": "Specific prompts yield more accurate and relevant responses"}
+                        {
+                            "question": "What's the most important element of a good prompt?",
+                            "options": ["Length", "Specificity", "Complexity", "Creativity"],
+                            "answer": "Specificity",
+                            "explanation": "Specific prompts yield more accurate and relevant responses"
+                        }
                     ],
                     "exercise_instructions": "Create a prompt that extracts key insights from a financial report..."
                 }
@@ -147,26 +160,33 @@ class SlideAgent:
     def generate_slides(self, content):
         if not openai_client:
             return self._mock_slides(content)
+            
         try:
             response = openai_client.chat.completions.create(
                 model="gpt-4-turbo",
                 messages=[
-                    {"role": "system", "content": "You create professional slide decks in Markdown format using Marp syntax."},
-                    {"role": "user", "content": (
-                        f"Create a slide deck for this workshop content: {json.dumps(content)}. "
-                        "Use Marp Markdown format with themes and visual elements. "
-                        "Include: title slide, module slides with key points, case studies, "
-                        "exercise instructions, and summary slides. Make it visually appealing."
-                    )}
+                    {
+                        "role": "system",
+                        "content": "You create professional slide decks in Markdown format using Marp syntax."
+                    },
+                    {
+                        "role": "user",
+                        "content": (
+                            f"Create a slide deck for this workshop content: {json.dumps(content)}. "
+                            "Use Marp Markdown format with themes and visual elements. "
+                            "Include: title slide, module slides with key points, case studies, "
+                            "exercise instructions, and summary slides. Make it visually appealing."
+                        )
+                    }
                 ],
                 temperature=0.2,
                 max_tokens=2500
             )
             return response.choices[0].message.content
         except Exception as e:
-            st.error(f"Slide generation error: {e}")
+            st.error(f"Slide generation error: {str(e)}")
             return self._mock_slides(content)
-
+    
     def _mock_slides(self, content):
         return f"""---
 marp: true
@@ -201,34 +221,41 @@ backgroundImage: url('https://marp.app/assets/hero-background.svg')
 1. Craft effective prompts for different scenarios
 2. Optimize prompts for specific AI models
 3. Analyze and refine prompt performance
+
 """
 
 class CodeAgent:
     def generate_code(self, content):
         if not openai_client:
             return self._mock_code(content)
+            
         try:
             response = openai_client.chat.completions.create(
                 model="gpt-4-turbo",
                 messages=[
-                    {"role": "system", "content": "You create practical code labs for technical workshops."},
-                    {"role": "user", "content": (
-                        f"Create a Jupyter notebook with code exercises for this workshop: {json.dumps(content)}. "
-                        "Include: setup instructions, practical exercises with solutions, "
-                        "and real-world implementation examples. Use Python with popular AI libraries."
-                    )}
+                    {
+                        "role": "system",
+                        "content": "You create practical code labs for technical workshops."
+                    },
+                    {
+                        "role": "user",
+                        "content": (
+                            f"Create a Jupyter notebook with code exercises for this workshop: {json.dumps(content)}. "
+                            "Include: setup instructions, practical exercises with solutions, "
+                            "and real-world implementation examples. Use Python with popular AI libraries."
+                        )
+                    }
                 ],
                 temperature=0.3,
                 max_tokens=2000
             )
             return response.choices[0].message.content
         except Exception as e:
-            st.error(f"Code generation error: {e}")
+            st.error(f"Code generation error: {str(e)}")
             return self._mock_code(content)
-
+    
     def _mock_code(self, content):
-        return f"""
-# {content['workshop_title']} - Code Labs
+        return f"""# {content['workshop_title']} - Code Labs
 
 import openai
 import pandas as pd
@@ -237,10 +264,11 @@ import pandas as pd
 def generate_response(prompt):
     response = openai.chat.completions.create(
         model="gpt-4",
-        messages=[{"role": "user", "content": prompt}]
+        messages=[{{"role": "user", "content": prompt}}]
     )
     return response.choices[0].message.content
 
+# Test your function
 print(generate_response("Explain quantum computing in simple terms"))
 
 ## Exercise 2: Advanced Prompt Patterns
@@ -255,6 +283,7 @@ class DesignAgent:
     def generate_design(self, slide_content):
         if not openai_client:
             return None
+            
         try:
             response = openai_client.images.generate(
                 prompt=f"Create a professional slide background for a corporate AI workshop about: {slide_content[:500]}",
@@ -263,45 +292,65 @@ class DesignAgent:
             )
             return response.data[0].url
         except Exception as e:
-            st.error(f"Design generation error: {e}")
+            st.error(f"Design generation error: {str(e)}")
             return None
 
 class VoiceoverAgent:
     def __init__(self):
-        self.client = eleven_client
-        self.default_voice_id = "9BWtsMINqrJLrRacOk9x"  # Default fallback voice
-        self.model_id = "eleven_monolingual_v1"
-
-    def get_voices(self):
-        if not self.client:
-            return []
-        try:
-            voices = self.client.voices.list()
-            return [{"voice_id": v.voice_id, "name": v.name} for v in voices]
-        except Exception as e:
-            st.error(f"Voice loading error: {e}")
-            return []
-
+        self.api_key = ELEVENLABS_API_KEY
+        self.voice_id = "9BWtsMINqrJLrRacOk9x"  # Default voice ID
+        self.model = "eleven_monolingual_v1"
+        
     def generate_voiceover(self, text, voice_id=None):
-        if not self.client:
+        if not self.api_key:
             return None
+            
         try:
-            vid = voice_id or self.default_voice_id
-            audio = self.client.text_to_speech.convert(
-                text=text,
-                voice_id=vid,
-                model_id=self.model_id,
-                voice_settings={
+            # Use custom voice if provided, otherwise use default
+            voice = voice_id if voice_id else self.voice_id
+            
+            url = f"https://api.elevenlabs.io/v1/text-to-speech/{voice}"
+            headers = {
+                "Accept": "audio/mpeg",
+                "Content-Type": "application/json",
+                "xi-api-key": self.api_key
+            }
+            data = {
+                "text": text,
+                "model_id": self.model,
+                "voice_settings": {
                     "stability": 0.7,
                     "similarity_boost": 0.8,
                     "style": 0.5,
                     "use_speaker_boost": True
                 }
-            )
-            return audio
+            }
+            response = requests.post(url, json=data, headers=headers)
+            
+            if response.status_code == 200:
+                return response.content
+            else:
+                st.error(f"Voiceover API error: {response.status_code} - {response.text}")
+                return None
         except Exception as e:
-            st.error(f"Voiceover generation error: {e}")
+            st.error(f"Voiceover generation error: {str(e)}")
             return None
+    
+    def get_voices(self):
+        if not self.api_key:
+            return []
+            
+        try:
+            url = "https://api.elevenlabs.io/v1/voices"
+            headers = {"xi-api-key": self.api_key}
+            response = requests.get(url, headers=headers)
+            
+            if response.status_code == 200:
+                return response.json().get("voices", [])
+            return []
+        except Exception as e:
+            st.error(f"Voice loading error: {str(e)}")
+            return []
 
 # Initialize agents
 topic_agent = TopicAgent()
@@ -321,13 +370,14 @@ st.set_page_config(
     initial_sidebar_state="expanded"
 )
 
-# Custom CSS
+# Custom CSS with fixed input styling
 st.markdown("""
 <style>
     .stApp {
         background: linear-gradient(135deg, #6a11cb 0%, #2575fc 100%);
         color: #fff;
     }
+    /* Fix for input text color */
     .stTextInput>div>div>input {
         color: #333 !important;
         background-color: #fff !important;
@@ -363,4 +413,275 @@ st.markdown("""
         display: flex;
         align-items: center;
         margin: 5px 0;
-        padding
+        padding: 8px;
+        border-radius: 8px;
+        cursor: pointer;
+        transition: background 0.3s;
+    }
+    .voice-option:hover {
+        background: rgba(255,255,255,0.2);
+    }
+    .voice-option.selected {
+        background: rgba(0,180,155,0.3);
+        border: 2px solid #00b09b;
+    }
+    .voice-thumb {
+        width: 40px;
+        height: 40px;
+        border-radius: 50%;
+        margin-right: 10px;
+        object-fit: cover;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+# Header
+col1, col2 = st.columns([1, 3])
+with col1:
+    st.image("https://cdn-icons-png.flaticon.com/512/1995/1995485.png", width=100)
+with col2:
+    st.title("🤖 Workshop in a Box Pro")
+    st.caption("Generate Premium Corporate AI Training Workshops with Voiceovers")
+
+# Initialize session state
+if 'workshop_topic' not in st.session_state:
+    st.session_state.workshop_topic = "Advanced Prompt Engineering"
+if 'generated' not in st.session_state:
+    st.session_state.generated = False
+if 'generating' not in st.session_state:
+    st.session_state.generating = False
+if 'voiceovers' not in st.session_state:
+    st.session_state.voiceovers = {}
+if 'selected_voice' not in st.session_state:
+    st.session_state.selected_voice = "21m00Tcm4TlvDq8ikWAM"  # Default voice ID
+
+# Sidebar configuration
+with st.sidebar:
+    st.header("⚙️ Workshop Configuration")
+    
+    # Workshop topic input with session state
+    st.session_state.workshop_topic = st.text_input(
+        "Workshop Topic", 
+        st.session_state.workshop_topic,
+        key="topic_input",
+        help="Enter the main topic for your workshop"
+    )
+    
+    # Validate topic input
+    if st.session_state.workshop_topic.strip() == "":
+        st.warning("Please enter a workshop topic")
+        st.stop()
+    
+    duration = st.slider("Duration (hours)", 1.0, 8.0, 3.0, 0.5)
+    difficulty = st.selectbox("Difficulty Level", 
+                            ["Beginner", "Intermediate", "Advanced", "Expert"])
+    include_code = st.checkbox("Include Code Labs", True)
+    include_design = st.checkbox("Generate Visual Designs", True)
+    include_voiceover = st.checkbox("Generate Voiceovers", True)
+    
+    # Voice selection
+    if include_voiceover:
+        st.subheader("🎙️ Voice Selection")
+        
+        # Get available voices
+        voices = voiceover_agent.get_voices()
+        
+        # If we have voices, let the user select one
+        if voices:
+            # Create 2 columns for voice selection
+            cols = st.columns(2)
+            for i, voice in enumerate(voices[:4]):  # Show first 4 voices
+                with cols[i % 2]:
+                    # Create a unique key for each voice button
+                    voice_key = f"voice_{voice['voice_id']}"
+                    
+                    # Display voice option
+                    if st.button(
+                        f"🗣️ {voice['name']}",
+                        key=voice_key,
+                        use_container_width=True,
+                        help=f"Select {voice['name']} voice"
+                    ):
+                        st.session_state.selected_voice = voice['voice_id']
+            
+            # Show which voice is currently selected
+            selected_voice_name = next((v['name'] for v in voices if v['voice_id'] == st.session_state.selected_voice), "Default")
+            st.info(f"Selected Voice: **{selected_voice_name}**")
+        else:
+            if ELEVENLABS_API_KEY:
+                st.warning("Couldn't load voices. Using default voice.")
+            else:
+                st.warning("ElevenLabs API key not set. Voiceovers disabled.")
+    
+    if st.button("✨ Generate Workshop", type="primary", use_container_width=True):
+        st.session_state.generating = True
+        st.session_state.voiceovers = {}  # Reset previous voiceovers
+
+# Generation pipeline
+if st.session_state.generating:
+    with st.spinner(f"🚀 Creating your {st.session_state.workshop_topic} workshop..."):
+        start_time = time.time()
+        
+        # Agent pipeline
+        outline = topic_agent.generate_outline(st.session_state.workshop_topic, duration, difficulty)
+        content = content_agent.generate_content(outline)
+        slides = slide_agent.generate_slides(content)
+        code_labs = code_agent.generate_code(content) if include_code else None
+        design_url = design_agent.generate_design(slides) if include_design else None
+        
+        # Generate voiceovers if enabled
+        voiceovers = {}
+        if include_voiceover and ELEVENLABS_API_KEY:
+            for i, module in enumerate(content.get("modules", [])):
+                # Create a short intro for each module
+                intro_text = f"Welcome to Module {i+1}: {module['title']}. " + \
+                             f"In this module, we'll cover: {', '.join(module.get('speaker_notes', []))[:300]}"
+                
+                # Generate voiceover
+                audio_data = voiceover_agent.generate_voiceover(
+                    intro_text,
+                    st.session_state.selected_voice
+                )
+                
+                if audio_data:
+                    voiceovers[f"module_{i+1}_intro.mp3"] = audio_data
+        
+        # Prepare download package
+        zip_buffer = io.BytesIO()
+        with zipfile.ZipFile(zip_buffer, "a") as zip_file:
+            zip_file.writestr("outline.json", json.dumps(outline, indent=2))
+            zip_file.writestr("content.json", json.dumps(content, indent=2))
+            zip_file.writestr("slides.md", slides)
+            if code_labs:
+                zip_file.writestr("code_labs.ipynb", code_labs)
+            if design_url:
+                try:
+                    img_data = requests.get(design_url).content
+                    zip_file.writestr("slide_design.png", img_data)
+                except:
+                    pass
+            # Add voiceovers to ZIP
+            for filename, audio_data in voiceovers.items():
+                zip_file.writestr(f"voiceovers/{filename}", audio_data)
+        
+        # Store results
+        st.session_state.outline = outline
+        st.session_state.content = content
+        st.session_state.slides = slides
+        st.session_state.code_labs = code_labs
+        st.session_state.design_url = design_url
+        st.session_state.voiceovers = voiceovers
+        st.session_state.zip_buffer = zip_buffer
+        st.session_state.gen_time = round(time.time() - start_time, 2)
+        st.session_state.generated = True
+        st.session_state.generating = False
+
+# Results display
+if st.session_state.generated:
+    st.success(f"✅ {st.session_state.workshop_topic} workshop generated in {st.session_state.gen_time} seconds!")
+    
+    # Download button
+    st.download_button(
+        label="📥 Download Workshop Package",
+        data=st.session_state.zip_buffer.getvalue(),
+        file_name=f"{st.session_state.workshop_topic.replace(' ', '_')}_workshop.zip",
+        mime="application/zip",
+        use_container_width=True
+    )
+    
+    # Preview sections
+    with st.expander("📝 Workshop Outline", expanded=True):
+        st.json(st.session_state.outline)
+    
+    with st.expander("📄 Content Script"):
+        st.write(st.session_state.content)
+    
+    with st.expander("🖥️ Slide Deck Preview"):
+        st.markdown("```markdown\n" + textwrap.dedent(st.session_state.slides[:2000]) + "\n```")
+    
+    if st.session_state.code_labs:
+        with st.expander("💻 Code Labs"):
+            st.code(st.session_state.code_labs)
+    
+    if st.session_state.design_url:
+        with st.expander("🎨 Generated Design"):
+            st.image(st.session_state.design_url, caption="Custom Slide Design")
+    
+    # Voiceover player
+    if st.session_state.voiceovers:
+        with st.expander("🔊 Voiceover Previews"):
+            for i, (filename, audio_bytes) in enumerate(st.session_state.voiceovers.items()):
+                module_num = filename.split("_")[1]
+                st.subheader(f"Module {module_num} Introduction")
+                
+                # Create an audio player for each voiceover
+                st.audio(audio_bytes, format="audio/mp3")
+                
+                # Add download button for individual voiceover
+                st.download_button(
+                    label=f"Download Module {module_num} Voiceover",
+                    data=audio_bytes,
+                    file_name=filename,
+                    mime="audio/mpeg",
+                    key=f"voiceover_dl_{i}"
+                )
+    elif include_voiceover and ELEVENLABS_API_KEY:
+        st.warning("Voiceovers not generated. Check your ElevenLabs API key.")
+
+# Sales and booking section
+st.divider()
+st.subheader("🚀 Ready to Deliver This Workshop?")
+st.markdown(f"""
+### Premium {st.session_state.workshop_topic} Training Package
+- **Live Workshop Delivery**: $10,000 per session
+- **On-Demand Course**: $5,000 (unlimited access)
+- **Pilot Program**: $1,000 refundable deposit
+- **Voiceover Add-on**: $500 per module
+
+✨ **All inclusive**: Customization, materials, and follow-up support
+""")
+
+col1, col2 = st.columns(2)
+with col1:
+    st.link_button("📅 Book a Live Workshop", "https://calendly.com/your-link", 
+                  use_container_width=True)
+with col2:
+    st.link_button("💳 Purchase On-Demand Course", "https://your-store.com", 
+                  use_container_width=True)
+
+# Debug info
+with st.sidebar:
+    st.divider()
+    if openai_client:
+        st.success("OpenAI API Connected")
+    else:
+        st.warning("OpenAI API not set - using enhanced mock data")
+    
+    if ELEVENLABS_API_KEY:
+        st.success("ElevenLabs API Key Found")
+    elif include_voiceover:
+        st.warning("ElevenLabs API key not set")
+    
+    st.info(f"""
+    **Current Workshop:**
+    {st.session_state.workshop_topic}
+    
+    **Premium Features:**
+    - AI-generated voiceovers
+    - Professional slide designs
+    - Real-world case studies
+    - Practical code labs
+    """)
+
+# How it works section
+st.divider()
+st.subheader("💡 How It Works")
+st.markdown("""
+1. **Configure** your workshop topic and parameters
+2. **Generate** premium training materials with voiceovers
+3. **Customize** the content to your specific needs
+4. **Deliver** high-value corporate training at $10K/session
+5. **Reuse** the materials for unlimited revenue
+
+*"The voiceover feature helped me create on-demand courses that sold for $5K each"* - Michael L., AI Consultant
+""")