Spaces:
Runtime error
Runtime error
| import streamlit as st | |
| import base64 | |
| from io import BytesIO | |
| import json | |
| import time | |
| import os | |
| from utils import create_slide_preview, TEMPLATES, generate_slide_content | |
| from enhanced_pptx import enhanced_create_ppt | |
| from slide_editor_enhancements import render_enhanced_slide_editor | |
| from multi_llm_provider import get_ai_manager | |
| from visual_elements import search_stock_images, download_image, analyze_slide_for_visuals | |
| # Check for API keys | |
| api_key = os.getenv("ANTHROPIC_API_KEY") | |
| openai_key = os.getenv("OPENAI_API_KEY") | |
| deepseek_key = os.getenv("DEEPSEEK_API_KEY") | |
| perplexity_key = os.getenv("PERPLEXITY_API_KEY") | |
| pexels_key = os.getenv("PEXELS_API_KEY") | |
| def nav_button(label, stage, icon=None, primary=False): | |
| """Create a navigation button with improved styling""" | |
| button_style = "primary" if primary else "secondary" | |
| icon_text = f"{icon} " if icon else "" | |
| if st.button(f"{icon_text}{label}", key=f"nav_{stage}", type=button_style, use_container_width=True): | |
| st.session_state.current_stage = stage | |
| st.rerun() | |
| def display_navigation_bar(): | |
| """Display navigation bar at the top of the page""" | |
| stages = [ | |
| {"name": "ideation", "label": "Ideation", "icon": "💡"}, | |
| {"name": "storyboard", "label": "Storyboard", "icon": "📋"}, | |
| {"name": "template", "label": "Template", "icon": "🎨"}, | |
| {"name": "slides", "label": "Edit Slides", "icon": "🖼️"}, | |
| {"name": "export", "label": "Export", "icon": "📤"} | |
| ] | |
| cols = st.columns(len(stages)) | |
| for i, stage in enumerate(stages): | |
| with cols[i]: | |
| is_current = st.session_state.current_stage == stage["name"] | |
| # Create a clickable button with custom CSS | |
| if st.button( | |
| f"{stage['icon']} {stage['label']}", | |
| key=f"nav_top_{stage['name']}", | |
| disabled=is_current, | |
| use_container_width=True, | |
| type="primary" if is_current else "secondary" | |
| ): | |
| # If we've already completed previous stages, allow direct navigation | |
| if stage["name"] in ["ideation"] or ( | |
| stage["name"] == "storyboard" and st.session_state.storyboard | |
| ) or ( | |
| stage["name"] == "template" and st.session_state.storyboard | |
| ) or ( | |
| stage["name"] == "slides" and st.session_state.slides_content | |
| ) or ( | |
| stage["name"] == "export" and st.session_state.slides_content | |
| ): | |
| st.session_state.current_stage = stage["name"] | |
| st.rerun() | |
| else: | |
| st.warning(f"Please complete the previous stages before going to {stage['label']}") | |
| # Progress bar | |
| stages_order = ["ideation", "storyboard", "template", "slides", "export"] | |
| current_idx = stages_order.index(st.session_state.current_stage) | |
| progress = current_idx / (len(stages_order) - 1) | |
| st.progress(progress) | |
| def render_ai_settings(): | |
| """Render AI settings sidebar section""" | |
| st.sidebar.write("## 🧠 AI Settings") | |
| # Get AI manager | |
| ai_manager = get_ai_manager() | |
| available_models = ai_manager.get_available_models() | |
| if not available_models: | |
| st.sidebar.warning("No AI providers configured. Add API keys in secrets.") | |
| default_model = "claude-3-sonnet-20250219" | |
| else: | |
| default_model = list(available_models.keys())[0] if available_models else "claude-3-sonnet-20250219" | |
| # Select default model for the whole presentation | |
| selected_model = st.sidebar.selectbox( | |
| "Default AI Model", | |
| options=list(available_models.keys()), | |
| format_func=lambda x: available_models.get(x, x), | |
| index=0 if default_model in available_models else 0 | |
| ) | |
| st.session_state.default_model = selected_model | |
| # Temperature setting | |
| temperature = st.sidebar.slider( | |
| "AI Creativity", | |
| min_value=0.0, | |
| max_value=1.0, | |
| value=0.7, | |
| step=0.1, | |
| help="Higher values make output more creative but less predictable" | |
| ) | |
| st.session_state.ai_temperature = temperature | |
| # Web search integration | |
| enable_search = st.sidebar.checkbox( | |
| "Enable Web Search", | |
| value=st.session_state.get("enable_web_search", False), | |
| help="Use Perplexity to search for up-to-date information", | |
| disabled=not perplexity_key | |
| ) | |
| st.session_state.enable_web_search = enable_search | |
| if enable_search and not perplexity_key: | |
| st.sidebar.warning("Perplexity API key required for web search") | |
| # Stock image settings | |
| st.sidebar.write("## 🖼️ Image Settings") | |
| if not pexels_key: | |
| st.sidebar.warning("Pexels API key required for better stock images") | |
| # Test different AI providers | |
| if st.sidebar.button("Test AI Providers"): | |
| with st.sidebar: | |
| st.write("Testing AI providers...") | |
| for model in list(available_models.keys())[:2]: # Test first two models | |
| try: | |
| with st.spinner(f"Testing {model}..."): | |
| response = ai_manager.generate_text( | |
| "Write a one-sentence test response.", | |
| model=model, | |
| max_tokens=50 | |
| ) | |
| st.success(f"{model}: {response}") | |
| except Exception as e: | |
| st.error(f"{model}: Error - {str(e)}") | |
| def render_ideation_stage(): | |
| """Render the ideation stage UI""" | |
| display_navigation_bar() | |
| # Add AI settings sidebar | |
| render_ai_settings() | |
| st.header("💡 Step 1: Presentation Ideation") | |
| st.write("Let's start by defining the purpose and scope of your presentation.") | |
| col1, col2 = st.columns(2) | |
| with col1: | |
| st.session_state.presentation_title = st.text_input( | |
| "Presentation Title", | |
| value=st.session_state.presentation_title | |
| ) | |
| st.session_state.presentation_purpose = st.text_area( | |
| "What's the purpose of this presentation?", | |
| value=st.session_state.presentation_purpose, | |
| help="E.g., Inform, persuade, pitch a product, update stakeholders, etc." | |
| ) | |
| with col2: | |
| st.session_state.target_audience = st.text_area( | |
| "Who is your target audience?", | |
| value=st.session_state.target_audience, | |
| help="E.g., Executives, customers, technical team, general public, etc." | |
| ) | |
| # Add example suggestions | |
| st.write("📚 **Example presentations:**") | |
| examples = [ | |
| "Quarterly Business Review", | |
| "Product Launch Presentation", | |
| "Team Project Update", | |
| "Investor Pitch Deck" | |
| ] | |
| # Create two columns for examples | |
| ex_col1, ex_col2 = st.columns(2) | |
| for i, example in enumerate(examples): | |
| with ex_col1 if i % 2 == 0 else ex_col2: | |
| if st.button(f"📄 {example}", key=f"example_{example}"): | |
| st.session_state.presentation_title = example | |
| # Set appropriate purpose and audience based on example | |
| if "Quarterly" in example: | |
| st.session_state.presentation_purpose = "Review business performance for the past quarter and outline goals for the next quarter" | |
| st.session_state.target_audience = "Executives and department heads" | |
| elif "Product" in example: | |
| st.session_state.presentation_purpose = "Introduce a new product to customers and highlight its key features and benefits" | |
| st.session_state.target_audience = "Potential customers and sales team" | |
| elif "Project" in example: | |
| st.session_state.presentation_purpose = "Update team members on project progress, achievements, and next steps" | |
| st.session_state.target_audience = "Project stakeholders and team members" | |
| elif "Investor" in example: | |
| st.session_state.presentation_purpose = "Pitch our business to potential investors to secure funding" | |
| st.session_state.target_audience = "Venture capitalists and angel investors" | |
| st.rerun() | |
| # AI model selection for storyboard generation | |
| st.write("### 🧠 AI Engine Selection") | |
| # Get AI manager | |
| ai_manager = get_ai_manager() | |
| available_models = ai_manager.get_available_models() | |
| cols = st.columns([2, 1]) | |
| with cols[0]: | |
| selected_model = st.selectbox( | |
| "AI Model for Storyboard Generation", | |
| options=list(available_models.keys()), | |
| format_func=lambda x: available_models.get(x, x), | |
| index=0, | |
| key="storyboard_model" | |
| ) | |
| with cols[1]: | |
| web_research = st.checkbox( | |
| "Include Web Research", | |
| value=st.session_state.get("enable_web_search", False), | |
| disabled=not perplexity_key, | |
| help="Search the web for the latest information related to your presentation topic" | |
| ) | |
| # Generate button with loading indicator | |
| st.markdown("---") | |
| if st.button("🐊 Generate Storyboard", type="primary", use_container_width=True): | |
| if not st.session_state.presentation_title or not st.session_state.presentation_purpose: | |
| st.warning("Please provide at least a title and purpose to proceed.") | |
| else: | |
| with st.spinner("🧠 SlideGator.AI is chomping on your presentation ideas..."): | |
| from utils import generate_storyboard | |
| # If web research is enabled, perform a search first | |
| if web_research and perplexity_key: | |
| with st.spinner("🔍 Researching the latest information..."): | |
| search_query = f"latest information about {st.session_state.presentation_title}" | |
| search_results = ai_manager.web_search(search_query) | |
| if search_results: | |
| # Create a research summary | |
| st.success(f"Found {len(search_results)} relevant sources of information!") | |
| # Store in session state | |
| st.session_state.web_research = search_results | |
| else: | |
| st.warning("No research results found. Proceeding without research.") | |
| # Generate storyboard with the selected model | |
| storyboard = generate_storyboard( | |
| st.session_state.presentation_title, | |
| st.session_state.presentation_purpose, | |
| st.session_state.target_audience, | |
| model=selected_model | |
| ) | |
| if storyboard: | |
| st.session_state.storyboard = storyboard | |
| st.session_state.current_stage = "storyboard" | |
| st.success("Storyboard created successfully!") | |
| st.rerun() | |
| def render_storyboard_stage(): | |
| """Render the storyboard review stage UI""" | |
| display_navigation_bar() | |
| st.header("📋 Step 2: Review and Edit Storyboard") | |
| st.write(f"Storyboard for: **{st.session_state.presentation_title}**") | |
| st.write("Expand each slide to edit its content or add notes.") | |
| # Display storyboard for review with edit options | |
| edited_storyboard = [] | |
| # Add a "regenerate" button and AI options | |
| col1, col2, col3 = st.columns([2, 1, 1]) | |
| with col1: | |
| # Get AI manager | |
| ai_manager = get_ai_manager() | |
| available_models = ai_manager.get_available_models() | |
| selected_model = st.selectbox( | |
| "AI Model", | |
| options=list(available_models.keys()), | |
| format_func=lambda x: available_models.get(x, x), | |
| index=0, | |
| key="storyboard_regen_model" | |
| ) | |
| with col2: | |
| if st.button("🔄 Regenerate All", help="Create a new storyboard with current title/purpose"): | |
| from utils import generate_storyboard | |
| with st.spinner("🐊 SlideGator.AI is rethinking your presentation structure..."): | |
| storyboard = generate_storyboard( | |
| st.session_state.presentation_title, | |
| st.session_state.presentation_purpose, | |
| st.session_state.target_audience, | |
| model=selected_model | |
| ) | |
| if storyboard: | |
| st.session_state.storyboard = storyboard | |
| st.success("Storyboard regenerated!") | |
| st.rerun() | |
| with col3: | |
| if st.button("🔍 Analyze Flow", help="Analyze the narrative flow of your presentation"): | |
| with st.spinner("🧠 Analyzing presentation flow..."): | |
| # Convert storyboard to text for analysis | |
| storyboard_text = "" | |
| for i, slide in enumerate(st.session_state.storyboard): | |
| storyboard_text += f"Slide {i+1}: {slide.get('title', 'Untitled')}\n" | |
| storyboard_text += f"Purpose: {slide.get('purpose', '')}\n" | |
| key_points = slide.get('key_points', []) | |
| if isinstance(key_points, list): | |
| for point in key_points: | |
| storyboard_text += f"- {point}\n" | |
| else: | |
| storyboard_text += f"- {key_points}\n" | |
| storyboard_text += "\n" | |
| # Analyze the flow | |
| prompt = f""" | |
| You are an expert presentation designer. | |
| Please analyze the flow and structure of this presentation storyboard: | |
| {storyboard_text} | |
| Provide feedback on: | |
| 1. The narrative flow and logical progression | |
| 2. Any gaps in the content | |
| 3. Balance of information across slides | |
| 4. Suggestions for improvement | |
| Be constructive and specific. | |
| """ | |
| try: | |
| analysis = ai_manager.generate_text( | |
| prompt=prompt, | |
| model=selected_model, | |
| system_prompt="You are an expert presentation flow analyst focusing on business presentations.", | |
| temperature=0.3, | |
| max_tokens=1000 | |
| ) | |
| # Display analysis | |
| st.info("### Presentation Flow Analysis") | |
| st.write(analysis) | |
| except Exception as e: | |
| st.error(f"Error analyzing presentation flow: {str(e)}") | |
| # Add slide button with options | |
| col1, col2 = st.columns([3, 1]) | |
| with col1: | |
| slide_position = st.radio( | |
| "Add new slide:", | |
| ["At End", "After Current", "Before Current"], | |
| horizontal=True | |
| ) | |
| with col2: | |
| if st.button("➕ Add New Slide", use_container_width=True): | |
| # Create a new slide | |
| new_slide = { | |
| 'title': 'New Slide', | |
| 'purpose': 'Additional content', | |
| 'key_points': ['Add your content here'], | |
| 'visual_elements': ['Suggested visuals will appear here'] | |
| } | |
| # Insert at the selected position | |
| if slide_position == "At End": | |
| st.session_state.storyboard.append(new_slide) | |
| elif slide_position == "After Current": | |
| # Get current slide index from session state or default to last | |
| current_idx = st.session_state.get("current_storyboard_slide", len(st.session_state.storyboard) - 1) | |
| st.session_state.storyboard.insert(current_idx + 1, new_slide) | |
| else: # Before Current | |
| current_idx = st.session_state.get("current_storyboard_slide", 0) | |
| st.session_state.storyboard.insert(max(0, current_idx), new_slide) | |
| st.rerun() | |
| # Add slide templates section | |
| with st.expander("📑 Slide Templates"): | |
| st.write("Add pre-designed slide templates to your presentation:") | |
| template_cols = st.columns(3) | |
| slide_templates = [ | |
| {"name": "Section Divider", "icon": "🏷️", "title": "Section Title", | |
| "purpose": "Introduce a new section", | |
| "key_points": ["A clean slide to mark a new section of your presentation"]}, | |
| {"name": "Comparison", "icon": "⚖️", "title": "Comparison", | |
| "purpose": "Compare two options or approaches", | |
| "key_points": ["Option A benefits", "Option A challenges", "Option B benefits", "Option B challenges"], | |
| "visual_elements": ["Two-column layout", "Comparison table or chart"]}, | |
| {"name": "Quote", "icon": "💬", "title": "Key Quote", | |
| "purpose": "Highlight an important quote", | |
| "key_points": ["The quote goes here", "- Attribution"], | |
| "visual_elements": ["Quotation marks graphic", "Simple background"]}, | |
| {"name": "Data Visualization", "icon": "📊", "title": "Key Metrics", | |
| "purpose": "Present important data", | |
| "key_points": ["Metric 1 and its significance", "Metric 2 and its significance", "Trends and patterns"], | |
| "visual_elements": ["Chart or graph", "Data visualization"]}, | |
| {"name": "Call to Action", "icon": "🎯", "title": "Next Steps", | |
| "purpose": "Define clear action items", | |
| "key_points": ["Specific action item 1", "Specific action item 2", "Timeline and ownership"], | |
| "visual_elements": ["Arrow or path graphic", "Timeline visualization"]}, | |
| {"name": "Team Slide", "icon": "👥", "title": "Our Team", | |
| "purpose": "Introduce key team members", | |
| "key_points": ["Team member 1 with role", "Team member 2 with role", "Team member 3 with role"], | |
| "visual_elements": ["Team photos or icons", "Organizational chart"]} | |
| ] | |
| for i, template in enumerate(slide_templates): | |
| with template_cols[i % 3]: | |
| if st.button(f"{template['icon']} {template['name']}", key=f"template_{template['name']}"): | |
| # Create a new slide based on the template | |
| new_slide = { | |
| 'title': template['title'], | |
| 'purpose': template['purpose'], | |
| 'key_points': template['key_points'], | |
| 'visual_elements': template.get('visual_elements', []) | |
| } | |
| # Add to storyboard | |
| st.session_state.storyboard.append(new_slide) | |
| st.success(f"Added {template['name']} slide!") | |
| st.rerun() | |
| # Display storyboard slides | |
| for i, slide in enumerate(st.session_state.storyboard): | |
| # Set current slide in session state when expander is opened | |
| is_expanded = i == 0 or st.session_state.get("current_storyboard_slide") == i | |
| with st.expander(f"Slide {i+1}: {slide.get('title', 'Untitled')}", expanded=is_expanded): | |
| if is_expanded: | |
| st.session_state.current_storyboard_slide = i | |
| # Main slide content | |
| cols = st.columns([3, 1]) | |
| with cols[0]: | |
| slide_title = st.text_input(f"Title ###{i}", value=slide.get('title', 'Untitled')) | |
| with cols[1]: | |
| # Slide reordering and deletion | |
| cols2 = st.columns([1, 1, 1]) | |
| with cols2[0]: | |
| if i > 0 and st.button("⬆️", key=f"up_{i}"): | |
| st.session_state.storyboard[i], st.session_state.storyboard[i-1] = st.session_state.storyboard[i-1], st.session_state.storyboard[i] | |
| st.session_state.current_storyboard_slide = i - 1 | |
| st.rerun() | |
| with cols2[1]: | |
| if i < len(st.session_state.storyboard) - 1 and st.button("⬇️", key=f"down_{i}"): | |
| st.session_state.storyboard[i], st.session_state.storyboard[i+1] = st.session_state.storyboard[i+1], st.session_state.storyboard[i] | |
| st.session_state.current_storyboard_slide = i + 1 | |
| st.rerun() | |
| with cols2[2]: | |
| if st.button("🗑️", key=f"delete_{i}"): | |
| if len(st.session_state.storyboard) > 1: # Prevent deleting the last slide | |
| st.session_state.storyboard.pop(i) | |
| st.session_state.current_storyboard_slide = min(i, len(st.session_state.storyboard) - 1) | |
| st.rerun() | |
| else: | |
| st.error("Cannot delete the last slide") | |
| slide_purpose = st.text_area(f"Purpose ###{i}", value=slide.get('purpose', '')) | |
| # Handle key points (could be string or list) | |
| if isinstance(slide.get('key_points', ""), list): | |
| key_points_text = "\n".join(slide['key_points']) | |
| else: | |
| key_points_text = slide.get('key_points', "") | |
| key_points = st.text_area(f"Key Points (one per line) ###{i}", value=key_points_text) | |
| # Handle visual elements (could be string or list) | |
| if isinstance(slide.get('visual_elements', ""), list): | |
| visual_elements_text = "\n".join(slide['visual_elements']) | |
| else: | |
| visual_elements_text = slide.get('visual_elements', "") | |
| visual_elements = st.text_area(f"Visual Elements (one per line) ###{i}", value=visual_elements_text) | |
| # AI enhancement options | |
| with st.expander("🧠 AI Enhancement"): | |
| ai_cols = st.columns(2) | |
| with ai_cols[0]: | |
| # Get AI manager | |
| ai_manager = get_ai_manager() | |
| available_models = ai_manager.get_available_models() | |
| enhancement_model = st.selectbox( | |
| "AI Model", | |
| options=list(available_models.keys()), | |
| format_func=lambda x: available_models.get(x, x), | |
| index=0, | |
| key=f"enhance_model_{i}" | |
| ) | |
| with ai_cols[1]: | |
| enhancement_type = st.selectbox( | |
| "Enhancement Type", | |
| ["Content", "Title", "Visual Suggestions", "All"], | |
| key=f"enhance_type_{i}" | |
| ) | |
| if st.button("✨ Enhance with AI", key=f"enhance_slide_{i}"): | |
| with st.spinner("🧠 Enhancing slide content..."): | |
| # Update slide with current edits first | |
| updated_slide = { | |
| 'title': slide_title, | |
| 'purpose': slide_purpose, | |
| 'key_points': key_points.split("\n") if "\n" in key_points else [key_points] if key_points else [], | |
| 'visual_elements': visual_elements.split("\n") if "\n" in visual_elements else [visual_elements] if visual_elements else [] | |
| } | |
| try: | |
| # Create appropriate prompt based on enhancement type | |
| if enhancement_type == "Content" or enhancement_type == "All": | |
| content_prompt = f""" | |
| You are an expert presentation content creator. | |
| Enhance the content for this slide: | |
| Title: {updated_slide['title']} | |
| Purpose: {updated_slide['purpose']} | |
| Current content: {updated_slide['key_points']} | |
| Make the content more impactful, clear, and aligned with the slide's purpose. | |
| Return only the enhanced content points as a JSON array of strings like this: | |
| ["Enhanced point 1", "Enhanced point 2", "Enhanced point 3"] | |
| """ | |
| content_response = ai_manager.generate_text( | |
| prompt=content_prompt, | |
| model=enhancement_model, | |
| system_prompt="You are an expert presentation content creator. Return only JSON array of enhanced bullet points.", | |
| temperature=0.7, | |
| max_tokens=500 | |
| ) | |
| # Extract JSON array from response | |
| try: | |
| json_start = content_response.find("[") | |
| json_end = content_response.rfind("]") + 1 | |
| if json_start >= 0 and json_end > 0: | |
| json_str = content_response[json_start:json_end] | |
| enhanced_content = json.loads(json_str) | |
| updated_slide['key_points'] = enhanced_content | |
| except Exception as e: | |
| st.error(f"Error parsing content enhancement: {str(e)}") | |
| if enhancement_type == "Title" or enhancement_type == "All": | |
| title_prompt = f""" | |
| You are an expert presentation title creator. | |
| Current slide title: {updated_slide['title']} | |
| Slide purpose: {updated_slide['purpose']} | |
| Slide content: {updated_slide['key_points']} | |
| Create a more engaging, clear, and impactful title for this slide. | |
| Return only the new title with no additional text or explanation. | |
| """ | |
| title_response = ai_manager.generate_text( | |
| prompt=title_prompt, | |
| model=enhancement_model, | |
| system_prompt="You are an expert presentation title creator. Return only the enhanced title.", | |
| temperature=0.7, | |
| max_tokens=50 | |
| ) | |
| updated_slide['title'] = title_response.strip() | |
| if enhancement_type == "Visual Suggestions" or enhancement_type == "All": | |
| visual_prompt = f""" | |
| You are an expert presentation visual designer. | |
| Slide title: {updated_slide['title']} | |
| Slide purpose: {updated_slide['purpose']} | |
| Slide content: {updated_slide['key_points']} | |
| Suggest specific visual elements that would enhance this slide. | |
| Consider charts, diagrams, images, icons, and layout suggestions. | |
| Return only a JSON array of specific recommendations like: | |
| ["Bar chart comparing quarterly revenue", "Icon representing customer satisfaction", "Split-screen layout with image on left"] | |
| """ | |
| visual_response = ai_manager.generate_text( | |
| prompt=visual_prompt, | |
| model=enhancement_model, | |
| system_prompt="You are an expert presentation visual designer. Return only a JSON array of visual element recommendations.", | |
| temperature=0.7, | |
| max_tokens=300 | |
| ) | |
| # Extract JSON array from response | |
| try: | |
| json_start = visual_response.find("[") | |
| json_end = visual_response.rfind("]") + 1 | |
| if json_start >= 0 and json_end > 0: | |
| json_str = visual_response[json_start:json_end] | |
| enhanced_visuals = json.loads(json_str) | |
| updated_slide['visual_elements'] = enhanced_visuals | |
| except Exception as e: | |
| st.error(f"Error parsing visual enhancement: {str(e)}") | |
| # Update the storyboard with enhanced slide | |
| st.session_state.storyboard[i] = updated_slide | |
| st.success("Slide enhanced with AI!") | |
| st.rerun() | |
| except Exception as e: | |
| st.error(f"Error enhancing slide: {str(e)}") | |
| # Web search enhancement option | |
| if perplexity_key: | |
| with st.expander("🔍 Enhance with Web Search"): | |
| search_query = st.text_input( | |
| "Search Query", | |
| value=f"latest information about {slide_title}", | |
| key=f"search_query_{i}" | |
| ) | |
| if st.button("🔍 Search & Enhance", key=f"search_enhance_{i}"): | |
| # Update slide with current edits first | |
| updated_slide = { | |
| 'title': slide_title, | |
| 'purpose': slide_purpose, | |
| 'key_points': key_points.split("\n") if "\n" in key_points else [key_points] if key_points else [], | |
| 'visual_elements': visual_elements.split("\n") if "\n" in visual_elements else [visual_elements] if visual_elements else [] | |
| } | |
| # Enhance with web search | |
| enhanced_slide = ai_manager.enhance_with_web_search(updated_slide, search_query) | |
| # Update the storyboard | |
| st.session_state.storyboard[i] = enhanced_slide | |
| st.success("Slide enhanced with web search results!") | |
| st.rerun() | |
| # Update storyboard with edits | |
| edited_slide = { | |
| 'title': slide_title, | |
| 'purpose': slide_purpose, | |
| 'key_points': key_points.split("\n") if "\n" in key_points else [key_points] if key_points else [], | |
| 'visual_elements': visual_elements.split("\n") if "\n" in visual_elements else [visual_elements] if visual_elements else [] | |
| } | |
| edited_storyboard.append(edited_slide) | |
| # Update the storyboard in session state | |
| st.session_state.storyboard = edited_storyboard | |
| st.markdown("---") | |
| col1, col2 = st.columns(2) | |
| with col1: | |
| nav_button("Back to Ideation", "ideation", icon="⬅️") | |
| with col2: | |
| nav_button("Continue to Template Selection", "template", icon="➡️", primary=True) |