Update app.py

app.py

@@ -1,56 +1,32 @@
-import gradio as gr
 import os
-import sys
-import tempfile
-import uuid
-import torch
 import subprocess
-from pathlib import Path
-
-if not os.path.exists("Open-Sora"):
-    print("Esecuzione setup iniziale...")
-    subprocess.run(["bash", "setup.sh"], check=True)
-    print("Setup completato!")
+import gradio as gr
+import torch
+import sys
 
-# Verifica la disponibilità della GPU
-print("CUDA disponibile:", torch.cuda.is_available())
+# Verifica la versione di CUDA
+print(f"CUDA disponibile: {torch.cuda.is_available()}")
 if torch.cuda.is_available():
-    print("Dispositivo CUDA:", torch.cuda.get_device_name(0))
-    print("Memoria GPU totale:", torch.cuda.get_device_properties(0).total_memory / 1e9, "GB")
-
-# Scarica i modelli se necessario
-model_dir = Path("./ckpts")
-if not model_dir.exists():
-    print("Scaricamento del modello Open-Sora...")
-    os.system("mkdir -p ./ckpts")
-    os.system("huggingface-cli download hpcai-tech/Open-Sora-v2 --local-dir ./ckpts")
-    print("Modello scaricato!")
-else:
-    print("Modello già presente nella directory ckpts")
+    print(f"CUDA versione: {torch.version.cuda}")
+    print(f"Dispositivo: {torch.cuda.get_device_name(0)}")
 
-# Directory per i video generati
-outputs_dir = Path("./outputs")
-outputs_dir.mkdir(exist_ok=True)
+# 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...")
 
-def generate_video(prompt, motion_score=4, aspect_ratio="1:1", num_frames=33):
-    """
-    Genera un video usando Open-Sora in base al prompt fornito.
-    
-    Args:
-        prompt: Il testo descrittivo per la generazione
-        motion_score: Intensità del movimento (1-7)
-        aspect_ratio: Proporzioni del video (1:1, 16:9, 9:16, 2.39:1)
-        num_frames: Numero di frame (deve essere 4k+1 e <129)
-    
-    Returns:
-        Tupla (stato, percorso_video)
-    """
+# Implementazione dell'inferenza seguendo la guida
+def generate_video(prompt):
     try:
-        # Crea un ID unico per il file di output
-        output_id = str(uuid.uuid4())
-        output_path = outputs_dir / f"{output_id}.mp4"
+        # Directory per i video generati
+        if not os.path.exists("outputs"):
+            os.makedirs("outputs")
         
-        # Crea il comando seguendo la guida ufficiale
+        # Comando esattamente come nella guida
         cmd = [
             "torchrun", 
             "--nproc_per_node", "1", 
@@ -58,39 +34,33 @@ def generate_video(prompt, motion_score=4, aspect_ratio="1:1", num_frames=33):
             "scripts/diffusion/inference.py", 
             "configs/diffusion/inference/256px.py",
             "--prompt", prompt,
-            "--motion-score", str(motion_score),
-            "--aspect_ratio", aspect_ratio,
-            "--num_frames", str(num_frames),
-            "--save-dir", str(outputs_dir)
+            "--save-dir", "outputs"
         ]
         
         print(f"Esecuzione comando: {' '.join(cmd)}")
         
-        # Esegui il comando e cattura l'output
-        process = subprocess.Popen(
+        # Esegui il comando nella directory di Open-Sora
+        process = subprocess.run(
             cmd, 
-            stdout=subprocess.PIPE, 
-            stderr=subprocess.PIPE,
-            cwd="Open-Sora"  # Imposta la directory di lavoro
+            cwd="Open-Sora",
+            capture_output=True,
+            text=True,
+            check=False
         )
         
-        stdout, stderr = process.communicate()
-        print("STDOUT:", stdout.decode())
-        
         if process.returncode != 0:
-            print("STDERR:", stderr.decode())
-            return f"Errore: {stderr.decode()}", None
+            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
         
-        # Trova il video generato più recente se il file specifico non è trovato
-        if not output_path.exists():
-            video_files = list(outputs_dir.glob("*.mp4"))
-            if video_files:
-                # Ordina per data di creazione e prendi il più recente
-                output_path = sorted(video_files, key=lambda f: f.stat().st_mtime, reverse=True)[0]
-            else:
-                return "Errore: 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", str(output_path)
+        return "Generazione completata", video_path
     
     except Exception as e:
         print(f"Eccezione: {str(e)}")
@@ -106,49 +76,15 @@ with gr.Blocks() as demo:
                 label="Descrivi il video che vuoi generare",
                 placeholder="Es. Un panda che mangia bambù in una foresta, stile cinematografico"
             )
-            
-            with gr.Row():
-                motion_score = gr.Slider(
-                    minimum=1, 
-                    maximum=7, 
-                    value=4, 
-                    step=1, 
-                    label="Intensità movimento (1-7)"
-                )
-                
-                aspect_ratio = gr.Dropdown(
-                    choices=["1:1", "16:9", "9:16", "2.39:1"], 
-                    value="1:1", 
-                    label="Proporzioni"
-                )
-            
-            num_frames = gr.Slider(
-                minimum=5, 
-                maximum=125, 
-                value=33, 
-                step=4, 
-                label="Numero di frame (4k+1)"
-            )
-            
             generate_btn = gr.Button("Genera Video")
         
         with gr.Column():
             status_output = gr.Textbox(label="Stato")
             video_output = gr.Video(label="Video Generato")
     
-    # Esempi di prompt
-    gr.Examples(
-        examples=[
-            ["Un gatto che gioca con un gomitolo di lana, stile cinematografico", 4, "1:1", 33],
-            ["Cascata in una foresta pluviale, raggi di sole, alta qualità", 3, "16:9", 33],
-            ["Astronave che viaggia attraverso un campo di asteroidi, stile 3D", 5, "16:9", 33],
-        ],
-        inputs=[prompt_input, motion_score, aspect_ratio, num_frames],
-    )
-    
     generate_btn.click(
         fn=generate_video,
-        inputs=[prompt_input, motion_score, aspect_ratio, num_frames],
+        inputs=[prompt_input],
         outputs=[status_output, video_output]
     )