app.py

import gradio as gr
from transformers import pipeline
import pyttsx3
from manim import Scene, Text, Write, config
from pydub import AudioSegment
import os

# Load pre-trained Hugging Face text generation model for comedy scripts
script_generator = pipeline("text-generation", model="gpt2")

# Function to generate a comedy script using GPT-2
def generate_comedy_script(prompt):
    result = script_generator(prompt, max_length=150, num_return_sequences=1)
    return result[0]["generated_text"]

# Text-to-Speech (TTS) using pyttsx3 for comedy
def text_to_speech(script, output_audio_file="script_audio.mp3"):
    engine = pyttsx3.init()
    engine.save_to_file(script, output_audio_file)
    engine.runAndWait()
    return output_audio_file

# Function to generate animated video using Manim (for comedy script)
def generate_animation(script, output_video_file="animated_script.mp4"):
    class ScriptAnimation(Scene):
        def construct(self):
            # Create a text object and animate it
            script_text = Text(script[:200])  # Limited text for simplicity
            self.play(Write(script_text))
    
    config.media_dir = "./media"
    config.output_file = output_video_file
    animation = ScriptAnimation()
    animation.render()
    
    return os.path.join(config.media_dir, "videos", output_video_file)

# Function to generate simple music (for kids content)
def generate_kids_music(theme, output_music_file="kids_music.wav"):
    # Simple sine wave generation using pydub for kids' music
    music = AudioSegment.sine(frequency=261.63)  # C4 note
    music += AudioSegment.sine(frequency=293.66)  # D4 note
    music += AudioSegment.sine(frequency=329.63)  # E4 note
    
    # Extend for more complexity, then export
    music.export(output_music_file, format="wav")
    return output_music_file

# Function to combine kids music with an animation
def generate_kids_animation_with_music(theme, output_video_file="kids_animation.mp4"):
    # Step 1: Generate kids music
    music_file = generate_kids_music(theme)
    
    # Step 2: Generate simple animation for the music (using text animation as a placeholder)
    class KidsMusicAnimation(Scene):
        def construct(self):
            music_text = Text("Kids Music: " + theme)
            self.play(Write(music_text))
    
    config.media_dir = "./media"
    config.output_file = output_video_file
    animation = KidsMusicAnimation()
    animation.render()
    
    return output_video_file, music_file

# Gradio interface to bring everything together
def generate_comedy_and_animation(prompt):
    # Comedy Script Generation
    script = generate_comedy_script(prompt)
    audio_file = text_to_speech(script)
    video_file = generate_animation(script)
    
    return script, audio_file, video_file

def generate_kids_content(theme):
    video_file, music_file = generate_kids_animation_with_music(theme)
    return music_file, video_file

# Gradio app for Comedy and Kids Content
with gr.Blocks() as app:
    gr.Markdown("## AI Comedy and Kids Content Generator")
    
    with gr.Tab("Generate Comedy Animation"):
        prompt_input = gr.Textbox(label="Comedy Prompt")
        generate_btn = gr.Button("Generate Comedy Script and Animation")
        comedy_script = gr.Textbox(label="Generated Script")
        comedy_audio = gr.Audio(label="Generated Audio")
        comedy_video = gr.Video(label="Generated Animation")
        
        generate_btn.click(
            generate_comedy_and_animation,
            inputs=prompt_input,
            outputs=[comedy_script, comedy_audio, comedy_video]
        )
    
    with gr.Tab("Generate Kids Music Animation"):
        theme_input = gr.Textbox(label="Kids Music Theme")
        generate_music_btn = gr.Button("Generate Kids Music and Animation")
        kids_music_audio = gr.Audio(label="Generated Music")
        kids_music_video = gr.Video(label="Generated Kids Animation")
        
        generate_music_btn.click(
            generate_kids_content,
            inputs=theme_input,
            outputs=[kids_music_audio, kids_music_video]
        )

app.launch()