Update app.py

app.py

@@ -61,7 +61,6 @@ def clean_response_text(response_text):
 def generate_ideas(user_input):
     """
     Generate a diverse set of ideas based on the user's input concept using the LLM.
-    Validate the relevance of each idea using a cheaper LLM (gemini-2.0-flash-lite).
     
     Args:
         user_input (str): The user's input concept or idea (e.g., "blindfolded Rubik's Cube challenge").
@@ -69,7 +68,7 @@ def generate_ideas(user_input):
     Returns:
         list: A list of ideas as strings.
     """
-    # Step 1: Generate ideas using gemini-2.0-flash
+    # Generate ideas using gemini-2.0-flash-lite
     prompt = f"""
     The user has provided the concept: "{user_input}". You must generate 5 diverse and creative ideas for a TikTok video that are directly and explicitly related to "{user_input}".
     Each idea must clearly incorporate and focus on the core theme of "{user_input}" without deviating into unrelated topics.
@@ -87,7 +86,7 @@ def generate_ideas(user_input):
     """
     try:
         response = client.models.generate_content(
-            model='gemini-2.0-flash',
+            model='gemini-2.0-flash-lite',
             contents=[prompt],
             config=types.GenerateContentConfig(
                 temperature=1.2,
@@ -103,54 +102,6 @@ def generate_ideas(user_input):
             raise ValueError("Invalid JSON format: 'ideas' key missing, not a list, or incorrect length")
         
         ideas = response_json['ideas']
-        
-        # Step 2: Validate relevance of each idea using gemini-2.0-flash-lite
-        for idea in ideas:
-            validation_prompt = f"""
-            Determine if the following idea for a TikTok video is related to the user's concept.
-            User's concept: "{user_input}"
-            Idea: "{idea}"
-            Respond with a JSON object containing a single key 'is_related' with a boolean value (true or false).
-            Example:
-            {{"is_related": true}}
-            """
-            try:
-                validation_response = client.models.generate_content(
-                    model='gemini-2.0-flash-lite',
-                    contents=[validation_prompt],
-                    config=types.GenerateContentConfig(
-                        temperature=0.0,  # Low temperature for deterministic output
-                        safety_settings=SAFETY_SETTINGS
-                    )
-                )
-                print(f"Validation response for idea '{idea}': {validation_response.text}")  # Debugging
-                if not validation_response.text or validation_response.text.isspace():
-                    raise ValueError("Empty validation response from API")
-                cleaned_validation_text = clean_response_text(validation_response.text)
-                validation_json = json.loads(cleaned_validation_text)
-                if 'is_related' not in validation_json or not isinstance(validation_json['is_related'], bool):
-                    raise ValueError("Invalid validation JSON format: 'is_related' key missing or not a boolean")
-                
-                if not validation_json['is_related']:
-                    print(f"Idea '{idea}' is not related to '{user_input}'. Falling back to default ideas.")
-                    return [
-                        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"
-                    ]
-            except Exception as e:
-                print(f"Error validating idea '{idea}': {e}. Falling back to default ideas.")
-                return [
-                    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"
-                ]
-        
-        # All ideas are related, return them
         return ideas
     
     except Exception as e:
@@ -202,7 +153,7 @@ def generate_item(user_input, ideas, generate_video=False, max_retries=3):
             """
             try:
                 response = client.models.generate_content(
-                    model='gemini-2.0-flash',
+                    model='gemini-2.0-flash-lite',
                     contents=[prompt],
                     config=types.GenerateContentConfig(
                         temperature=1.2,
@@ -282,108 +233,94 @@ def generate_item(user_input, ideas, generate_video=False, max_retries=3):
                     # Otherwise, continue to next cycle
                     break  # Exit inner loop to retry with new idea
 
-        # Step 2: Generate video if enabled (with retries using the same image)
+        # Step 2: Generate video if enabled (with fallback to text-to-video if image-to-video fails)
         if generate_video and generated_image is not None:
-            max_video_retries_per_image = 2  # Try video generation twice per image
+            max_video_retries_per_image = 2  # Try text-to-video generation twice if needed
             video_generated = False
 
-            # First, try image-to-video generation
-            for video_attempt in range(max_video_retries_per_image):
-                try:
-                    # Base video prompt
-                    video_prompt_base = f"""
-                    The user concept is "{user_input}". Based on this and the scene: {image_prompt}, create a video.
-                    Use a close-up shot with a slow dolly shot circling around the subject, 
-                    using shallow focus on the main subject to emphasize details, in a realistic style with cinematic lighting.
-                    """
-                    # Modify the prompt slightly for each retry
-                    if video_attempt == 0:
-                        video_prompt = video_prompt_base
-                    else:
-                        video_prompt = f"""
-                        The user concept is "{user_input}". Based on this and a simplified scene: {image_prompt}, create a video.
-                        Use a static close-up shot of the subject in a realistic style.
-                        """
-
-                    print(f"Attempting image-to-video generation (video attempt {video_attempt + 1}, total attempt {total_attempts}): {video_prompt}")
-                    operation = client.models.generate_videos(
-                        model="veo-2.0-generate-001",
-                        prompt=video_prompt,
-                        image=generated_image.image,
-                        config=types.GenerateVideosConfig(
-                            aspect_ratio="9:16",
-                            number_of_videos=1,
-                            duration_seconds=8,
-                            negative_prompt="blurry, low quality, text, letters"
-                        )
+            # First, try image-to-video generation (only once)
+            try:
+                video_prompt = f"""
+                The user concept is "{user_input}". Based on this and the scene: {image_prompt}, create a video.
+                Use a close-up shot with a slow dolly shot circling around the subject, 
+                using shallow focus on the main subject to emphasize details, in a realistic style with cinematic lighting.
+                """
+                print(f"Attempting image-to-video generation (total attempt {total_attempts}): {video_prompt}")
+                operation = client.models.generate_videos(
+                    model="veo-2.0-generate-001",
+                    prompt=video_prompt,
+                    image=generated_image.image,
+                    config=types.GenerateVideosConfig(
+                        aspect_ratio="9:16",
+                        number_of_videos=1,
+                        duration_seconds=8,
+                        negative_prompt="blurry, low quality, text, letters"
                     )
-                    # Wait for video to generate
-                    while not operation.done:
-                        time.sleep(20)
-                        operation = client.operations.get(operation)
-                    
-                    # Log detailed information about the operation
-                    print(f"Video generation operation completed: {operation}")
-                    print(f"Operation done: {operation.done}")
-                    print(f"Operation error: {operation.error}")
-                    if operation.error:
-                        print(f"Operation error message: {operation.error.message}")
-                        if hasattr(operation.error, 'code'):
-                            print(f"Operation error code: {operation.error.code}")
-                        if hasattr(operation.error, 'details'):
-                            print(f"Operation error details: {operation.error.details}")
-                    print(f"Operation response: {operation.response}")
-                    if operation.response:
-                        print(f"Operation response has generated_videos: {hasattr(operation.response, 'generated_videos')}")
-                        if hasattr(operation.response, 'generated_videos'):
-                            print(f"Generated videos: {operation.response.generated_videos}")
-                        else:
-                            print("No generated_videos attribute in response")
-
-                    # Enhanced error handling for video generation response
-                    if operation.error:
-                        raise ValueError(f"Video generation operation failed with error: {operation.error.message}")
-                    if operation.response is None:
-                        raise ValueError("Video generation operation failed: No response")
-                    if not hasattr(operation.response, 'generated_videos') or operation.response.generated_videos is None:
-                        raise ValueError("Video generation operation failed: No generated_videos in response")
-                    
-                    # Process the single generated video
-                    if len(operation.response.generated_videos) > 0:
-                        video = operation.response.generated_videos[0]
-                        if video is None or not hasattr(video, 'video'):
-                            raise ValueError("Video is invalid or missing video data")
-                        fname = 'with_image_input.mp4'
-                        print(f"Generated video: {fname}")
-                        # Download the video and get the raw bytes
-                        video_data = client.files.download(file=video.video)
-                        # Ensure video_data is in bytes
-                        if isinstance(video_data, bytes):
-                            video_bytes = video_data
-                        else:
-                            # If video_data is a file-like object, read the bytes
-                            video_buffer = BytesIO()
-                            for chunk in video_data:
-                                video_buffer.write(chunk)
-                            video_bytes = video_buffer.getvalue()
-                        # Encode the video bytes as base64
-                        video_base64 = base64.b64encode(video_bytes).decode()
-                        video_generated = True
-                        # Successfully generated video, return the result
-                        return {
-                            'text': text,
-                            'image_base64': img_str,
-                            'video_base64': video_base64,
-                            'ideas': ideas
-                        }
+                )
+                # Wait for video to generate
+                while not operation.done:
+                    time.sleep(20)
+                    operation = client.operations.get(operation)
+                
+                # Log detailed information about the operation
+                print(f"Video generation operation completed: {operation}")
+                print(f"Operation done: {operation.done}")
+                print(f"Operation error: {operation.error}")
+                if operation.error:
+                    print(f"Operation error message: {operation.error.message}")
+                    if hasattr(operation.error, 'code'):
+                        print(f"Operation error code: {operation.error.code}")
+                    if hasattr(operation.error, 'details'):
+                        print(f"Operation error details: {operation.error.details}")
+                print(f"Operation response: {operation.response}")
+                if operation.response:
+                    print(f"Operation response has generated_videos: {hasattr(operation.response, 'generated_videos')}")
+                    if hasattr(operation.response, 'generated_videos'):
+                        print(f"Generated videos: {operation.response.generated_videos}")
                     else:
-                        raise ValueError("No video was generated")
-                except Exception as e:
-                    print(f"Error generating video (image-to-video attempt {video_attempt + 1}, total attempt {total_attempts}): {e}")
-                    if video_attempt == max_video_retries_per_image - 1:
-                        print("Image-to-video generation failed after all attempts. Falling back to text-to-video generation.")
-                        break
-                    continue  # Retry image-to-video generation with a modified prompt
+                        print("No generated_videos attribute in response")
+
+                # Enhanced error handling for video generation response
+                if operation.error:
+                    raise ValueError(f"Video generation operation failed with error: {operation.error.message}")
+                if operation.response is None:
+                    raise ValueError("Video generation operation failed: No response")
+                if not hasattr(operation.response, 'generated_videos') or operation.response.generated_videos is None:
+                    raise ValueError("Video generation operation failed: No generated_videos in response")
+                
+                # Process the single generated video
+                if len(operation.response.generated_videos) > 0:
+                    video = operation.response.generated_videos[0]
+                    if video is None or not hasattr(video, 'video'):
+                        raise ValueError("Video is invalid or missing video data")
+                    fname = 'with_image_input.mp4'
+                    print(f"Generated video: {fname}")
+                    # Download the video and get the raw bytes
+                    video_data = client.files.download(file=video.video)
+                    # Ensure video_data is in bytes
+                    if isinstance(video_data, bytes):
+                        video_bytes = video_data
+                    else:
+                        # If video_data is a file-like object, read the bytes
+                        video_buffer = BytesIO()
+                        for chunk in video_data:
+                            video_buffer.write(chunk)
+                        video_bytes = video_buffer.getvalue()
+                    # Encode the video bytes as base64
+                    video_base64 = base64.b64encode(video_bytes).decode()
+                    video_generated = True
+                    # Successfully generated video, return the result
+                    return {
+                        'text': text,
+                        'image_base64': img_str,
+                        'video_base64': video_base64,
+                        'ideas': ideas
+                    }
+                else:
+                    raise ValueError("No video was generated")
+            except Exception as e:
+                print(f"Error generating video (image-to-video, total attempt {total_attempts}): {e}")
+                print("Image-to-video generation failed. Falling back to text-to-video generation.")
 
             # If image-to-video generation failed, try text-to-video generation
             if not video_generated:
@@ -487,7 +424,7 @@ def generate_item(user_input, ideas, generate_video=False, max_retries=3):
                                     'video_base64': video_base64,
                                     'ideas': ideas
                                 }
-                            # Both image-to-video and text-to-video failed, break to outer loop to try a new image
+                            # Text-to-video failed, break to outer loop to try a new image
                             print(f"Text-to-video generation failed after {max_video_retries_per_image} attempts. Selecting a new idea and generating a new image.")
                             break
                         continue  # Retry text-to-video generation with a modified prompt