Update src/streamlit_app.py

src/streamlit_app.py

@@ -468,4 +468,299 @@ def display_timestamp_improvements(json_data):
             column_config={
                 "Timestamp": st.column_config.TextColumn(width="small"),
                 "Current Element": st.column_config.TextColumn(width="medium"),
-                "Improvement Type": st.
+                "Improvement Type": st.column_config.TextColumn(width="medium"),
+                "Recommended Change": st.column_config.TextColumn(width="large"),
+                "Expected Impact": st.column_config.TextColumn(width="medium"),
+                "Priority": st.column_config.TextColumn(width="small")
+            }
+        )
+        
+        logger.info("Timestamp improvements displayed successfully")
+        
+    except Exception as e:
+        error_msg = f"Error displaying timestamp improvements: {str(e)}"
+        logger.error(error_msg, exc_info=True)
+        st.error(error_msg)
+
+def create_csv_download(json_data):
+    """Create CSV content with all scripts combined"""
+    logger.info("Creating CSV download...")
+    
+    try:
+        all_scripts_data = []
+        
+        # Combine all script variations into one dataset
+        for i, variation in enumerate(json_data.get("script_variations", []), 1):
+            variation_name = variation.get("variation_name", f"Variation {i}")
+            logger.debug(f"Processing variation for CSV: {variation_name}")
+            
+            for row in variation.get("script_table", []):
+                script_row = {
+                    'Variation': variation_name,
+                    'Timestamp': row.get('timestamp', ''),
+                    'Script_Voiceover': row.get('script_voiceover', ''),
+                    'Visual_Direction': row.get('visual_direction', ''),
+                    'Psychological_Trigger': row.get('psychological_trigger', ''),
+                    'CTA_Action': row.get('cta_action', '')
+                }
+                all_scripts_data.append(script_row)
+        
+        # Convert to DataFrame and then to CSV
+        if all_scripts_data:
+            df = pd.DataFrame(all_scripts_data)
+            csv_content = df.to_csv(index=False)
+            logger.info(f"CSV created successfully with {len(all_scripts_data)} rows")
+            return csv_content
+        else:
+            logger.warning("No script data available for CSV")
+            return "No script data available"
+            
+    except Exception as e:
+        error_msg = f"Error creating CSV: {str(e)}"
+        logger.error(error_msg, exc_info=True)
+        return f"Error creating CSV: {error_msg}"
+
+def check_token(user_token):
+    logger.info("Checking access token...")
+    
+    ACCESS_TOKEN = os.getenv("ACCESS_TOKEN")
+    if not ACCESS_TOKEN:
+        error_msg = "ACCESS_TOKEN not set in environment."
+        logger.critical(error_msg)
+        return False, "Server error: Access token not configured."
+    
+    if user_token == ACCESS_TOKEN:
+        logger.info("Access token validated successfully.")
+        return True, ""
+    
+    logger.warning("Invalid access token attempt.")
+    return False, "Invalid token."
+
+def main():
+    """Main application function"""
+    logger.info("Starting main application...")
+
+    if "authenticated" not in st.session_state:
+        st.session_state["authenticated"] = False
+        logger.debug("Authentication state initialized")
+
+    if not st.session_state["authenticated"]:
+        logger.info("User not authenticated, showing login screen")
+        st.markdown("## Access Required")
+        token_input = st.text_input("Enter Access Token", type="password")
+        if st.button("Unlock App"):
+            ok, error_msg = check_token(token_input)
+            if ok:
+                st.session_state["authenticated"] = True
+                logger.info("User authenticated successfully")
+                st.rerun()
+            else:
+                logger.warning(f"Authentication failed: {error_msg}")
+                st.error(error_msg)
+        return
+
+    # Add API test button for debugging
+    if st.sidebar.button("🔧 Test API Connection"):
+        logger.info("Testing API connection...")
+        try:
+            genai.configure(api_key=GEMINI_API_KEY)
+            models = list(genai.list_models())
+            st.sidebar.success(f"✅ API Working! Found {len(models)} models")
+            logger.info(f"API test successful, found {len(models)} models")
+            for model in models[:3]:  # Show first 3 models
+                st.sidebar.text(f"• {model.name}")
+        except Exception as e:
+            error_msg = f"❌ API Test Failed: {str(e)}"
+            st.sidebar.error(error_msg)
+            logger.error(f"API test failed: {str(e)}", exc_info=True)
+
+    # Sidebar navigation
+    if st.session_state["authenticated"]:
+        logger.info("User authenticated, showing main interface")
+
+        selected_tab = st.sidebar.radio("Select Mode", ["Script Generator", "History"])
+        logger.debug(f"Selected tab: {selected_tab}")
+
+        # ========== SCRIPT GENERATOR ==========
+        if selected_tab == "Script Generator":
+            logger.info("Script Generator mode selected")
+            
+            with st.expander("How to Use This Tool", expanded=False):
+                st.markdown("""
+                ### Upload Guidelines:
+                - **Best videos to analyze**: Already profitable Facebook/TikTok ads in your niche  
+                - **Video length**: 30–90 seconds work best for analysis  
+                - **Quality**: Clear audio and visuals help with better analysis  
+
+                ### Context Tips:
+                - **Offer details**: Be specific about your main promise and mechanism  
+                - **Audience**: Include demographics, pain points, and desires  
+                - **Hooks**: Mention any specific angles that have worked for you  
+
+                ### Script Optimization:
+                - Generated scripts focus on stopping scroll and driving clicks  
+                - Each variation tests different psychological triggers  
+                - Use the timestamp format for precise video production  
+                - Test multiple variations to find your best performer  
+                """)
+            st.subheader("Input Configuration")
+
+            uploaded_video = st.file_uploader(
+                "Upload Reference Video",
+                type=['mp4', 'mov', 'avi', 'mkv'],
+                help="Upload a profitable ad video to analyze and create variations from"
+            )
+            
+            if uploaded_video is not None:
+                logger.info(f"Video uploaded: {uploaded_video.name}, size: {uploaded_video.size} bytes")
+            else:
+                st.info("Please upload a reference video to begin analysis.")
+
+            st.subheader("Additional Context (Optional)")
+            
+            offer_details = st.text_area(
+                "Offer Details",
+                placeholder="e.g., Solar installation with $0 down payment...",
+                height=80,
+                help="Describe the product/service and main promise"
+            )
+            
+            target_audience = st.text_area(
+                "Target Audience",
+                placeholder="e.g., 40+ homeowners with high electricity bills...",
+                height=80,
+                help="Describe the ideal customer demographics and pain points"
+            )
+            
+            specific_hooks = st.text_area(
+                "Specific Hooks to Test",
+                placeholder="e.g., Government rebate angle, celebrity endorsement...",
+                height=80,
+                help="Any specific angles or hooks you want to incorporate"
+            )
+            
+            additional_context = st.text_area(
+                "Additional Context",
+                placeholder="Any other relevant information...",
+                height=100,
+                help="Compliance requirements, brand guidelines, or other notes"
+            )
+
+            generate_button = st.button("Generate Script Variations", use_container_width=True)
+
+            if "analysis_results" in st.session_state and st.session_state["analysis_results"]:
+                if st.button("Clear Results", use_container_width=True):
+                    del st.session_state["analysis_results"]
+                    logger.info("Analysis results cleared")
+                    st.rerun()
+
+            # Generate & show results
+            if uploaded_video and generate_button:
+                logger.info("Starting video analysis process...")
+                
+                with st.spinner("Analyzing video and generating scripts..."):
+                    video_bytes = uploaded_video.read()
+                    uploaded_video.seek(0)
+
+                    json_response = analyze_video_and_generate_script(
+                        video_bytes,
+                        uploaded_video.name,
+                        offer_details,
+                        target_audience,
+                        specific_hooks,
+                        additional_context
+                    )
+
+                if json_response:
+                    logger.info("Analysis completed successfully, saving to database...")
+                    try:
+                        insert_analysis_result(
+                            video_name=uploaded_video.name,
+                            offer_details=offer_details,
+                            target_audience=target_audience,
+                            specific_hook=specific_hooks,
+                            additional_context=additional_context,
+                            response=json_response
+                        )
+                        logger.info("Results saved to database")
+                    except Exception as db_error:
+                        logger.error(f"Failed to save to database: {str(db_error)}", exc_info=True)
+                        st.warning("Analysis completed but failed to save to database")
+                    
+                    st.session_state["analysis_results"] = json_response
+                else:
+                    logger.error("Analysis failed, no response received")
+
+            if "analysis_results" in st.session_state:
+                logger.info("Displaying analysis results...")
+                json_response = st.session_state["analysis_results"]
+
+                tab1, tab2, tab3 = st.tabs(["Script Variations", "Video Analysis", "Improvement Recommendations"])
+                
+                with tab1:
+                    display_script_variations(json_response)
+                    csv_content = create_csv_download(json_response)
+                    st.download_button("Download All Scripts (CSV)", data=csv_content,
+                                       file_name="video_script_variations.csv", mime="text/csv")
+                with tab2:
+                    display_video_analysis(json_response)
+                with tab3:
+                    display_timestamp_improvements(json_response)
+
+        # ========== HISTORY ==========
+        elif selected_tab == "History":
+            logger.info("History mode selected")
+            
+            try:
+                from database import get_all_results
+                history_items = get_all_results(limit=20)
+                logger.info(f"Retrieved {len(history_items) if history_items else 0} history items")
+
+                if history_items:
+                    video_titles = [
+                        f"{item['video_name']} ({item['created_at'].strftime('%Y-%m-%d %H:%M')})"
+                        for item in history_items
+                    ]
+
+                    selected = st.sidebar.radio("History Items", video_titles, index=0)
+                    selected_index = video_titles.index(selected)
+                    selected_data = history_items[selected_index]
+                    
+                    logger.info(f"Selected history item: {selected_data['video_name']}")
+
+                    st.subheader(f"Analysis for: {selected_data['video_name']}")
+                    json_response = selected_data.get("response")
+
+                    if json_response:
+                        tab1, tab2, tab3 = st.tabs(["Script Variations", "Video Analysis", "Improvement Recommendations"])
+
+                        with tab1:
+                            display_script_variations(json_response)
+                        with tab2:
+                            display_video_analysis(json_response)
+                        with tab3:
+                            display_timestamp_improvements(json_response)
+                    else:
+                        warning_msg = "No valid response data for this analysis."
+                        logger.warning(warning_msg)
+                        st.warning(warning_msg)
+                else:
+                    logger.info("No history items found")
+                    st.sidebar.info("No saved analyses found.")
+                    st.info("No saved history available.")
+                    
+            except Exception as history_error:
+                error_msg = f"Error loading history: {str(history_error)}"
+                logger.error(error_msg, exc_info=True)
+                st.error(error_msg)
+
+if __name__ == "__main__":
+    try:
+        logger.info("=" * 50)
+        logger.info("LAUNCHING VIDEO ANALYZER APPLICATION")
+        logger.info("=" * 50)
+        main()
+    except Exception as e:
+        logger.exception("CRITICAL ERROR: Unhandled error during app launch")
+        st.error(f"Critical application error: {str(e)}")
+        st.error("Please check the logs for more details.")