Generation Pipeline

topic_clean = topic[:30].replace(' ', '_').replace(':', '').replace('/', '_')
topic_clean = topic_clean.replace('"', '').replace("'", '').replace('?', '').replace('!', '')

generation_id = topic_clean
update_progress(generation_id, 0, "started", "🚀 Starting generation...")

{
  "topic": "Newton's Third Law of Motion",
  "total_slides": 5,
  "slides": [
    {
      "slide_number": 1,
      "title": "Newton's Third Law",
      "content_text": "For every action, there is an equal and opposite reaction",
      "needs_image": false,
      "image_keyword": "",
      "needs_animation": true,
      "animation_description": "Show rocket with force vectors",
      "duration": 6.0
    }
  ]
}

try:
    content_data = content_gen.generate_content(topic, num_slides)
except Exception as e:
    print(f"Content generation error: {e}")
    traceback.print_exc()
    raise

{
  "topic": "Newton's Third Law of Motion",
  "total_duration": 30.0,
  "language": "english",
  "slide_scripts": [
    {
      "slide_number": 1,
      "start_time": 0.0,
      "end_time": 6.0,
      "narration_text": "Today we'll explore Newton's Third Law, which states that for every action, there is an equal and opposite reaction."
    }
  ]
}

response = requests.post(
    Config.SARVAM_TTS_URL,
    headers={"API-Subscription-Key": Config.SARVAM_API_KEY},
    json={
        "text": narration_text,
        "language_code": language_code,
        "model": Config.SARVAM_MODEL,
        "speaker": "meera"  # or other voices
    }
)
audio_data = response.json()["audios"][0]

audio_path = voice_gen.combine_slide_audios(slide_audio_paths, topic)
# Output: outputs/audio/{topic}_combined.mp3

from moviepy import concatenate_audioclips, AudioFileClip

audio_clips = [AudioFileClip(path) for path in slide_audio_paths.values()]
combined = concatenate_audioclips(audio_clips)
combined.write_audiofile(output_path, codec='mp3')

for idx, slide in enumerate(content_data['slides'], 1):
    visual_progress = 50 + int((idx / total_slides) * 30)
    
    has_animation = slide.get('needs_animation', False)
    has_image = slide.get('needs_image', False)
    
    # Mutual exclusivity enforcement
    if has_animation and has_image:
        print(f"⚠️ ERROR: Slide {slide_num} has BOTH flags!")
        has_image = False  # Animation takes priority

text_slide = slide_renderer.create_text_slide(
    slide['title'],
    slide['content_text'],
    slide_num,
    topic
)
slide_paths[slide_num] = text_slide
# Output: PNG with centered title and content

print(f"\n📊 Final visual breakdown:")
print(f"   Animations: {len(animation_paths)}")
print(f"   Images: {len(image_paths)}")
print(f"   Text-only: {total_slides - len(animation_paths) - len(image_paths)}")

if abs(final_video.duration - audio.duration) > 0.5:
    print(f"⚠️ Warning: Video ({final_video.duration:.1f}s) doesn't match audio ({audio.duration:.1f}s)")

if (response.data.status === "success") {
  const generatedData = {
    content: response.data.content_data,
    script: response.data.script_data,
    videoPath: response.data.video_path,
    videoFilename: response.data.video_filename
  };
  onGenerationComplete(generatedData);
}

try:
    content_data = content_gen.generate_content(topic, num_slides)
except Exception as e:
    error_msg = f"Error: {str(e)}"
    print(f"Full error:\n{traceback.format_exc()}")
    update_progress(generation_id, 0, "error", f"❌ {error_msg}")
    raise HTTPException(status_code=500, detail=error_msg)

try:
    audio_path = voice_gen.generate_voice_for_slide(...)
except Exception as e:
    print(f"Error generating audio for slide {slide_num}: {e}")
    # Use estimated duration from content
    actual_durations[slide_num] = slide_script['end_time'] - slide_script['start_time']

try:
    image_path = image_fetcher.fetch_image(keyword, slide_num, topic)
    if not image_path:
        raise ValueError("Image fetch returned empty path")
except Exception as e:
    print(f"❌ Error fetching image for slide {slide_num}: {e}")
    # Fallback to text-only slide
    text_slide = slide_renderer.create_text_slide(...)
    slide_paths[slide_num] = text_slide

try:
    animation_code = manim_gen.generate_animation_code(slide, duration)
    video_path = video_renderer.render_manim_animation(code_path, scene_name)
except Exception as e:
    print(f"❌ Error generating animation for slide {slide_num}: {e}")
    traceback.print_exc()
    # Fallback to text-only slide
    text_slide = slide_renderer.create_text_slide(...)
    slide_paths[slide_num] = text_slide

def update_progress(generation_id: str, progress: int, status: str, message: str):
    timestamp = datetime.now().strftime("%H:%M:%S")
    generation_status[generation_id] = {
        "status": status,
        "progress": progress,
        "message": message,
        "timestamp": timestamp
    }
    print(f"[{timestamp}] {message}")

eventSource.onmessage = (event) => {
  const data = JSON.parse(event.data);
  setProgress(data.progress);
  setStatus(data.status);
  setMessage(data.message);
};