Create app.py

app.py

@@ -0,0 +1,521 @@
+import streamlit as st
+import anthropic
+import requests
+import base64
+import json
+import time
+import os
+from typing import Dict, List, Any
+import fal_client
+from dotenv import load_dotenv
+from IPython.display import Image as IPImage, display
+
+# Page config
+st.set_page_config(
+    page_title="Interactive Course Preview Generator",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Custom CSS for modern, minimalist design
+st.markdown("""
+    <style>
+    .main {background-color: #f8f9fa;}
+    .stButton>button {
+        background-color: #4c6ef5;
+        color: white;
+        border-radius: 4px;
+        border: none;
+        padding: 0.5rem 1rem;
+    }
+    .content-box {
+        background-color: white;
+        padding: 1.5rem;
+        border-radius: 8px;
+        box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+        margin: 1rem 0;
+    }
+    .section-title {
+        color: #4c6ef5;
+        font-size: 1.2rem;
+        font-weight: bold;
+        margin-bottom: 1rem;
+    }
+    </style>
+    """, unsafe_allow_html=True)
+
+st.markdown("""
+    <style>
+    .main {background-color: #f8f9fa;}
+    .subtitle {
+        color: #6c757d;
+        font-size: 0.9rem;
+        font-style: italic;
+        margin-top: 0.5rem;
+    }
+    .preview-content {
+        background-color: #f8f9fa;
+        padding: 1rem;
+        border-left: 3px solid #4c6ef5;
+        margin: 1rem 0;
+    }
+    .script-content {
+        background-color: #e9ecef;
+        padding: 1rem;
+        border-radius: 4px;
+        margin: 1rem 0;
+    }
+    </style>
+""", unsafe_allow_html=True)
+
+# Templates for content generation
+COURSE_TEMPLATE = """Create a concise course outline for:
+Topic: {topic}
+Level: {level}
+Duration: {duration}
+
+Include:
+1. Brief course description (2-3 sentences)
+2. 4-5 main sections
+3. For each section:
+   - Title
+   - Brief description (1 sentence)
+   - 2-3 key concepts
+
+Format it clearly and professionally."""
+
+PREVIEW_TEMPLATE = """Create content for two brief preview slides about the concept: {concept}
+For each slide include EXACTLY in this order:
+1. Slide Title
+2. Content (3 brief bullet points maximum)
+3. Teacher Script (2-3 sentences maximum)
+4. Image Description (one sentence describing a minimalist visual)
+
+Format each slide clearly with these exact headers:
+"Slide 1:", "Content:", "Teacher Script:", "Image Description:"
+"Slide 2:", "Content:", "Teacher Script:", "Image Description:"
+"""
+
+INSTRUCTOR_INTRO_TEMPLATE = """Create a very brief welcome message (2 sentences maximum) for:
+Instructor: {name}
+Course: {topic}
+Style: {style}
+
+Keep it natural and concise."""
+
+# API Integration Functions
+def generate_image(description: str) -> str:
+    """Generate image using verified Fal.ai implementation with proper waiting"""
+    try:
+        with st.spinner(f"Generating image for: {description}"):
+            handler = fal_client.submit(
+                "fal-ai/flux-pro/v1.1-ultra",
+                arguments={
+                    "prompt": f"Professional minimalist educational visual: {description}",
+                    "num_images": 1
+                }
+            )
+            
+            # Extended wait time with status check
+            for _ in range(30):  # Maximum 30 seconds wait
+                time.sleep(1)
+                result = fal_client.result("fal-ai/flux-pro/v1.1-ultra", handler.request_id)
+                if result and "images" in result and result["images"]:
+                    return result["images"][0]["url"]
+            return None
+    except Exception as e:
+        st.error(f"Image generation error: {e}")
+        return None
+
+def generate_and_get_image(prompt: str) -> str:
+    """Generate and get image using verified Fal.ai implementation"""
+    try:
+        with st.spinner(f"Generating image..."):
+            # Submit request
+            handler = fal_client.submit(
+                "fal-ai/flux-pro/v1.1-ultra",
+                arguments={"prompt": prompt, "num_images": 1}
+            )
+            request_id = handler.request_id
+            
+            if request_id:
+                time.sleep(10)  # Wait for generation
+                # Get result
+                result = fal_client.result("fal-ai/flux-pro/v1.1-ultra", request_id)
+                if result and "images" in result and result["images"]:
+                    return result["images"][0]["url"]
+    except Exception as e:
+        st.error(f"Image generation error: {e}")
+    return None
+    
+def create_voice_preview(text: str, voice_description: str) -> bytes:
+    """Create voice preview using verified ElevenLabs implementation"""
+    url = "https://api.elevenlabs.io/v1/text-to-voice/create-previews"
+    headers = {
+        'xi-api-key': st.secrets["ELEVENLABS_API_KEY"],
+        'Content-Type': 'application/json'
+    }
+    payload = {
+        'voice_description': voice_description,
+        'text': text
+    }
+    
+    try:
+        response = requests.post(url, headers=headers, json=payload)
+        if response.status_code == 200:
+            return base64.b64decode(response.json()['previews'][0]['audio_base_64'])
+        return None
+    except Exception as e:
+        st.error(f"Voice generation error: {e}")
+        return None
+
+def generate_content(topic: str, level: str, duration: str, 
+                    instructor_name: str, teaching_style: str) -> Dict:
+    """Generate course content using Claude 3.5"""
+    client = anthropic.Anthropic(api_key=st.secrets["ANTHROPIC_API_KEY"])
+    
+    try:
+        # Generate course outline
+        outline_response = client.messages.create(
+            model="claude-3-5-sonnet-latest",
+            max_tokens=4096,
+            messages=[
+                {
+                    "role": "user",
+                    "content": COURSE_TEMPLATE.format(
+                        topic=topic,
+                        level=level,
+                        duration=duration
+                    )
+                }
+            ]
+        )
+        
+        course_content = outline_response.content[0].text
+        
+        # Parse content to get a concept for preview
+        sections = parse_course_content(course_content)
+        preview_concept = sections[0]['concepts'][0] if sections and sections[0].get('concepts') else topic
+        
+        # Generate preview content
+        preview_response = client.messages.create(
+            model="claude-3-5-sonnet-latest",
+            max_tokens=4096,
+            messages=[
+                {
+                    "role": "user",
+                    "content": PREVIEW_TEMPLATE.format(concept=preview_concept)
+                }
+            ]
+        )
+        
+        # Generate instructor introduction
+        intro_response = client.messages.create(
+            model="claude-3-5-sonnet-latest",
+            max_tokens=4096,
+            messages=[
+                {
+                    "role": "user",
+                    "content": INSTRUCTOR_INTRO_TEMPLATE.format(
+                        name=instructor_name,
+                        style=teaching_style,
+                        topic=topic
+                    )
+                }
+            ]
+        )
+        
+        return {
+            "status": "success",
+            "course_outline": course_content,
+            "preview_content": preview_response.content[0].text,
+            "instructor_intro": intro_response.content[0].text,
+            "sections": sections
+        }
+    except Exception as e:
+        return {"status": "error", "message": str(e)}
+
+def parse_outline(content: str) -> List[Dict]:
+    """Parse course outline to get sections and concepts"""
+    sections = []
+    current_section = None
+    
+    for line in content.split('\n'):
+        line = line.strip()
+        if not line:
+            continue
+        
+        if line.lower().startswith(('section', 'part', 'module')):
+            if current_section:
+                sections.append(current_section)
+            current_section = {
+                'title': line,
+                'description': '',
+                'concepts': []
+            }
+        elif current_section:
+            if not current_section['description']:
+                current_section['description'] = line
+            elif line.startswith(('-', '•', '*')):
+                current_section['concepts'].append(line.lstrip('-•* '))
+    
+    if current_section:
+        sections.append(current_section)
+    
+    return sections
+    
+def parse_course_content(content: str) -> List[Dict]:
+    """Parse course content into structured format"""
+    sections = []
+    current_section = None
+    
+    for line in content.split('\n'):
+        line = line.strip()
+        if not line:
+            continue
+        
+        if line.lower().startswith(('section', 'part', 'module')):
+            if current_section:
+                sections.append(current_section)
+            current_section = {
+                'title': line,
+                'description': '',
+                'concepts': []
+            }
+        elif current_section:
+            if not current_section['description']:
+                current_section['description'] = line
+            elif line.startswith(('-', '•', '*')):
+                current_section['concepts'].append(line.lstrip('-•* '))
+    
+    if current_section:
+        sections.append(current_section)
+    
+    return sections
+
+def generate_course_outline(topic: str, level: str, duration: str) -> Dict:
+    """Generate initial course outline and get first concept"""
+    client = anthropic.Anthropic(api_key=st.secrets["ANTHROPIC_API_KEY"])
+    
+    prompt = f"""Create a course outline for:
+Topic: {topic}
+Level: {level}
+Duration: {duration}
+
+Include:
+1. Brief course description (2-3 sentences)
+2. 4-5 main sections with:
+   - Clear title
+   - 2-3 key concepts per section
+   - Brief description
+
+Format clearly with sections and concepts."""
+
+    try:
+        response = client.messages.create(
+            model="claude-3-5-sonnet-latest",
+            max_tokens=4096,
+            messages=[{"role": "user", "content": prompt}]
+        )
+        
+        outline = response.content[0].text
+        # Parse to get first concept
+        sections = parse_outline(outline)
+        first_concept = sections[0]['concepts'][0] if sections and sections[0].get('concepts') else topic
+        
+        return {
+            "status": "success",
+            "outline": outline,
+            "sections": sections,
+            "first_concept": first_concept
+        }
+    except Exception as e:
+        return {"status": "error", "message": str(e)}
+
+def generate_preview_content(topic: str, concept: str) -> str:
+    """Generate preview content using Claude"""
+    client = anthropic.Anthropic(api_key=st.secrets["ANTHROPIC_API_KEY"])
+    
+    prompt = f"""Create TWO preview slides about {concept} for a course on {topic}.
+    
+For EACH slide, provide EXACTLY in this format:
+SLIDE [number]:
+- Title: [slide title]
+- Content: [3 clear bullet points]
+- Teaching Script: [2-3 sentences explaining the slide content]
+- Visual Description: [clear description for image generation]
+
+Keep all content clear and concise."""
+
+    try:
+        response = client.messages.create(
+            model="claude-3-5-sonnet-latest",
+            max_tokens=4096,
+            messages=[{"role": "user", "content": prompt}]
+        )
+        return response.content[0].text
+    except Exception as e:
+        st.error(f"Content generation error: {e}")
+        return None
+
+def parse_preview_content(content: str) -> List[Dict]:
+    """Parse preview content into structured format"""
+    slides = []
+    current_slide = None
+    
+    for line in content.split('\n'):
+        line = line.strip()
+        if not line:
+            continue
+            
+        if line.startswith('SLIDE'):
+            if current_slide:
+                slides.append(current_slide)
+            current_slide = {
+                'title': '',
+                'content': [],
+                'script': '',
+                'visual': ''
+            }
+        elif current_slide:
+            if line.startswith('- Title:'):
+                current_slide['title'] = line.replace('- Title:', '').strip()
+            elif line.startswith('- Content:'):
+                # Next lines will be content until next section
+                continue
+            elif line.startswith('- Teaching Script:'):
+                current_slide['script'] = line.replace('- Teaching Script:', '').strip()
+            elif line.startswith('- Visual Description:'):
+                current_slide['visual'] = line.replace('- Visual Description:', '').strip()
+            elif line.startswith('-') or line.startswith('•'):
+                current_slide['content'].append(line.lstrip('-• ').strip())
+    
+    if current_slide:
+        slides.append(current_slide)
+    
+    return slides
+
+def display_preview_content(preview_slides: List[Dict]):
+    """Display preview content with proper styling"""
+    for i, slide in enumerate(preview_slides, 1):
+        st.markdown(f"### Preview Slide {i}")
+        
+        # Content section
+        st.markdown('<div class="preview-content">', unsafe_allow_html=True)
+        for point in slide['content']:
+            st.markdown(f"• {point}")
+        st.markdown('</div>', unsafe_allow_html=True)
+        
+        # Script section
+        st.markdown('<div class="script-content">', unsafe_allow_html=True)
+        st.markdown("**Teaching Script:**")
+        st.markdown(slide['script'])
+        st.markdown('</div>', unsafe_allow_html=True)
+        
+        # Generate and display image
+        if slide['image_description']:
+            image_url = generate_image(slide['image_description'])
+            if image_url:
+                st.image(image_url, use_column_width=True)
+
+
+    
+
+
+def display_preview_slides(slides: List[Dict]):
+    """Display preview slides with proper styling"""
+    for i, slide in enumerate(slides, 1):
+        st.markdown(f"### {slide['title']}")
+        
+        col1, col2 = st.columns([2, 1])
+        
+        with col1:
+            # Content
+            st.markdown('<div class="preview-content">', unsafe_allow_html=True)
+            for point in slide['content']:
+                st.markdown(f"• {point}")
+            st.markdown('</div>', unsafe_allow_html=True)
+            
+            # Teaching Script
+            st.markdown('<div class="script-content">', unsafe_allow_html=True)
+            st.markdown("**Teaching Script:**")
+            st.markdown(slide['script'])
+            st.markdown('</div>', unsafe_allow_html=True)
+        
+        with col2:
+            # Generate and display image
+            if slide['visual']:
+                image_url = generate_and_get_image(slide['visual'])
+                if image_url:
+                    st.image(image_url, use_column_width=True)
+
+def main():
+    st.title("Interactive Course Preview Generator")
+    st.markdown("Generate professional course previews with content, visuals, and voice narration")
+
+    # Input Section
+    with st.container():
+        st.markdown('<div class="section-title">Course Configuration</div>', unsafe_allow_html=True)
+        
+        col1, col2 = st.columns(2)
+        with col1:
+            topic = st.text_input("Course Topic", 
+                placeholder="e.g., Machine Learning Fundamentals")
+            level = st.selectbox("Course Level", 
+                ["Beginner", "Intermediate", "Advanced"])
+            duration = st.selectbox("Course Duration",
+                ["2 Hours", "4 Hours", "8 Hours", "Full Day"])
+
+        with col2:
+            instructor_name = st.text_input("Instructor Name",
+                placeholder="e.g., Dr. Sarah Johnson")
+            teaching_style = st.selectbox("Teaching Style",
+                ["Interactive", "Lecture-Based", "Project-Based", "Discussion-Led"])
+            instructor_gender = st.selectbox("Instructor Voice",
+                ["Male", "Female"])
+
+    if st.button("Generate Preview", type="primary"):
+        with st.spinner("Creating your course preview..."):
+            try:
+                # Step 1: Generate course outline and get first concept
+                outline_result = generate_course_outline(topic, level, duration)
+                if outline_result["status"] != "success":
+                    st.error(f"Error generating outline: {outline_result.get('message')}")
+                    return
+                
+                # Step 2: Generate instructor introduction
+                intro_audio = create_voice_preview(
+                    f"Hello! I'm {instructor_name}, and I'll be your instructor for {topic}. Let's explore this exciting subject together!",
+                    f"Professional {instructor_gender.lower()} instructor, {teaching_style.lower()} style"
+                )
+                
+                # Step 3: Generate preview content using first concept
+                preview_content = generate_preview_content(topic, outline_result["first_concept"])
+                if not preview_content:
+                    st.error("Failed to generate preview content")
+                    return
+                
+                # Step 4: Parse and display content
+                slides = parse_preview_content(preview_content)
+                
+                # Display results
+                
+                # Course Outline
+                st.markdown("## Course Overview")
+                st.markdown(outline_result["outline"])
+                
+                # Instructor Introduction
+                st.markdown("## Instructor Introduction")
+                if intro_audio:
+                    st.audio(intro_audio)
+                
+                # Preview Slides
+                st.markdown("## Preview Slides")
+                display_preview_slides(slides)
+                
+            except Exception as e:
+                st.error(f"An error occurred: {str(e)}")
+                return
+
+if __name__ == "__main__":
+    main()