Update app.py

app.py

@@ -1,226 +1,194 @@
 """
-Generatore Video LEGGERO per CPU Basic HF Spaces
-Modello: zeroscope_v2_576w (\~1.3–1.8 GB in fp16)
-Target: \~4–9 GB RAM peak durante inferenza
+Generatore Video ULTRA-LEGGERO per HF Spaces CPU Basic (2026)
+- Modello: zeroscope_v2_dark_30x448x256 (\~1–1.5 GB fp16)
+- Risoluzione: 256x448, 8 frame, 15 steps
+- Target RAM peak: \~5–8 GB → dovrebbe sopravvivere su CPU Basic
 """
 
 import os
 import uuid
-import shutil
 import threading
 import queue
 import sqlite3
-from typing import Dict, List, Optional
-from pathlib import Path
-
+import gc
 import torch
 import gradio as gr
-from PIL import Image
 from diffusers import DiffusionPipeline
 from diffusers.utils import export_to_video
-from moviepy.editor import VideoFileClip, concatenate_videoclips
-
-# ==============================================================================
-# CONFIG
-# ==============================================================================
 
-CACHE_DIR = "/tmp/hf_cache"
-os.environ["HF_HOME"] = CACHE_DIR
-os.makedirs(CACHE_DIR, exist_ok=True)
-TMP_VIDEO_DIR = "/tmp/videos"
-os.makedirs(TMP_VIDEO_DIR, exist_ok=True)
+# Config per ridurre RAM
+os.environ["HF_HOME"] = "/tmp/hf_cache"
+os.makedirs("/tmp/hf_cache", exist_ok=True)
+TMP_DIR = "/tmp/videos"
+os.makedirs(TMP_DIR, exist_ok=True)
 
 # ==============================================================================
-# DATABASE semplice (persistente su disco)
+# DATABASE minimo su /tmp
 # ==============================================================================
+class MiniDB:
+    def __init__(self, path="/tmp/jobs.db"):
+        self.path = path
+        self.init()
 
-class DatabaseLavori:
-    def __init__(self, db_path: str = "/tmp/lavori.db"):
-        self.db_path = db_path
-        self.init_db()
-
-    def init_db(self):
-        with sqlite3.connect(self.db_path) as conn:
+    def init(self):
+        with sqlite3.connect(self.path) as conn:
             conn.execute("""
-                CREATE TABLE IF NOT EXISTS lavori (
-                    id_lavoro TEXT PRIMARY KEY,
-                    id_utente TEXT NOT NULL,
+                CREATE TABLE IF NOT EXISTS jobs (
+                    id TEXT PRIMARY KEY,
+                    user TEXT NOT NULL,
                     prompt TEXT NOT NULL,
-                    stato TEXT DEFAULT 'in_attesa',
-                    progresso INTEGER DEFAULT 0,
-                    percorso_video TEXT,
-                    errore TEXT
+                    status TEXT DEFAULT 'queued',
+                    progress INTEGER DEFAULT 0,
+                    video_path TEXT,
+                    error TEXT
                 )
             """)
 
-    def aggiungi(self, id_lavoro: str, id_utente: str, prompt: str):
-        with sqlite3.connect(self.db_path) as conn:
-            conn.execute(
-                "INSERT INTO lavori (id_lavoro, id_utente, prompt) VALUES (?, ?, ?)",
-                (id_lavoro, id_utente, prompt)
-            )
+    def add(self, job_id, user, prompt):
+        with sqlite3.connect(self.path) as conn:
+            conn.execute("INSERT INTO jobs (id, user, prompt) VALUES (?, ?, ?)", (job_id, user, prompt))
 
-    def aggiorna(self, id_lavoro: str, **kwargs):
-        with sqlite3.connect(self.db_path) as conn:
+    def update(self, job_id, **kwargs):
+        with sqlite3.connect(self.path) as conn:
             sets = ", ".join(f"{k} = ?" for k in kwargs)
-            values = list(kwargs.values()) + [id_lavoro]
-            conn.execute(f"UPDATE lavori SET {sets} WHERE id_lavoro = ?", values)
+            vals = list(kwargs.values()) + [job_id]
+            conn.execute(f"UPDATE jobs SET {sets} WHERE id = ?", vals)
 
-    def get(self, id_lavoro: str) -> Optional[Dict]:
-        with sqlite3.connect(self.db_path) as conn:
+    def get(self, job_id):
+        with sqlite3.connect(self.path) as conn:
             conn.row_factory = sqlite3.Row
-            row = conn.execute("SELECT * FROM lavori WHERE id_lavoro = ?", (id_lavoro,)).fetchone()
+            row = conn.execute("SELECT * FROM jobs WHERE id = ?", (job_id,)).fetchone()
             return dict(row) if row else None
 
 
 # ==============================================================================
-# WORKER
+# WORKER con offload pesante
 # ==============================================================================
-
-class VideoWorker(threading.Thread):
-    def __init__(self, db: DatabaseLavori):
+class LightWorker(threading.Thread):
+    def __init__(self, db: MiniDB):
         super().__init__(daemon=True)
         self.db = db
-        self.queue = queue.Queue()
-        self.running = True
+        self.q = queue.Queue()
+        self.alive = True
 
-        print("Caricamento modello leggero zeroscope_v2_576w (fp16)...")
+        print("Loading ultra-light model: zeroscope_v2_dark_30x448x256 ...")
         try:
             self.pipe = DiffusionPipeline.from_pretrained(
-                "cerspense/zeroscope_v2_576w",
+                "cerspense/zeroscope_v2_dark_30x448x256",
                 torch_dtype=torch.float16,
-                cache_dir=CACHE_DIR,
                 safety_checker=None,
                 requires_safety_checker=False
             )
-            # Ottimizzazioni memoria CPU
             self.pipe.enable_vae_slicing()
-            self.pipe.enable_sequential_cpu_offload()      # Molto importante su CPU
-            # Alternativa se sequential è troppo lento: self.pipe.enable_model_cpu_offload()
-            print("Modello caricato OK")
+            self.pipe.enable_sequential_cpu_offload()  # cruciale per CPU Basic
+            # NON fare .to("cuda") o .enable_model_cpu_offload() prima di sequential!
+            print("Model loaded successfully (low RAM mode)")
         except Exception as e:
-            print(f"Errore caricamento modello: {e}")
+            print(f"Model load failed: {e}")
             raise
 
-    def add_job(self, id_lavoro: str, prompt: str):
-        self.queue.put((id_lavoro, prompt))
+    def enqueue(self, job_id, prompt):
+        self.q.put((job_id, prompt))
 
     def run(self):
-        while self.running:
+        while self.alive:
             try:
-                id_lavoro, prompt = self.queue.get(timeout=12)
-                print(f"→ Inizio lavoro {id_lavoro}")
-
-                self.db.aggiorna(id_lavoro, stato="in_elaborazione", progresso=10)
+                job_id, prompt = self.q.get(timeout=10)
+                print(f"Processing {job_id}")
+                self.db.update(job_id, status="processing", progress=10)
 
-                video_path = self._generate(id_lavoro, prompt)
+                video_path = self._gen(job_id, prompt)
 
                 if video_path:
-                    self.db.aggiorna(
-                        id_lavoro,
-                        stato="completato",
-                        progresso=100,
-                        percorso_video=video_path
-                    )
+                    self.db.update(job_id, status="done", progress=100, video_path=video_path)
                 else:
-                    self.db.aggiorna(id_lavoro, stato="fallito", errore="Generazione fallita")
+                    self.db.update(job_id, status="failed", error="Generation error")
 
+                gc.collect()  # pulizia forzata
             except queue.Empty:
                 continue
             except Exception as e:
-                print(f"Errore worker: {e}")
+                print(f"Worker error: {e}")
 
-    def _generate(self, id_lavoro: str, prompt: str) -> Optional[str]:
+    def _gen(self, job_id, prompt):
         try:
-            self.db.aggiorna(id_lavoro, progresso=30)
+            self.db.update(job_id, progress=30)
 
-            # Parametri leggeri
-            video_frames = self.pipe(
+            result = self.pipe(
                 prompt,
-                num_inference_steps=20,     # meno steps = più veloce, meno qualità
-                height=320,
-                width=576,
-                num_frames=16,              # solo 16 frame (\~2 secondi a 8 fps)
-                guidance_scale=7.5
-            ).frames[0]
-
-            clip_path = os.path.join(TMP_VIDEO_DIR, f"clip_{id_lavoro}.mp4")
-            export_to_video(video_frames, clip_path, fps=8)
+                num_inference_steps=15,
+                height=256,
+                width=448,
+                num_frames=8,
+                guidance_scale=6.0
+            )
 
-            # Pulizia memoria esplicita
-            torch.cuda.empty_cache() if torch.cuda.is_available() else None
-            del video_frames
+            frames = result.frames[0]
+            out_path = os.path.join(TMP_DIR, f"{job_id}.mp4")
+            export_to_video(frames, out_path, fps=8)
 
-            return clip_path
+            del frames, result
+            gc.collect()
 
+            return out_path
         except Exception as e:
-            print(f"Errore generazione: {e}")
+            print(f"Gen error {job_id}: {e}")
             return None
 
 
 # ==============================================================================
-# API
+# API semplice
 # ==============================================================================
-
-db = DatabaseLavori()
-worker = VideoWorker(db)
+db = MiniDB()
+worker = LightWorker(db)
 worker.start()
 
-def crea_video(id_utente: str, prompt: str):
-    if not id_utente.strip():
-        return "Errore: inserisci ID utente"
-    if not prompt.strip():
-        return "Errore: inserisci un prompt"
+def start_job(user_id: str, prompt: str):
+    if not user_id.strip() or not prompt.strip():
+        return "Errore: inserisci ID utente e prompt validi"
 
-    id_lavoro = f"vid_{uuid.uuid4().hex[:10]}"
-    db.aggiungi(id_lavoro, id_utente, prompt)
-    worker.add_job(id_lavoro, prompt)
+    job_id = f"j{uuid.uuid4().hex[:10]}"
+    db.add(job_id, user_id, prompt)
+    worker.enqueue(job_id, prompt)
 
-    return f"Video in coda!\nID lavoro: **{id_lavoro}**\nControlla stato tra 3–15 minuti (CPU lenta)."
+    return f"Job in coda!\nID: **{job_id}**\nTempo stimato: 3–12 min (CPU lenta)"
 
-def check_stato(id_lavoro: str):
-    job = db.get(id_lavoro)
+def check_job(job_id: str):
+    job = db.get(job_id)
     if not job:
         return "ID non trovato"
 
-    stato = job["stato"]
-    prog = job["progresso"]
-    video = job.get("percorso_video", "")
-    err = job.get("errore", "")
-
-    msg = f"**Stato**: {stato}\n**Progresso**: {prog}%"
-    if video:
-        msg += f"\n\nVideo pronto → scaricalo da: {video}"
-    if err:
-        msg += f"\nErrore: {err}"
+    msg = f"Stato: {job['status']}\nProgresso: {job['progress']}%"
+    if job.get('video_path'):
+        msg += f"\n\nVideo pronto:\n{job['video_path']}"
+    if job.get('error'):
+        msg += f"\nErrore: {job['error']}"
     return msg
 
 
 # ==============================================================================
-# GRADIO UI leggera
+# UI minima
 # ==============================================================================
-
-with gr.Blocks(title="Video Generator – CPU Basic") as demo:
+with gr.Blocks(title="Video Gen - CPU Basic Ultra Light") as demo:
     gr.Markdown("""
-    # Generatore Video LEGGERO (CPU Basic)
-    Modello: zeroscope_v2_576w • \~16 frame (\~2 sec) • Lento ma funziona gratis
+    # Generatore Video ULTRA LEGGERO (CPU Basic Free)
+    - Modello: zeroscope_v2_dark_30x448x256
+    - Video: \~1 secondo (8 frame @ 256×448)
+    - Tempo: 3–12 min per video
     """)
 
     with gr.Row():
-        with gr.Column():
-            gr.Markdown("### Crea video")
-            utente = gr.Textbox(label="Tuo ID utente", placeholder="es. mario123")
-            prompt = gr.Textbox(label="Prompt", lines=4, placeholder="Un cane corre felice nel parco al tramonto")
-            btn_genera = gr.Button("Metti in coda", variant="primary")
-            output_crea = gr.Textbox(label="Risultato")
-
-        with gr.Column():
-            gr.Markdown("### Controlla stato")
-            id_input = gr.Textbox(label="ID lavoro")
-            btn_check = gr.Button("Verifica")
-            output_stato = gr.Textbox(label="Stato", lines=6)
-
-    btn_genera.click(crea_video, [utente, prompt], output_crea)
-    btn_check.click(check_stato, id_input, output_stato)
+        user = gr.Textbox(label="ID Utente", placeholder="es. test123")
+        prompt_box = gr.Textbox(label="Prompt", lines=3, placeholder="Un gatto salta su un tavolo di legno")
+
+    btn = gr.Button("Avvia (in coda)", variant="primary")
+    result = gr.Textbox(label="Output", lines=5)
+
+    check_id = gr.Textbox(label="Controlla ID job")
+    btn_check = gr.Button("Verifica stato")
+    status_out = gr.Textbox(label="Stato", lines=5)
+
+    btn.click(start_job, [user, prompt_box], result)
+    btn_check.click(check_job, check_id, status_out)
 
 demo.launch(server_name="0.0.0.0", server_port=7860, show_error=True)