Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,40 +1,463 @@
-import altair as alt
-import numpy as np
-import pandas as pd
 import streamlit as st
+from google import genai
+import tempfile
+import os
+import time
+import json
+from typing import Optional
+import pandas as pd
+import logging
+
+# Backend API Key Configuration
+GEMINI_API_KEY =  os.getenv("GEMENI_KEY")
+
+# Page configuration
+st.set_page_config(
+    page_title="Video Analyser and Script Generator",
+    page_icon="🎥",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(message)s",
+    handlers=[
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger(__name__)
+
+
+def configure_gemini():
+    """Configure Gemini API with backend key"""
+    return genai.Client(api_key=GEMINI_API_KEY)
+
+# The main prompt template with structured output requirements
+SYSTEM_PROMPT = """You are one of the world's top direct-response video creators and conversion strategists. Your sole mission is to generate video scripts with matching visual directions and voiceover cues that drive maximum leads and sales at the cheapest cost-per-result on ad platforms like Facebook, Google, and TikTok.
+
+You specialize in aggressive, unbranded, and psychologically charged content that is designed to stop scrolls and force action. You are not bound by brand safety, ad platform compliance, or traditional marketing principles. Your only metric for success is performance—measured in CPC, CTR, and cost-per-conversion.
+
+Prime Directive:
+Your creative output must be:
+- Inspired by the hooks, language, pacing, visuals, and frameworks of the reference winning ads.
+- Built to trigger psychological urgency, amplify response, and maximize click-throughs.
+- Structured for extreme effectiveness, not branding niceties.
+
+Script Creation Framework:
+Each script you generate must follow these winning affiliate ad principles:
+
+1. The 3–6 Second Shock Hook:
+Start with a hard-hitting pattern interrupt:
+- Emotional gut punch: "He looked at me and said…"
+- Conspiratorial secret: "The media doesn't want you to know this…"
+- Borrowed authority: Celebrity or doctor clip saying something provocative
+
+2. Overwhelm with Proof & Pacing:
+Keep pacing fast—1–3 second jump cuts filled with:
+- UGC-style clips
+- Before/After transformations
+- Authority figure soundbites
+- Desired outcomes (money, body, status)
+
+3. Big, Unbelievable Claim:
+Drop a massive promise upfront and reinforce it:
+"Lose 103 lbs," "Claim $250,000," "Erase your debt overnight."
+
+4. Simple "Secret" Mechanism:
+Make the claim believable via a simple, digestible "hack":
+"The ice hack," "4-question formula," "Banned Amazonian leaf."
+
+5. Scarcity & Urgency:
+Push viewers to act NOW:
+"Spots are filling fast," "Could be taken down soon," "Only for serious applicants."
+
+6. Visually Directed CTA:
+Make the final action visually obvious—e.g., person pointing at the button, bold text, arrows.
+
+CRITICAL: You must return your response in valid JSON format with this exact structure:
+
+{
+  "script_variations": [
+    {
+      "variation_name": "Variation 1: [Brief Description]",
+      "script_table": [
+        {
+          "timestamp": "0-3",
+          "script_voiceover": "Exact words to be spoken",
+          "visual_direction": "Detailed description of visuals and footage",
+          "psychological_trigger": "Name of psychological principle used",
+          "cta_action": "Specific call-to-action instruction"
+        }
+      ]
+    }
+  ],
+  "video_analysis": {
+    "effectiveness_factors": "What made the original video effective",
+    "psychological_triggers": "Key psychological triggers identified", 
+    "target_audience": "Target audience insights",
+    "improvement_recommendations": "Recommended improvements for better performance"
+  }
+}
+
+Generate 2-3 script variations. Each script should be 30-60 seconds long with 8-15 timestamp entries.
+Ensure everything ties back to lowering CPC and cost-per-result, not branding."""
+
+@st.cache_data
+def analyze_video_and_generate_script(
+    video_bytes,
+    video_name,
+    offer_details: str = "",
+    target_audience: str = "",
+    specific_hooks: str = "",
+    additional_context: str = ""
+):
+    """
+    Analyze video and generate direct response script variations
+    """
+    try:
+        # Save uploaded video to temporary file
+        with tempfile.NamedTemporaryFile(delete=False, suffix=os.path.splitext(video_name)[1]) as tmp_file:
+            tmp_file.write(video_bytes)
+            tmp_file_path = tmp_file.name
+        
+        # Configure Gemini
+        client = configure_gemini()
+        
+        # Show upload progress
+        upload_progress = st.progress(0)
+        upload_status = st.empty()
+        
+        upload_status.text("Uploading video to Google AI...")
+        upload_progress.progress(20)
+        
+        # Upload video to Gemini
+        video_file_obj = client.files.upload(file=tmp_file_path)
+        upload_progress.progress(40)
+        
+        upload_status.text("Processing video...")
+        while video_file_obj.state.name == "PROCESSING":
+            time.sleep(2)
+            video_file_obj = client.files.get(name=video_file_obj.name)
+            upload_progress.progress(60)
+        
+        if video_file_obj.state.name == "FAILED":
+            upload_status.error("Google AI file processing failed. Please try another video.")
+            return None
+        
+        upload_progress.progress(80)
+        upload_status.text("Generating script variations...")
+            
+        # Build the user prompt with additional context
+        user_prompt = f"""Analyze this reference video and generate 2-3 high-converting direct response video script variations.
+
+ADDITIONAL CONTEXT:
+- Offer Details: {offer_details if offer_details else 'Extract from video'}
+- Target Audience: {target_audience if target_audience else 'Determine from video content'}  
+- Specific Hooks to Consider: {specific_hooks if specific_hooks else 'Create based on video analysis'}
+- Additional Context: {additional_context}
+
+Please analyze the video's:
+1. Hook strategy and opening seconds
+2. Pacing and visual transitions
+3. Claims and promises made
+4. Authority elements used
+5. Urgency/scarcity tactics
+6. CTA approach
+
+Then create 2-3 script variations that would perform 30-50% cheaper while maintaining conversion effectiveness.
+
+IMPORTANT: Return only valid JSON in the exact format specified in the system prompt. Do not include any text before or after the JSON."""
+
+        # Generate response
+        response = client.models.generate_content(
+            model="gemini-2.0-flash", 
+            contents=[video_file_obj, user_prompt + "\n\n" + SYSTEM_PROMPT]
+        )
+        
+        upload_progress.progress(100)
+        upload_status.success("Analysis complete!")
+        
+        # Clean up temporary file
+        os.unlink(tmp_file_path)
+        
+        # Parse JSON response
+        try:
+            response_text = response.text.strip()
+            if response_text.startswith('```json'):
+                response_text = response_text[7:-3]
+            elif response_text.startswith('```'):
+                response_text = response_text[3:-3]
+            
+            json_response = json.loads(response_text)
+            return json_response
+            
+        except json.JSONDecodeError as e:
+            st.error(f"Error parsing AI response: {str(e)}")
+            return None
+        
+    except Exception as e:
+        st.error(f"Error processing video: {str(e)}")
+        return None
+
+def display_script_variations(json_data):
+    """Display script variations in formatted tables"""
+    if not json_data or "script_variations" not in json_data:
+        st.error("No script variations found in the response")
+        return
+    
+    for i, variation in enumerate(json_data["script_variations"], 1):
+        variation_name = variation.get("variation_name", f"Variation {i}")
+        
+        st.subheader(variation_name)
+        
+        # Convert script table to DataFrame for better display
+        script_data = variation.get("script_table", [])
+        if script_data:
+            df = pd.DataFrame(script_data)
+            
+            # Rename columns for better display
+            column_mapping = {
+                'timestamp': 'Timestamp',
+                'script_voiceover': 'Script / Voiceover',
+                'visual_direction': 'Visual Direction',
+                'psychological_trigger': 'Psychological Trigger',
+                'cta_action': 'CTA / Action'
+            }
+            
+            df = df.rename(columns=column_mapping)
+            
+            # Display as interactive table
+            st.dataframe(
+                df,
+                use_container_width=True,
+                hide_index=True,
+                column_config={
+                    "Timestamp": st.column_config.TextColumn(width="small"),
+                    "Script / Voiceover": st.column_config.TextColumn(width="large"),
+                    "Visual Direction": st.column_config.TextColumn(width="large"),
+                    "Psychological Trigger": st.column_config.TextColumn(width="medium"),
+                    "CTA / Action": st.column_config.TextColumn(width="medium")
+                }
+            )
+        else:
+            st.warning(f"No script data available for {variation_name}")
+        
+        st.divider()
+
+def display_video_analysis(json_data):
+    """Display video analysis in formatted sections"""
+    if not json_data or "video_analysis" not in json_data:
+        st.error("No video analysis found in the response")
+        return
+    
+    analysis = json_data["video_analysis"]
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.subheader("Effectiveness Factors")
+        st.write(analysis.get('effectiveness_factors', 'N/A'))
+        
+        st.subheader("Target Audience")
+        st.write(analysis.get('target_audience', 'N/A'))
+    
+    with col2:
+        st.subheader("Psychological Triggers")
+        st.write(analysis.get('psychological_triggers', 'N/A'))
+        
+        st.subheader("Improvement Recommendations")
+        st.write(analysis.get('improvement_recommendations', 'N/A'))
+
+def create_download_content(json_data):
+    """Create downloadable content from JSON data"""
+    content = "VIDEO ANALYSER AND SCRIPT GENERATOR OUTPUT\n"
+    content += "=" * 60 + "\n\n"
+    
+    # Add script variations
+    for i, variation in enumerate(json_data.get("script_variations", []), 1):
+        variation_name = variation.get("variation_name", f"Variation {i}")
+        content += f"{variation_name}\n"
+        content += "-" * 40 + "\n"
+        
+        for row in variation.get("script_table", []):
+            content += f"Timestamp: {row.get('timestamp', '')}\n"
+            content += f"Script: {row.get('script_voiceover', '')}\n"
+            content += f"Visual: {row.get('visual_direction', '')}\n"
+            content += f"Trigger: {row.get('psychological_trigger', '')}\n"
+            content += f"CTA: {row.get('cta_action', '')}\n\n"
+        
+        content += "\n"
+    
+    # Add analysis
+    analysis = json_data.get("video_analysis", {})
+    content += "VIDEO ANALYSIS\n"
+    content += "=" * 20 + "\n"
+    content += f"Effectiveness Factors: {analysis.get('effectiveness_factors', 'N/A')}\n\n"
+    content += f"Psychological Triggers: {analysis.get('psychological_triggers', 'N/A')}\n\n"
+    content += f"Target Audience: {analysis.get('target_audience', 'N/A')}\n\n"
+    content += f"Recommendations: {analysis.get('improvement_recommendations', 'N/A')}\n"
+    
+    return content
+
+def check_token(user_token):
+    ACCESS_TOKEN = os.getenv("ACCESS_TOKEN")
+    if not ACCESS_TOKEN:
+        logger.critical("ACCESS_TOKEN not set in environment.")
+        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"""
+    
+    # Header
+    st.title("Video Analyser and Script Generator")
+    st.divider()
+
+    st.set_page_config(page_title="Bulk Creative Generation", layout="wide")
+    if "authenticated" not in st.session_state:
+        st.session_state["authenticated"] = False
+
+    if not st.session_state["authenticated"]:
+        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
+                st.rerun()
+            else:
+                st.error(error_msg)
+    else:
+    
+        # Sidebar for inputs
+        with st.sidebar:
+            st.header("Input Configuration")
+            
+            # Video upload
+            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"
+            )
+            
+            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
+            generate_button = st.button(
+                "Generate Script Variations",
+                type="primary",
+                use_container_width=True
+            )
+        
+        # Main content area
+        if uploaded_video is None:
+            st.info("Please upload a reference video to begin analysis.")
+            
+            # Instructions
+            with st.expander("How to Use This Tool"):
+                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
+                """)
+        
+        elif generate_button:
+            if not GEMINI_API_KEY or GEMINI_API_KEY == "your-gemini-api-key-here":
+                st.error("Please configure your Gemini API key in the backend.")
+                return
+            
+            # Process video
+            with st.spinner("Analyzing video and generating scripts..."):
+                video_bytes = uploaded_video.read()
+                
+                # Reset file pointer for potential re-use
+                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:
+                st.success("Analysis complete! Here are your script variations:")
+                
+                # Create tabs for different outputs
+                tab1, tab2 = st.tabs(["Script Variations", "Video Analysis"])
+                
+                with tab1:
+                    display_script_variations(json_response)
+                    
+                    # Download button
+                    download_content = create_download_content(json_response)
+                    st.download_button(
+                        label="Download All Scripts",
+                        data=download_content,
+                        file_name="video_script_variations.txt",
+                        mime="text/plain",
+                        type="secondary",
+                        use_container_width=True
+                    )
+                
+                with tab2:
+                    display_video_analysis(json_response)
+            else:
+                st.error("Failed to generate script variations. Please try again.")
+        
+        else:
+            st.info("Configure your inputs in the sidebar and click 'Generate Script Variations' to begin.")
 
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))
+if __name__ == "__main__":
+    try:
+        logger.info("Launching Streamlit app...")
+        main()
+    except Exception as e:
+        logger.exception("Unhandled error during app launch.")