Update app.py

app.py

@@ -98,7 +98,6 @@ except Exception as e:
     logger.exception("Failed to initialize Google Clients/Models."); st.error(f"🚨 Failed Init: {e}", icon="🚨"); st.stop()
 
 # --- Define Pydantic Schemas (Using V2 Syntax) ---
-# (Schemas remain the same as previous version)
 class StorySegment(BaseModel):
     scene_id: int = Field(..., ge=0)
     image_prompt: str = Field(..., min_length=10, max_length=250)
@@ -126,15 +125,29 @@ class ChronoWeaveResponse(BaseModel):
         return self
 
 # --- Helper Functions ---
-# (wave_file_writer and generate_audio_live_async remain the same)
+
+# CORRECTED wave_file_writer function with proper indentation
 @contextlib.contextmanager
 def wave_file_writer(filename: str, channels: int = 1, rate: int = AUDIO_SAMPLING_RATE, sample_width: int = 2):
     """Context manager to safely write WAV files."""
-    wf = None; try: wf = wave.open(filename, "wb"); wf.setnchannels(channels); wf.setsampwidth(sample_width); wf.setframerate(rate); yield wf
-    except Exception as e: logger.error(f"Error opening/configuring wave file {filename}: {e}"); raise
+    wf = None
+    try:
+        # Indent these lines correctly under the try:
+        wf = wave.open(filename, "wb")
+        wf.setnchannels(channels)
+        wf.setsampwidth(sample_width) # 2 bytes for 16-bit audio
+        wf.setframerate(rate)
+        yield wf # yield remains inside the try block
+    except Exception as e:
+        logger.error(f"Error opening/configuring wave file {filename}: {e}")
+        raise # Re-raise the exception
     finally:
-        if wf: try: wf.close()
-        except Exception as e_close: logger.error(f"Error closing wave file {filename}: {e_close}")
+        if wf:
+            try:
+                wf.close()
+            except Exception as e_close:
+                logger.error(f"Error closing wave file {filename}: {e_close}")
+
 
 async def generate_audio_live_async(api_text: str, output_filename: str, voice: Optional[str] = None) -> Optional[str]:
     """Generates audio using Gemini Live API (async version) via the GenerativeModel."""
@@ -184,49 +197,10 @@ def generate_image_imagen(prompt: str, aspect_ratio: str = "1:1", task_id: str =
     logger.info(f"🖼️ [{task_id}] Requesting image: '{prompt[:70]}...' (Aspect: {aspect_ratio})")
     logger.error(f"   ❌ [{task_id}] Image generation skipped: Function needs update to use Vertex AI SDK for Imagen.")
     st.error(f"Image generation for {task_id} skipped: Requires Vertex AI SDK implementation.", icon="🖼️")
-
-    # --- Placeholder for Vertex AI SDK Implementation ---
-    # Example conceptual structure (replace with actual Vertex AI SDK code):
-    # try:
-    #     from vertexai.preview.generative_models import ImageGenerationModel # Example import
-    #
-    #     # Assuming vertex_image_model is initialized globally or passed in
-    #     # vertex_image_model = ImageGenerationModel.from_pretrained("imagegeneration@006") # Example init
-    #
-    #     response = vertex_image_model.generate_images(
-    #         prompt=f"Simple kids animation style... NO humans... Aspect ratio {aspect_ratio}. Scene: {prompt}",
-    #         number_of_images=1,
-    #         # Add other relevant parameters like negative_prompt, seed, etc.
-    #     )
-    #
-    #     if response.images:
-    #         image_bytes = response.images[0]._image_bytes # Access image bytes (check actual attribute name)
-    #         image = Image.open(BytesIO(image_bytes))
-    #         logger.info(f"   ✅ [{task_id}] Image generated (Vertex AI).")
-    #         # Check safety attributes if available in Vertex AI response
-    #         return image
-    #     else:
-    #         # Check Vertex AI response for errors / blocking reasons
-    #         logger.warning(f"   ⚠️ [{task_id}] No image data received from Vertex AI.")
-    #         st.warning(f"No image data {task_id} (Vertex AI).", icon="🖼️")
-    #         return None
-    #
-    # except ImportError:
-    #      logger.error(f"   ❌ [{task_id}] Vertex AI SDK ('google-cloud-aiplatform') not installed.")
-    #      st.error(f"Vertex AI SDK not installed for image generation.", icon="🚨")
-    #      return None
-    # except Exception as e:
-    #      logger.exception(f"   ❌ [{task_id}] Vertex AI image generation failed: {e}")
-    #      st.error(f"Image gen failed {task_id} (Vertex AI): {e}", icon="🖼️")
-    #      return None
-    # --- End Placeholder ---
-
-    # Keep the old failing logic commented out or remove, returning None for now
-    return None # Return None until Vertex AI SDK is implemented
-
+    # Return None because the current method is known to fail based on previous logs
+    return None
 
 # --- Streamlit UI Elements ---
-# (Identical to previous version)
 st.sidebar.header("⚙️ Configuration")
 if GOOGLE_API_KEY: st.sidebar.success("Google API Key Loaded", icon="✅")
 else: st.sidebar.error("Google API Key Missing!", icon="🚨")
@@ -249,16 +223,13 @@ if generate_button:
         except OSError as e: st.error(f"🚨 Failed create temp dir {temp_dir}: {e}", icon="📂"); st.stop()
         final_video_paths, generation_errors = {}, {}
 
-        # --- 1. Generate Narrative Structure ---
         chrono_response: Optional[ChronoWeaveResponse] = None
         with st.spinner("Generating narrative structure... 🤔"): chrono_response = generate_story_sequence_chrono(theme, num_scenes, num_timelines, divergence_prompt)
 
         if chrono_response:
-            # --- 2. Process Each Timeline ---
             overall_start_time = time.time(); all_timelines_successful = True
             with st.status("Generating assets and composing videos...", expanded=True) as status:
                 for timeline_index, timeline in enumerate(chrono_response.timelines):
-                    # ... (Timeline setup - same as before) ...
                     timeline_id, divergence, segments = timeline.timeline_id, timeline.divergence_reason, timeline.segments
                     timeline_label = f"Timeline {timeline_id}"; st.subheader(f"Processing {timeline_label}: {divergence}")
                     logger.info(f"--- Processing {timeline_label} (Idx: {timeline_index}) ---"); generation_errors[timeline_id] = []
@@ -266,7 +237,6 @@ if generate_button:
                     timeline_start_time = time.time(); scene_success_count = 0
 
                     for scene_index, segment in enumerate(segments):
-                        # ... (Scene setup - same as before) ...
                         scene_id = segment.scene_id; task_id = f"T{timeline_id}_S{scene_id}"
                         status.update(label=f"Processing {timeline_label}, Scene {scene_id + 1}/{len(segments)}...")
                         st.markdown(f"--- **Scene {scene_id + 1} ({task_id})** ---")
@@ -275,28 +245,22 @@ if generate_button:
                         st.write(f"   *Img Prompt:* {segment.image_prompt}" + (f" *(Mod: {segment.timeline_visual_modifier})*" if segment.timeline_visual_modifier else "")); st.write(f"   *Audio Text:* {segment.audio_text}")
 
                         # --- 2a. Image Generation ---
-                        # !!! This call will currently return None until Vertex AI SDK is implemented !!!
                         generated_image: Optional[Image.Image] = None
                         with st.spinner(f"[{task_id}] Generating image... 🎨"):
                             combined_prompt = segment.image_prompt
                             if segment.character_description: combined_prompt += f" Featuring: {segment.character_description}"
                             if segment.timeline_visual_modifier: combined_prompt += f" Style hint: {segment.timeline_visual_modifier}."
-                            generated_image = generate_image_imagen(combined_prompt, aspect_ratio, task_id) # Needs Vertex AI SDK update
+                            generated_image = generate_image_imagen(combined_prompt, aspect_ratio, task_id) # <<< Needs Vertex AI SDK update
 
-                        if generated_image: # This block will likely not execute currently
+                        if generated_image:
                             image_path = os.path.join(temp_dir, f"{task_id}_image.png")
                             try: generated_image.save(image_path); temp_image_files[scene_id] = image_path; st.image(generated_image, width=180, caption=f"Scene {scene_id+1}")
                             except Exception as e: logger.error(f"   ❌ [{task_id}] Img save error: {e}"); st.error(f"Save image {task_id} failed.", icon="💾"); scene_has_error = True; generation_errors[timeline_id].append(f"S{scene_id+1}: Img save fail.")
-                        else:
-                            # Error logged within generate_image_imagen if it fails
-                            scene_has_error = True; generation_errors[timeline_id].append(f"S{scene_id+1}: Img gen fail.")
-                            continue # Skip rest of scene processing if image fails
+                        else: scene_has_error = True; generation_errors[timeline_id].append(f"S{scene_id+1}: Img gen fail."); continue
 
                         # --- 2b. Audio Generation ---
-                        # (Audio generation logic remains the same, but won't be reached if image fails)
                         generated_audio_path: Optional[str] = None
                         if not scene_has_error:
-                             # ... (Audio generation logic - same as before) ...
                             with st.spinner(f"[{task_id}] Generating audio... 🔊"):
                                 audio_path_temp = os.path.join(temp_dir, f"{task_id}_audio.wav")
                                 try: generated_audio_path = asyncio.run(generate_audio_live_async(segment.audio_text, audio_path_temp, audio_voice))
@@ -305,13 +269,12 @@ if generate_button:
                             if generated_audio_path:
                                 temp_audio_files[scene_id] = generated_audio_path; try: open(generated_audio_path,'rb') as ap: st.audio(ap.read(), format='audio/wav')
                                 except Exception as e: logger.warning(f"   ⚠️ [{task_id}] Audio preview error: {e}")
-                            else: scene_has_error = True; generation_errors[timeline_id].append(f"S{scene_id+1}: Audio gen fail."); continue # Skip clip if audio fails
+                            else: scene_has_error = True; generation_errors[timeline_id].append(f"S{scene_id+1}: Audio gen fail."); continue
 
                         # --- 2c. Create Video Clip ---
-                        # (Clip creation logic remains the same, but won't be reached if image/audio fails)
                         if not scene_has_error and scene_id in temp_image_files and scene_id in temp_audio_files:
-                            # ... (Video clip creation logic - same as before) ...
-                            st.write(f"   🎬 Creating clip S{scene_id+1}..."); img_path, aud_path = temp_image_files[scene_id], temp_audio_files[scene_id]
+                            st.write(f"   🎬 Creating clip S{scene_id+1}...")
+                            img_path, aud_path = temp_image_files[scene_id], temp_audio_files[scene_id]
                             audio_clip_instance, image_clip_instance, composite_clip = None, None, None
                             try:
                                 if not os.path.exists(img_path): raise FileNotFoundError(f"Img missing: {img_path}")
@@ -321,18 +284,14 @@ if generate_button:
                                 composite_clip = image_clip_instance.set_audio(audio_clip_instance); video_clips.append(composite_clip)
                                 logger.info(f"      ✅ [{task_id}] Clip created (Dur: {audio_clip_instance.duration:.2f}s)."); st.write(f"      ✅ Clip created (Dur: {audio_clip_instance.duration:.2f}s)."); scene_success_count += 1
                             except Exception as e: logger.exception(f"      ❌ [{task_id}] Failed clip creation: {e}"); st.error(f"Failed clip {task_id}: {e}", icon="🎬"); scene_has_error = True; generation_errors[timeline_id].append(f"S{scene_id+1}: Clip fail.")
-                            finally: # Ensure clips are closed even on error here
+                            finally:
                                 if audio_clip_instance: audio_clip_instance.close();
                                 if image_clip_instance: image_clip_instance.close()
-                                # Don't remove files here on error, let assembly logic handle based on overall success
 
                     # --- 2d. Assemble Timeline Video ---
-                    # (Video assembly logic remains the same)
                     timeline_duration = time.time() - timeline_start_time
-                    if video_clips and scene_success_count == len(segments): # Only if ALL scenes succeeded
-                        # ... (Video assembly logic) ...
-                         status.update(label=f"Composing video {timeline_label}...")
-                         st.write(f"🎞️ Assembling video {timeline_label}..."); logger.info(f"🎞️ Assembling video {timeline_label}...")
+                    if video_clips and scene_success_count == len(segments):
+                         status.update(label=f"Composing video {timeline_label}..."); st.write(f"🎞️ Assembling video {timeline_label}..."); logger.info(f"🎞️ Assembling video {timeline_label}...")
                          output_filename = os.path.join(temp_dir, f"timeline_{timeline_id}_final.mp4"); final_timeline_video = None
                          try: final_timeline_video = concatenate_videoclips(video_clips, method="compose"); final_timeline_video.write_videofile(output_filename, fps=VIDEO_FPS, codec=VIDEO_CODEC, audio_codec=AUDIO_CODEC, logger=None); final_video_paths[timeline_id] = output_filename; logger.info(f"   ✅ [{timeline_label}] Video saved: {os.path.basename(output_filename)}"); st.success(f"✅ Video {timeline_label} completed in {timeline_duration:.2f}s.")
                          except Exception as e: logger.exception(f"   ❌ [{timeline_label}] Video assembly failed: {e}"); st.error(f"Assemble video {timeline_label} failed: {e}", icon="📼"); all_timelines_successful = False; generation_errors[timeline_id].append(f"T{timeline_id}: Assembly fail.")
@@ -345,7 +304,6 @@ if generate_button:
                     if generation_errors[timeline_id]: logger.error(f"Errors {timeline_label}: {generation_errors[timeline_id]}")
 
                 # --- End of Timelines Loop ---
-                # (Final status update logic remains the same)
                 overall_duration = time.time() - overall_start_time
                 if all_timelines_successful and final_video_paths: status_msg = f"Complete! ({len(final_video_paths)} videos in {overall_duration:.2f}s)"; status.update(label=status_msg, state="complete", expanded=False); logger.info(status_msg)
                 elif final_video_paths: status_msg = f"Partially Complete ({len(final_video_paths)} videos, errors). {overall_duration:.2f}s"; status.update(label=status_msg, state="warning", expanded=True); logger.warning(status_msg)
@@ -354,7 +312,6 @@ if generate_button:
             # --- 3. Display Results ---
             st.header("🎬 Generated Timelines")
             if final_video_paths:
-                # ... (Display logic - same as before) ...
                 sorted_timeline_ids = sorted(final_video_paths.keys()); num_cols = min(len(sorted_timeline_ids), 3); cols = st.columns(num_cols)
                 for idx, timeline_id in enumerate(sorted_timeline_ids):
                     col = cols[idx % num_cols]; video_path = final_video_paths[timeline_id]
@@ -366,33 +323,30 @@ if generate_button:
                             with open(video_path, 'rb') as vf: video_bytes = vf.read()
                             st.video(video_bytes); logger.info(f"Displaying T{timeline_id}")
                             st.download_button(f"Download T{timeline_id}", video_bytes, f"timeline_{timeline_id}.mp4", "video/mp4", key=f"dl_{timeline_id}")
-                            if generation_errors.get(timeline_id): # Check if errors exist for this timeline
-                                # Filter out non-assembly errors for display below video
+                            if generation_errors.get(timeline_id):
                                 scene_errors = [err for err in generation_errors[timeline_id] if not err.startswith(f"T{timeline_id}:")]
                                 if scene_errors:
                                      with st.expander(f"⚠️ View {len(scene_errors)} Scene Issues"):
-                                         for err in scene_errors: st.warning(f"- {err}") # Use standard loop
+                                         # Use standard loop here to avoid ValueError
+                                         for err in scene_errors:
+                                             st.warning(f"- {err}")
                         except FileNotFoundError: logger.error(f"Video missing: {video_path}"); st.error(f"Error: Video missing T{timeline_id}.", icon="🚨")
                         except Exception as e: logger.exception(f"Display error {video_path}: {e}"); st.error(f"Display error T{timeline_id}: {e}", icon="🚨")
             else: # No videos generated
                 st.warning("No final videos were successfully generated.")
-                # Display summary of ALL errors using a standard loop to avoid ValueError
                 st.subheader("Summary of Generation Issues")
                 has_errors = any(generation_errors.values())
                 if has_errors:
                     with st.expander("View All Errors", expanded=True):
                         for tid, errors in generation_errors.items():
                             if errors:
-                                st.error(f"**Timeline {tid}:**") # Use markdown bold
+                                st.error(f"**Timeline {tid}:**")
                                 # Use standard for loop here - FIX for ValueError
                                 for msg in errors:
                                     st.error(f"  - {msg}")
-                else: # Should not happen if no videos, but handle defensively
-                     st.info("No generation errors were recorded.")
-
+                else: st.info("No generation errors recorded.")
 
             # --- 4. Cleanup ---
-            # (Cleanup logic remains the same)
             st.info(f"Attempting cleanup: {temp_dir}")
             try: shutil.rmtree(temp_dir); logger.info(f"✅ Temp dir removed: {temp_dir}"); st.success("✅ Temp files cleaned.")
             except Exception as e: logger.error(f"⚠️ Failed remove temp dir {temp_dir}: {e}"); st.warning(f"Could not remove temp files: {temp_dir}.", icon="⚠️")