Update app.py

app.py

@@ -17,7 +17,7 @@ except KeyError:
     raise ValueError("Please set the GEMINI_API_KEY environment variable.")
 client = genai.Client(api_key=api_key)
 
-# Define safety settings to disable all filters
+# Define safety settings to disable all filters for content generation
 SAFETY_SETTINGS = [
     types.SafetySetting(
         category=types.HarmCategory.HARM_CATEGORY_HARASSMENT,
@@ -184,6 +184,11 @@ def generate_item(user_input, ideas, generate_video=False, max_retries=3):
         total_attempts += 1
         
         # Step 1: Generate an image (retry up to max_retries times)
+        generated_image = None  # Initialize to None
+        text = None
+        img_str = None
+        image_prompt = None
+        
         for image_attempt in range(max_retries):
             selected_idea = random.choice(ideas)
             prompt = f"""
@@ -225,8 +230,7 @@ def generate_item(user_input, ideas, generate_video=False, max_retries=3):
                     prompt=image_prompt,
                     config=types.GenerateImagesConfig(
                         aspect_ratio="9:16",
-                        number_of_images=1,
-                        safety_settings=SAFETY_SETTINGS
+                        number_of_images=1
                     )
                 )
                 if imagen.generated_images and len(imagen.generated_images) > 0:
@@ -244,8 +248,9 @@ def generate_item(user_input, ideas, generate_video=False, max_retries=3):
                 else:
                     print(f"Image generation failed (image attempt {image_attempt + 1}, total attempt {total_attempts}): No images returned")
                     if image_attempt == max_retries - 1:
-                        # Last image attempt in this cycle, use a gray placeholder if max total attempts not reached
+                        # Last image attempt in this cycle
                         if total_attempts == max_total_attempts:
+                            # Max total attempts reached, use a gray placeholder
                             image = Image.new('RGB', (360, 640), color='gray')
                             buffered = BytesIO()
                             image.save(buffered, format="PNG")
@@ -256,8 +261,8 @@ def generate_item(user_input, ideas, generate_video=False, max_retries=3):
                                 'video_base64': None,
                                 'ideas': ideas
                             }
-                        # Otherwise, select a new idea and retry image generation in the next cycle
-                        continue
+                        # Otherwise, continue to next cycle
+                        break  # Exit inner loop to retry with new idea
             except Exception as e:
                 print(f"Error generating image (image attempt {image_attempt + 1}, total attempt {total_attempts}): {e}")
                 if image_attempt == max_retries - 1:
@@ -274,12 +279,15 @@ def generate_item(user_input, ideas, generate_video=False, max_retries=3):
                             'video_base64': None,
                             'ideas': ideas
                         }
-                    # Otherwise, select a new idea and retry image generation in the next cycle
-                    continue
+                    # 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)
-        if generate_video:
+        if generate_video and generated_image is not None:
             max_video_retries_per_image = 2  # Try video generation twice per image
+            video_generated = False
+
+            # First, try image-to-video generation
             for video_attempt in range(max_video_retries_per_image):
                 try:
                     # Base video prompt
@@ -297,7 +305,7 @@ def generate_item(user_input, ideas, generate_video=False, max_retries=3):
                         Use a static close-up shot of the subject in a realistic style.
                         """
 
-                    print(f"Attempting video generation (video attempt {video_attempt + 1}, total attempt {total_attempts}): {video_prompt}")
+                    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,
@@ -306,8 +314,7 @@ def generate_item(user_input, ideas, generate_video=False, max_retries=3):
                             aspect_ratio="9:16",
                             number_of_videos=1,
                             duration_seconds=8,
-                            negative_prompt="blurry, low quality, text, letters",
-                            safety_settings=SAFETY_SETTINGS
+                            negative_prompt="blurry, low quality, text, letters"
                         )
                     )
                     # Wait for video to generate
@@ -361,6 +368,7 @@ def generate_item(user_input, ideas, generate_video=False, max_retries=3):
                             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,
@@ -371,29 +379,128 @@ def generate_item(user_input, ideas, generate_video=False, max_retries=3):
                     else:
                         raise ValueError("No video was generated")
                 except Exception as e:
-                    print(f"Error generating video (video attempt {video_attempt + 1}, total attempt {total_attempts}): {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:
-                        if total_attempts == max_total_attempts:
-                            print("Max total attempts reached. Proceeding without video.")
-                            video_base64 = None
+                        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
+
+            # If image-to-video generation failed, try text-to-video generation
+            if not video_generated:
+                for video_attempt in range(max_video_retries_per_image):
+                    try:
+                        # Use the same video prompt but without the image
+                        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.
+                        """
+                        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 text-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,
+                            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 = 'text_to_video.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
                             }
-                        # Video generation failed with this image, break to outer loop to try a new image
-                        print(f"Video generation failed after {max_video_retries_per_image} attempts with this image. Selecting a new idea and generating a new image.")
-                        break
-                    continue  # Retry video generation with the same image but a modified prompt
+                        else:
+                            raise ValueError("No video was generated")
+                    except Exception as e:
+                        print(f"Error generating video (text-to-video attempt {video_attempt + 1}, total attempt {total_attempts}): {e}")
+                        if video_attempt == max_video_retries_per_image - 1:
+                            if total_attempts == max_total_attempts:
+                                print("Max total attempts reached. Proceeding without video.")
+                                video_base64 = None
+                                return {
+                                    'text': text,
+                                    'image_base64': img_str,
+                                    'video_base64': video_base64,
+                                    'ideas': ideas
+                                }
+                            # Both image-to-video and 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
         
-        # If video generation is not enabled or succeeded, return the result
-        return {
-            'text': text,
-            'image_base64': img_str,
-            'video_base64': video_base64,
-            'ideas': ideas
-        }
+        # If video generation is not enabled or image generation failed, return the result
+        if img_str is not None:
+            return {
+                'text': text,
+                'image_base64': img_str,
+                'video_base64': video_base64,
+                'ideas': ideas
+            }
+        # If img_str is None, continue to next cycle or fall back if max attempts reached
 
     # If max total attempts reached without success, use a gray placeholder image
     print("Max total attempts reached without successful image generation. Using placeholder.")