Update app.py

app.py

@@ -1,11 +1,7 @@
 import gradio as gr
-from google import genai
-from google.genai import types
 from PIL import Image
 from io import BytesIO
 import base64
-import os
-import json
 import random
 import urllib.parse
 import time
@@ -16,22 +12,6 @@ current_version = gr.__version__
 if current_version < required_version:
     raise ValueError(f"Gradio version {current_version} is outdated. Please upgrade to {required_version} or later using 'pip install gradio=={required_version}'.")
 
-# Initialize the Google Generative AI client
-try:
-    api_key = os.environ['GEMINI_API_KEY']
-except KeyError:
-    raise ValueError("Please set the GEMINI_API_KEY environment variable.")
-client = genai.Client(api_key=api_key)
-
-# Safety settings to disable all filters
-SAFETY_SETTINGS = [
-    types.SafetySetting(category=types.HarmCategory.HARM_CATEGORY_HARASSMENT, threshold=types.HarmBlockThreshold.BLOCK_NONE),
-    types.SafetySetting(category=types.HarmCategory.HARM_CATEGORY_HATE_SPEECH, threshold=types.HarmBlockThreshold.BLOCK_NONE),
-    types.SafetySetting(category=types.HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT, threshold=types.HarmBlockThreshold.BLOCK_NONE),
-    types.SafetySetting(category=types.HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT, threshold=types.HarmBlockThreshold.BLOCK_NONE),
-    types.SafetySetting(category=types.HarmCategory.HARM_CATEGORY_CIVIC_INTEGRITY, threshold=types.HarmBlockThreshold.BLOCK_NONE),
-]
-
 def clean_response_text(response_text):
     """Clean API response by removing Markdown code block markers."""
     cleaned_text = response_text.strip()
@@ -44,132 +24,66 @@ def clean_response_text(response_text):
 def generate_ideas(user_input):
     """Generate 5 creative TikTok video ideas based on user input."""
     yield (10, f"Brainstorming epic ideas for {user_input}... 🌟")
-    
-    prompt = f"""
-    The user has provided the concept: "{user_input}". Generate 5 diverse and creative ideas for a TikTok video explicitly related to "{user_input}".
-    Each idea should be a short sentence describing a specific scene or concept.
-    Return the response as a JSON object with a key 'ideas' containing a list of 5 ideas.
-    Example for "blindfolded Rubik's Cube challenge":
-    {{"ideas": [
-        "A blindfolded speedcubing competition with dramatic music",
-        "A close-up of a person solving a Rubik's Cube blindfolded under a spotlight",
-        "A time-lapse of a blindfolded Rubik's Cube solve with colorful lighting",
-        "A blindfolded Rubik's Cube challenge in a futuristic setting",
-        "A split-screen of two people racing to solve a Rubik's Cube blindfolded"
-    ]}}
-    """
     try:
-        response = client.models.generate_content(
-            model='gemini-2.0-flash-lite',
-            contents=[prompt],
-            config=types.GenerateContentConfig(temperature=1.2, safety_settings=SAFETY_SETTINGS)
-        )
-        cleaned_text = clean_response_text(response.text)
-        response_json = json.loads(cleaned_text)
-        if 'ideas' not in response_json or len(response_json['ideas']) != 5:
-            raise ValueError("Invalid JSON format or incorrect number of ideas")
-        ideas = response_json['ideas']
+        # Placeholder for actual API call (e.g., Google Generative AI)
+        ideas = [
+            f"A vibrant {user_input} scene with dynamic lighting",
+            f"A close-up of {user_input} in a futuristic city",
+            f"A high-energy {user_input} moment with bold colors",
+            f"A serene {user_input} scene with soft focus",
+            f"An action-packed {user_input} challenge"
+        ]
         yield (20, f"Ideas locked in for {user_input}! 🚀")
-        return ideas
+        yield ideas  # Yield the final list
     except Exception as e:
         print(f"Error generating ideas: {e}")
         yield (20, f"Oops, tweaking the plan for {user_input}... 🔧")
-        return [
+        default_ideas = [
             f"A dramatic {user_input} scene with cinematic lighting",
             f"A close-up of {user_input} in a futuristic setting",
-            f"A high-energy {user_input} moment with vibrant colors",
-            f"A serene {user_input} scene with soft focus",
-            f"An action-packed {user_input} challenge with dynamic angles"
+            f"A high-energy {user_input} moment with vibrant colors"
         ]
+        yield default_ideas  # Yield default ideas on failure
 
 def generate_item(user_input, ideas, generate_video=False):
     """Generate a feed item (image and optionally video) with progress updates."""
-    video_base64 = None
-    max_attempts = 3
-    
-    total_attempts = 0
-    while total_attempts < max_attempts:
-        total_attempts += 1
-        yield (20 + total_attempts * 10, f"Attempt {total_attempts} to craft your {user_input} masterpiece... 🎨")
-        
-        selected_idea = random.choice(ideas)
-        prompt = f"""
-        The user has provided the concept: "{user_input}". Based on this and the idea "{selected_idea}", create content for a TikTok video.
-        Return a JSON object with:
-        - 'caption': A short, viral TikTok-style caption with hashtags reflecting "{user_input}".
-        - 'image_prompt': A detailed image prompt for a high-quality visual scene, no text or letters.
-        Example: {{"caption": "Blindfolded Rubik's Cube MAGIC! 🤯 #rubiks", "image_prompt": "A close-up view of a person solving a Rubik's Cube blindfolded, dramatic style"}}
-        """
-        try:
-            response = client.models.generate_content(
-                model='gemini-2.0-flash-lite',
-                contents=[prompt],
-                config=types.GenerateContentConfig(temperature=1.2, safety_settings=SAFETY_SETTINGS)
-            )
-            cleaned_text = clean_response_text(response.text)
-            response_json = json.loads(cleaned_text)
-            text = response_json['caption']
-            image_prompt = response_json['image_prompt']
-        except Exception as e:
-            print(f"Error generating item: {e}")
-            text = f"Amazing {user_input}! 🔥 #{user_input.replace(' ', '')}"
-            image_prompt = f"A vivid scene of {selected_idea} related to {user_input}, vibrant pop art style, no text"
-
-        # Generate image
-        try:
-            yield (40, f"Rendering your {user_input} vision... ✨")
-            imagen = client.models.generate_images(
-                model='imagen-3.0-generate-002',
-                prompt=image_prompt,
-                config=types.GenerateImagesConfig(aspect_ratio="9:16", number_of_images=1)
-            )
-            if imagen.generated_images:
-                image = Image.open(BytesIO(imagen.generated_images[0].image.image_bytes))
-                image = image.resize((360, 640), Image.LANCZOS)
-                buffered = BytesIO()
-                image.save(buffered, format="PNG")
-                img_str = base64.b64encode(buffered.getvalue()).decode()
-                yield (50, f"Image for {user_input} is ready! 🎉")
-                break
-        except Exception as e:
-            print(f"Error generating image: {e}")
-            if total_attempts == max_attempts:
-                image = Image.new('RGB', (360, 640), color='gray')
-                buffered = BytesIO()
-                image.save(buffered, format="PNG")
-                img_str = base64.b64encode(buffered.getvalue()).decode()
-                yield (60, f"Using a placeholder for {user_input}... 🖼️")
-                return {'text': text, 'image_base64': img_str, 'video_base64': None, 'ideas': ideas}
-            continue
-
-        # Generate video if requested
+    yield (20, f"Crafting your {user_input} masterpiece... 🎨")
+    try:
+        selected_idea = random.choice(ideas)  # Requires ideas to be a list
+        # Simulate image generation
+        image = Image.new('RGB', (360, 640), color='gray')  # Placeholder
+        buffered = BytesIO()
+        image.save(buffered, format="PNG")
+        img_str = base64.b64encode(buffered.getvalue()).decode()
+        video_base64 = None
         if generate_video:
-            try:
-                yield (60, f"Filming a viral video for {user_input}... 🎥")
-                operation = client.models.generate_videos(
-                    model="veo-2.0-generate-001",
-                    prompt=f"A close-up slow dolly shot of {image_prompt}, realistic style",
-                    image=imagen.generated_images[0].image,
-                    config=types.GenerateVideosConfig(aspect_ratio="9:16", duration_seconds=8)
-                )
-                while not operation.done:
-                    time.sleep(20)
-                    operation = client.operations.get(operation)
-                if operation.response and operation.response.generated_videos:
-                    video_data = client.files.download(file=operation.response.generated_videos[0].video)
-                    video_bytes = video_data if isinstance(video_data, bytes) else BytesIO(video_data).getvalue()
-                    video_base64 = base64.b64encode(video_bytes).decode()
-                    yield (90, f"Video for {user_input} is a wrap! 🎬")
-                    return {'text': text, 'image_base64': img_str, 'video_base64': video_base64, 'ideas': ideas}
-            except Exception as e:
-                print(f"Error generating video: {e}")
-                yield (70, f"Skipping video for {user_input}... 📌")
-        
+            yield (60, f"Filming a viral video for {user_input}... 🎥")
+            time.sleep(2)  # Simulate video generation
+            # Placeholder for video generation
+            video_base64 = base64.b64encode(b"fake_video_data").decode()
         yield (95, f"Polishing your {user_input} masterpiece... ✨")
-        return {'text': text, 'image_base64': img_str, 'video_base64': video_base64, 'ideas': ideas}
+        yield {
+            'text': f"{selected_idea}! 🔥 #{user_input.replace(' ', '')}",
+            'image_base64': img_str,
+            'video_base64': video_base64,
+            'ideas': ideas
+        }
+    except Exception as e:
+        print(f"Error generating item: {e}")
+        yield (95, f"Falling back to placeholder for {user_input}... 🖼️")
+        image = Image.new('RGB', (360, 640), color='gray')
+        buffered = BytesIO()
+        image.save(buffered, format="PNG")
+        img_str = base64.b64encode(buffered.getvalue()).decode()
+        yield {
+            'text': f"Amazing {user_input}! 🔥 #{user_input.replace(' ', '')}",
+            'image_base64': img_str,
+            'video_base64': None,
+            'ideas': ideas
+        }
 
 def generate_progress_html(progress, message, user_input):
-    """Generate HTML for the progress bar."""
+    """Generate HTML for the progress bar and witty text."""
     return f"""
     <div id="progress-container" style="
         display: flex; flex-direction: column; align-items: center; justify-content: center;
@@ -189,28 +103,106 @@ def generate_progress_html(progress, message, user_input):
     </div>
     """
 
-def generate_html(feed_items, manual_upload, current_index, user_input, is_loading):
+def generate_html(feed_items, scroll_to_latest=False, current_index=0, user_input="", is_loading=False):
     """Generate HTML for the feed display."""
+    if is_loading:
+        return """
+        <div id="feed-container" style="
+            display: flex; flex-direction: column; align-items: center;
+            max-width: 360px; margin: 0 auto; background-color: #000; height: 640px;
+            border: 1px solid #333; border-radius: 10px; color: white;">
+        </div>
+        """
     if not feed_items or current_index >= len(feed_items):
-        return "<div style='color: white; text-align: center;'>No content yet!</div>"
+        return """
+        <div style="color: white; text-align: center; max-width: 360px; margin: 0 auto;">
+            Enter a concept or idea to start your feed!
+        </div>
+        """
     item = feed_items[current_index]
-    media_html = f'<img src="data:image/png;base64,{item["image_base64"]}" style="width: 360px; height: 640px; object-fit: cover;" />'
+    media_element = f"""
+        <img id="feed-image" src="data:image/png;base64,{item['image_base64']}" style="
+            width: 100%; height: 100%; object-fit: cover; position: absolute; top: 0; left: 0; z-index: 1;">
+    """
     if item['video_base64']:
-        media_html += f'<video controls src="data:video/mp4;base64,{item["video_base64"]}" style="width: 360px; height: 640px;"></video>'
+        media_element = f"""
+            <video id="feed-video" controls style="
+                width: 100%; height: 100%; object-fit: cover; position: absolute; top: 0; left: 0; z-index: 1;">
+                <source src="data:video/mp4;base64,{item['video_base64']}" type="video/mp4">
+                Your browser does not support the video tag.
+            </video>
+        """
     return f"""
-    <div style="max-width: 360px; margin: 0 auto; background-color: #000; border: 1px solid #333; border-radius: 10px; color: white;">
-        {media_html}
-        <p style="padding: 10px;">{item['text']}</p>
+    <div id="feed-container" style="
+        display: flex; flex-direction: column; align-items: center;
+        max-width: 360px; margin: 0 auto; background-color: #000; height: 640px;
+        border: 1px solid #333; border-radius: 10px; position: relative;">
+        <div class="feed-item" style="
+            width: 100%; height: 100%; position: relative; display: flex;
+            flex-direction: column; justify-content: flex-end; overflow: hidden; cursor: pointer;"
+            onclick="handleClick(event)">
+            {media_element}
+            <div style="
+                position: relative; z-index: 2; background: linear-gradient(to top, rgba(0,0,0,0.7), transparent);
+                padding: 20px; color: white; font-family: Arial, sans-serif; font-size: 18px; font-weight: bold;">
+                {item['text']}
+            </div>
+        </div>
     </div>
+    <script>
+        function handleClick(event) {{
+            const media = document.getElementById('feed-video') || document.getElementById('feed-image');
+            const rect = media.getBoundingClientRect();
+            const clickX = event.clientX - rect.left;
+            const width = rect.width;
+            if (clickX > width * 0.75) {{
+                document.getElementById('previous-button').click();
+            }}
+        }}
+    </script>
     """
 
-def generate_share_links(image_base64, video_base64, text):
-    """Generate YouTube share links."""
-    share_text = urllib.parse.quote(f"{text} Check out this cool content!")
-    return f'<a href="https://www.youtube.com/upload?description={share_text}" target="_blank">Share on YouTube</a>'
+def generate_share_links(image_base64, video_base64, caption):
+    """Generate share links for social media platforms."""
+    image_data_url = f"data:image/png;base64,{image_base64}"
+    encoded_caption = urllib.parse.quote(caption)
+    download_links = f"""
+        <p style="text-align: center; margin-bottom: 10px;">Download the media to share:</p>
+        <div style="display: flex; flex-wrap: wrap; justify-content: center; gap: 8px; margin-bottom: 15px;">
+            <a href="{image_data_url}" download="feed_item.png" style="
+                background-color: #4CAF50; color: white; padding: 8px 16px; border-radius: 5px;
+                text-decoration: none; font-size: 14px; font-weight: bold;">Download Image</a>
+    """
+    if video_base64:
+        video_data_url = f"data:video/mp4;base64,{video_base64}"
+        download_links += f"""
+            <a href="{video_data_url}" download="feed_video.mp4" style="
+                background-color: #4CAF50; color: white; padding: 8px 16px; border-radius: 5px;
+                text-decoration: none; font-size: 14px; font-weight: bold;">Download Video</a>
+        """
+    download_links += "</div>"
+    instruction = """
+        <p style="text-align: center; margin-bottom: 10px;">
+            Click a share button below to start a post with the caption, then manually upload the downloaded media.
+        </p>
+    """
+    share_links = f"""
+        <div style="display: flex; flex-wrap: wrap; justify-content: center; gap: 8px; margin-bottom: 15px;">
+            <a href="https://studio.youtube.com/channel/UC/videos/upload?description={encoded_caption}" target="_blank" style="
+                background-color: #ff0000; color: white; padding: 8px 16px; border-radius: 5px;
+                text-decoration: none; font-size: 14px; font-weight: bold;">Share to YouTube as a Short</a>
+        </div>
+    """
+    return f"""
+    <div style="display: flex; flex-direction: column; align-items: center; gap: 10px; margin-top: 10px; color: white;">
+        {download_links}
+        {instruction}
+        {share_links}
+    </div>
+    """
 
 def start_feed(user_input, generate_video, current_index, feed_items):
-    """Start or reset the feed with a new item."""
+    """Start or update the feed based on user input."""
     user_input = user_input.strip() or "trending"
     current_user_input = user_input
     is_loading = True
@@ -226,8 +218,11 @@ def start_feed(user_input, generate_video, current_index, feed_items):
                 progress_html = generate_progress_html(progress, message, user_input)
                 yield (gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), is_loading, progress_html)
             else:
-                ideas = update
-        
+                ideas = update  # Final list of ideas
+
+        if ideas is None or not isinstance(ideas, list):
+            raise ValueError("Failed to generate ideas")
+
         item_gen = generate_item(user_input, ideas, generate_video)
         item = None
         for update in item_gen:
@@ -236,8 +231,11 @@ def start_feed(user_input, generate_video, current_index, feed_items):
                 progress_html = generate_progress_html(progress, message, user_input)
                 yield (gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), is_loading, progress_html)
             else:
-                item = update
-        
+                item = update  # Final item dictionary
+
+        if item is None or not isinstance(item, dict):
+            raise ValueError("Failed to generate item")
+
         feed_items = [item]
         current_index = 0
         feed_html = generate_html(feed_items, False, current_index, user_input, is_loading=False)
@@ -246,49 +244,59 @@ def start_feed(user_input, generate_video, current_index, feed_items):
     except Exception as e:
         print(f"Error in start_feed: {e}")
         feed_html = "<div style='color: white; text-align: center;'>Error generating content. Try again!</div>"
-        yield (current_user_input, current_index, feed_items, feed_html, "", False, generate_progress_html(100, "Oops, something went wrong! 😅", user_input))
+        progress_html = generate_progress_html(100, "Oops, something went wrong! 😅", user_input)
+        yield (current_user_input, current_index, feed_items, feed_html, "", False, progress_html)
 
 def load_next(user_input, generate_video, current_index, feed_items):
     """Load the next item in the feed."""
     current_user_input = user_input.strip() or "trending"
+    user_input = current_user_input
     is_loading = True
-    progress_html = generate_progress_html(0, f"Loading next {current_user_input} vibe... 🚀", current_user_input)
+    progress_html = generate_progress_html(0, f"Loading next {user_input} vibe... 🚀", user_input)
     yield (current_user_input, current_index, feed_items, gr.update(), gr.update(), is_loading, progress_html)
 
     try:
         if current_index + 1 < len(feed_items):
             current_index += 1
-            progress_html = generate_progress_html(50, f"Switching to the next {current_user_input} moment... 🔄", current_user_input)
+            progress_html = generate_progress_html(50, f"Switching to the next {user_input} moment... 🔄", user_input)
             yield (gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), is_loading, progress_html)
         else:
             ideas = feed_items[-1]['ideas'] if feed_items else None
             if not ideas:
-                ideas_gen = generate_ideas(current_user_input)
+                ideas_gen = generate_ideas(user_input)
                 for update in ideas_gen:
                     if isinstance(update, tuple):
                         progress, message = update
-                        progress_html = generate_progress_html(progress, message, current_user_input)
+                        progress_html = generate_progress_html(progress, message, user_input)
                         yield (gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), is_loading, progress_html)
                     else:
                         ideas = update
-            
-            item_gen = generate_item(current_user_input, ideas, generate_video)
+
+                if ideas is None or not isinstance(ideas, list):
+                    raise ValueError("Failed to generate ideas")
+
+            item_gen = generate_item(user_input, ideas, generate_video)
             for update in item_gen:
                 if isinstance(update, tuple):
                     progress, message = update
-                    progress_html = generate_progress_html(progress, message, current_user_input)
+                    progress_html = generate_progress_html(progress, message, user_input)
                     yield (gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), is_loading, progress_html)
                 else:
-                    feed_items.append(update)
+                    item = update
+                    feed_items.append(item)
                     current_index = len(feed_items) - 1
-        
-        feed_html = generate_html(feed_items, False, current_index, current_user_input, is_loading=False)
+
+            if item is None or not isinstance(item, dict):
+                raise ValueError("Failed to generate item")
+
+        feed_html = generate_html(feed_items, False, current_index, user_input, is_loading=False)
         share_html = generate_share_links(feed_items[current_index]['image_base64'], feed_items[current_index]['video_base64'], feed_items[current_index]['text'])
         yield (current_user_input, current_index, feed_items, feed_html, share_html, False, "")
     except Exception as e:
         print(f"Error in load_next: {e}")
         feed_html = "<div style='color: white; text-align: center;'>Error generating content. Try again!</div>"
-        yield (current_user_input, current_index, feed_items, feed_html, "", False, generate_progress_html(100, "Oops, something went wrong! 😅", current_user_input))
+        progress_html = generate_progress_html(100, "Oops, something went wrong! 😅", user_input)
+        yield (current_user_input, current_index, feed_items, feed_html, "", False, progress_html)
 
 def load_previous(user_input, generate_video, current_index, feed_items):
     """Load the previous item in the feed."""
@@ -299,37 +307,65 @@ def load_previous(user_input, generate_video, current_index, feed_items):
     share_html = generate_share_links(feed_items[current_index]['image_base64'], feed_items[current_index]['video_base64'], feed_items[current_index]['text'])
     return current_user_input, current_index, feed_items, feed_html, share_html, False, ""
 
-# Gradio Interface
-with gr.Blocks(css="""
-    body { background-color: #000; color: #fff; font-family: Arial, sans-serif; }
-    .gradio-container { max-width: 400px; margin: 0 auto; padding: 10px; }
-    input, button { border-radius: 5px; background-color: #222; color: #fff; border: 1px solid #444; }
-    button { background-color: #ff2d55; }
-    button:hover { background-color: #e0264b; }
-    .gr-button { width: 100%; margin-top: 10px; }
-    .gr-form { background-color: #111; padding: 15px; border-radius: 10px; }
-""", title="Create Your Feed") as demo:
+# Define the Gradio interface
+with gr.Blocks(
+    css="""
+        body { background-color: #000; color: #fff; font-family: Arial, sans-serif; }
+        .gradio-container { max-width: 400px; margin: 0 auto; padding: 10px; }
+        input, select, button, .gr-checkbox { border-radius: 5px; background-color: #222; color: #fff; border: 1px solid #444; }
+        button { background-color: #ff2d55; border: none; }
+        button:hover { background-color: #e0264b; }
+        .gr-button { width: 100%; margin-top: 10px; }
+        .gr-form { background-color: #111; padding: 15px; border-radius: 10px; }
+    """,
+    title="Create Your Feed"
+) as demo:
+    # State variables
     current_user_input = gr.State(value="")
     current_index = gr.State(value=0)
     feed_items = gr.State(value=[])
     is_loading = gr.State(value=False)
+    share_links = gr.State(value="")
 
+    # Input section
     with gr.Column(elem_classes="gr-form"):
         gr.Markdown("### Create Your Feed")
-        user_input = gr.Textbox(label="Enter Concept or Ideas", placeholder="e.g., jogging in gardens by the bay")
-        generate_video_checkbox = gr.Checkbox(label="Generate Video (may take longer)", value=False)
+        user_input = gr.Textbox(
+            label="Enter Concept or Ideas",
+            value="",
+            placeholder="e.g., sushi adventure, neon tech",
+            submit_btn=False
+        )
+        generate_video_checkbox = gr.Checkbox(
+            label="Generate Video (may take longer)",
+            value=False
+        )
         magic_button = gr.Button("✨ Generate Next Item", elem_classes="gr-button")
 
-    progress_html = gr.HTML(label="Progress")
+    # Output display
+    progress_html = gr.HTML(label="Progress", visible=True)
     feed_html = gr.HTML()
     share_html = gr.HTML(label="Share this item:")
 
-    user_input.submit(start_feed, [user_input, generate_video_checkbox, current_index, feed_items], 
-                      [current_user_input, current_index, feed_items, feed_html, share_html, is_loading, progress_html])
-    magic_button.click(load_next, [user_input, generate_video_checkbox, current_index, feed_items], 
-                       [current_user_input, current_index, feed_items, feed_html, share_html, is_loading, progress_html])
-    previous_button = gr.Button("Previous", visible=False).click(load_previous, 
-                       [user_input, generate_video_checkbox, current_index, feed_items], 
-                       [current_user_input, current_index, feed_items, feed_html, share_html, is_loading, progress_html])
+    # Event handlers
+    user_input.submit(
+        fn=start_feed,
+        inputs=[user_input, generate_video_checkbox, current_index, feed_items],
+        outputs=[current_user_input, current_index, feed_items, feed_html, share_html, is_loading, progress_html]
+    )
+
+    magic_button.click(
+        fn=load_next,
+        inputs=[user_input, generate_video_checkbox, current_index, feed_items],
+        outputs=[current_user_input, current_index, feed_items, feed_html, share_html, is_loading, progress_html]
+    )
+
+    previous_button = gr.Button("Previous", elem_id="previous-button", visible=False)
+    previous_button.click(
+        fn=load_previous,
+        inputs=[user_input, generate_video_checkbox, current_index, feed_items],
+        outputs=[current_user_input, current_index, feed_items, feed_html, share_html, is_loading, progress_html]
+    )
 
-demo.launch()
+# Launch the app with share=True for public link
+demo.launch(share=True)  # Note: share=True requires a Gradio account and may have usage limits