app.py

import os
import subprocess
import gradio as gr
import torch
import sys

# Verifica la versione di CUDA
print(f"CUDA disponibile: {torch.cuda.is_available()}")
if torch.cuda.is_available():
    print(f"CUDA versione: {torch.version.cuda}")
    print(f"Dispositivo: {torch.cuda.get_device_name(0)}")

# Esegui lo script di setup se necessario
if not os.path.exists("Open-Sora"):
    print("Esecuzione setup iniziale...")
    try:
        subprocess.run(["bash", "setup.sh"], check=True)
    except subprocess.CalledProcessError as e:
        print(f"Errore durante l'esecuzione di setup.sh: {e}")
        print("Continuando comunque...")

# Implementazione dell'inferenza seguendo la guida
def generate_video(prompt):
    try:
        # Directory per i video generati
        if not os.path.exists("outputs"):
            os.makedirs("outputs")
        
        # Comando esattamente come nella guida
        cmd = [
            "torchrun", 
            "--nproc_per_node", "1", 
            "--standalone", 
            "scripts/diffusion/inference.py", 
            "configs/diffusion/inference/256px.py",
            "--prompt", prompt,
            "--save-dir", "outputs"
        ]
        
        print(f"Esecuzione comando: {' '.join(cmd)}")
        
        # Esegui il comando nella directory di Open-Sora
        process = subprocess.run(
            cmd, 
            cwd="Open-Sora",
            capture_output=True,
            text=True,
            check=False
        )
        
        if process.returncode != 0:
            print(f"Errore: {process.stderr}")
            return "Errore durante la generazione", None
        
        # Cerca il video generato più recente
        video_files = [f for f in os.listdir("outputs") if f.endswith(".mp4")]
        if not video_files:
            return "Nessun video generato trovato", None
        
        # Ordina per data di creazione e prendi il più recente
        video_path = os.path.join("outputs", sorted(video_files, key=lambda x: os.path.getmtime(os.path.join("outputs", x)), reverse=True)[0])
        
        return "Generazione completata", video_path
    
    except Exception as e:
        print(f"Eccezione: {str(e)}")
        return f"Errore: {str(e)}", None

# Interfaccia Gradio
with gr.Blocks() as demo:
    gr.Markdown("# Generatore di Video con Open-Sora")
    
    with gr.Row():
        with gr.Column():
            prompt_input = gr.Textbox(
                label="Descrivi il video che vuoi generare",
                placeholder="Es. Un panda che mangia bambù in una foresta, stile cinematografico"
            )
            generate_btn = gr.Button("Genera Video")
        
        with gr.Column():
            status_output = gr.Textbox(label="Stato")
            video_output = gr.Video(label="Video Generato")
    
    generate_btn.click(
        fn=generate_video,
        inputs=[prompt_input],
        outputs=[status_output, video_output]
    )

# Avvia l'interfaccia
demo.launch()