Update app.py

app.py

@@ -25,8 +25,8 @@ os.makedirs(PUBLIC, exist_ok=True)
 FFMPEG = shutil.which("ffmpeg") or "ffmpeg"
 FFPROBE = shutil.which("ffprobe") or "ffprobe"
 
-TTS_CONCURRENCY = 4
-TRANS_CONCURRENCY = 12
+TTS_CONCURRENCY = 8
+TRANS_CONCURRENCY = 20
 FFMPEG_THREADS = 4
 CHUNK_SIZE = 1024 * 512
 
@@ -43,7 +43,7 @@ THREAD_POOL = ThreadPoolExecutor(max_workers=16)
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     task = asyncio.create_task(periodic_cleanup())
-    log.info("DubFlow v2.4.8 started")
+    log.info("DubFlow v2.5.0 started")
     yield
     task.cancel()
     THREAD_POOL.shutdown(wait=False)
@@ -51,7 +51,7 @@ async def lifespan(app: FastAPI):
 
 app = FastAPI(
     title="DubFlow API",
-    version="2.4.8",
+    version="2.5.0",
     description="Video dubbing pipeline — MP4 → SRT → Translate → TTS → Dubbed MP4",
     lifespan=lifespan,
 )
@@ -143,15 +143,17 @@ def new_job():
         "cancel": False, "created": time.time(),
         "video_ready": False, "video_path": None, "params": None,
         "last_heartbeat": time.time(),
+        "original_name": "video",
     }
     log.info(f"[{jid[:8]}] job created")
     return jid
 
 def compute_global(step, step_pct):
+    """Calcolo progress globale con precisione decimale."""
     done = sum(STEP_WEIGHTS[s] for s in STEP_WEIGHTS if s < step)
     if step in STEP_WEIGHTS:
         done += STEP_WEIGHTS[step] * (step_pct / 100.0)
-    return min(100.0, done)
+    return round(min(100.0, done), 2)
 
 def update(jid, **kw):
     j = JOBS.get(jid)
@@ -599,7 +601,7 @@ async def step1_extract_srt(video_path, jid):
                     if not chunk: break
                     sent += len(chunk)
                     now = time.time()
-                    if now - last_t > 0.3:
+                    if now - last_t > 0.1:
                         pct = 15 + (sent/total) * 25
                         update(jid, step_progress=round(pct, 2),
                                message=f"Upload audio {sent/1048576:.1f}/{total/1048576:.1f} MB")
@@ -896,8 +898,18 @@ def speed_fit(inp, out, target):
     if res.returncode != 0:
         shutil.copy2(inp, out)
 
+_TTS_CACHE_DIR = os.path.join(TMP, "dubflow_tts_cache")
+os.makedirs(_TTS_CACHE_DIR, exist_ok=True)
+
+
+def _tts_cache_key(text, voice, rate, pitch, volume):
+    """Genera chiave cache stabile per il TTS."""
+    key = f"{voice}|{rate}|{pitch}|{volume}|{text}"
+    return hashlib.md5(key.encode()).hexdigest()
+
+
 async def _gtts_fallback(text, lang_code, out):
-    """Fallback su gTTS - sempre funziona da qualsiasi IP."""
+    """Fallback gTTS thread-safe e veloce."""
     loop = asyncio.get_event_loop()
     
     def _sync_gtts():
@@ -908,42 +920,45 @@ async def _gtts_fallback(text, lang_code, out):
             sp.check_call([sys.executable, "-m", "pip", "install", "-q", "gTTS"])
             from gtts import gTTS
         
-        gtts_lang_map = {
-            "nb": "no",
-            "zh": "zh-cn",
-        }
+        gtts_lang_map = {"nb": "no", "zh": "zh-cn"}
         lang = gtts_lang_map.get(lang_code, lang_code)
         
         try:
-            tts = gTTS(text=text, lang=lang, slow=False)
+            tts = gTTS(text=text, lang=lang, slow=False, tld="com")
             tts.save(out)
         except Exception:
             try:
                 tts = gTTS(text=text, lang="en", slow=False)
                 tts.save(out)
             except Exception as e:
-                raise RuntimeError(f"gTTS totally failed: {e}")
+                raise RuntimeError(f"gTTS failed: {e}")
     
     await loop.run_in_executor(THREAD_POOL, _sync_gtts)
     
     if not os.path.exists(out) or os.path.getsize(out) < 100:
-        raise RuntimeError("gTTS produced empty file")
+        raise RuntimeError("gTTS empty file")
+
+
+# Flag globale: una volta che edge è bloccato, non riprovare
+_EDGE_BLOCKED = False
 
 
 async def tts_block(text, voice, out, rate, pitch, volume):
-    """TTS con edge-tts + fallback gTTS automatico se 403."""
-    import random
-    last_err = None
+    """TTS ottimizzato: cache, edge-tts con skip rapido, gTTS fallback."""
+    global _EDGE_BLOCKED
+    
+    # 1. Check cache
+    cache_key = _tts_cache_key(text, voice, rate, pitch, volume)
+    cache_path = os.path.join(_TTS_CACHE_DIR, f"{cache_key}.mp3")
+    if os.path.exists(cache_path) and os.path.getsize(cache_path) > 100:
+        shutil.copy2(cache_path, out)
+        return
     
     lang_code = voice.split("-")[0].lower() if "-" in voice else "en"
     
-    # Tentativo 1-3: Edge TTS
-    edge_blocked = False
-    for attempt in range(3):
+    # 2. Edge-tts (skip se già confermato bloccato)
+    if not _EDGE_BLOCKED:
         try:
-            if attempt > 0:
-                await asyncio.sleep(random.uniform(0.5, 1.5) * attempt)
-            
             comm = edge_tts.Communicate(
                 text=text, voice=voice,
                 rate=rate, pitch=pitch, volume=volume,
@@ -952,28 +967,23 @@ async def tts_block(text, voice, out, rate, pitch, volume):
             async for c in comm.stream():
                 if c["type"] == "audio":
                     data.extend(c["data"])
-            if not data:
-                raise RuntimeError("empty audio")
-            async with aiofiles.open(out, "wb") as f:
-                await f.write(bytes(data))
-            return  # SUCCESS
+            if data:
+                async with aiofiles.open(out, "wb") as f:
+                    await f.write(bytes(data))
+                # Salva in cache
+                try: shutil.copy2(out, cache_path)
+                except: pass
+                return
         except Exception as e:
-            last_err = e
-            err_str = str(e)
-            if "403" in err_str or "Invalid response status" in err_str:
-                edge_blocked = True
-                break
-    
-    # log silenzioso, edge-tts è sempre bloccato su HF Spaces
-    
-    # Fallback: gTTS
-    try:
-        await _gtts_fallback(text, lang_code, out)
-        return  # SUCCESS via gTTS
-    except Exception as e:
-        last_err = e
+            if "403" in str(e) or "Invalid response" in str(e):
+                _EDGE_BLOCKED = True
+                log.warning("edge-tts permanently blocked on this IP, using gTTS only")
     
-    raise RuntimeError(f"TTS failed (edge+gtts): {last_err}")
+    # 3. Fallback gTTS
+    await _gtts_fallback(text, lang_code, out)
+    # Cache anche il risultato gTTS
+    try: shutil.copy2(out, cache_path)
+    except: pass
 
 
 async def step3_tts(srt, lang, gender, out_mp3, jid, rate, pitch, volume):
@@ -1096,6 +1106,10 @@ async def step4_dub(video, audio, out, mode, dub_vol, orig_vol, fade, jid):
 # ══════════════════════════════════════════════════════════════
 # PIPELINE
 # ══════════════════════════════════════════════════════════════
+# ══════════════════════════════════════════════════════════════
+# SSE PROGRESS
+# ══════════════════════════════════════════════════════════════
+
 async def run_pipeline(jid, base_url):
     j = JOBS[jid]
     log.info(f"[{jid[:8]}] pipeline waiting for video…")
@@ -1108,18 +1122,27 @@ async def run_pipeline(jid, base_url):
         if time.time() - wait_start > 1200:
             update(jid, error="Timeout attesa video", done=True)
             return
-        await asyncio.sleep(0.1)
+        await asyncio.sleep(0.05)
     
     log.info(f"[{jid[:8]}] video ready, starting pipeline")
     video_path = j["video_path"]
     p = j["params"]
     target_lang = p["lang"]
     
-    uid = uuid.uuid4().hex
-    tts_path = os.path.join(TMP, f"dub_tts_{uid}.mp3")
-    out_path = os.path.join(PUBLIC, f"{uid}.mp4")
-    srt_path = os.path.join(PUBLIC, f"{uid}.srt")
-    tsrt_path = os.path.join(PUBLIC, f"{uid}_{target_lang}.srt")
+    # NOMI INTELLIGENTI basati su nome originale
+    original = j.get("original_name", "video")
+    safe_original = re.sub(r'[^\w\-_.]', '_', original)[:60] or "video"
+    uid_short = uuid.uuid4().hex[:8]
+    
+    base_name = f"{safe_original}_dubbed_{target_lang}_{uid_short}"
+    srt_orig_name = f"{safe_original}_{uid_short}.srt"
+    srt_trans_name = f"{safe_original}_{target_lang}_{uid_short}.srt"
+    out_mp4_name = f"{base_name}.mp4"
+    
+    out_path = os.path.join(PUBLIC, out_mp4_name)
+    srt_path = os.path.join(PUBLIC, srt_orig_name)
+    tsrt_path = os.path.join(PUBLIC, srt_trans_name)
+    tts_path = os.path.join(TMP, f"dub_tts_{uid_short}.mp3")
 
     t0 = time.time()
     try:
@@ -1139,17 +1162,18 @@ async def run_pipeline(jid, base_url):
         
         elapsed = time.time() - t0
         update(jid, stage="done", done=True, step=4, step_progress=100,
-               message=f"Completato in {elapsed:.1f}s",
+               message=f"Completato in {elapsed:.2f}s",
                result={
-                   "video_url": f"{base_url}/file/{uid}.mp4",
-                   "video_download": f"{base_url}/file/{uid}.mp4?dl=1",
-                   "srt_original": f"{base_url}/file/{uid}.srt",
-                   "srt_translated": f"{base_url}/file/{uid}_{target_lang}.srt",
+                   "video_url": f"{base_url}/file/{out_mp4_name}",
+                   "video_download": f"{base_url}/file/{out_mp4_name}?dl=1",
+                   "video_filename": out_mp4_name,
+                   "srt_original": f"{base_url}/file/{srt_orig_name}",
+                   "srt_translated": f"{base_url}/file/{srt_trans_name}",
                    "language": target_lang, "gender": p["gender"],
-                   "elapsed_sec": round(elapsed, 1),
+                   "elapsed_sec": round(elapsed, 2),
                })
         JOBS[jid]["progress"] = 100.0
-        log.info(f"[{jid[:8]}] ✅ done in {elapsed:.1f}s")
+        log.info(f"[{jid[:8]}] ✅ done in {elapsed:.2f}s → {out_mp4_name}")
     except InterruptedError:
         log.info(f"[{jid[:8]}] cancelled")
         update(jid, error="Cancellato", done=True)
@@ -1160,9 +1184,7 @@ async def run_pipeline(jid, base_url):
         cleanup_paths([video_path, tts_path])
 
 
-# ══════════════════════════════════════════════════════════════
-# SSE PROGRESS
-# ══════════════════════════════════════════════════════════════
+
 @app.get("/progress/{jid}", tags=["Progress"])
 async def progress(jid: str):
     """Server-Sent Events stream con stato job in real-time."""
@@ -1178,13 +1200,17 @@ async def progress(jid: str):
                        ("progress","step","step_progress","message","stage","done","error","result")}
             s = json.dumps(payload)
             now = time.time()
-            if s != last_send or (now - last_time) > 2.0:
+            # invia sempre se cambia, max 20Hz; heartbeat ogni 1.5s
+            if s != last_send:
                 yield f"data: {s}\n\n"
                 last_send = s
                 last_time = now
+            elif (now - last_time) > 1.5:
+                yield f"data: {s}\n\n"
+                last_time = now
             if j["done"] or j["error"]: 
                 return
-            await asyncio.sleep(0.15)
+            await asyncio.sleep(0.05)
     return StreamingResponse(gen(), media_type="text/event-stream",
                              headers={"Cache-Control":"no-cache",
                                       "X-Accel-Buffering":"no",
@@ -1232,14 +1258,20 @@ async def job_create(request: Request,
     base = str(request.base_url).rstrip("/")
     asyncio.create_task(run_pipeline(jid, base))
     return {"job_id": jid, "status_url": f"{base}/status/{jid}", "progress_url": f"{base}/progress/{jid}"}
-
-
 @app.post("/job/{jid}/upload", tags=["Jobs"])
 async def job_upload(jid: str, video: UploadFile = File(...)):
     j = JOBS.get(jid)
     if not j: raise HTTPException(404, "job not found")
     if j["video_ready"]: raise HTTPException(400, "video già caricato")
     
+    # Estrai nome originale (senza path/estensione cattiva)
+    original_name = os.path.basename(video.filename or "video.mp4")
+    name_stem = os.path.splitext(original_name)[0]
+    # Sanitize: solo caratteri sicuri per filesystem
+    name_stem = re.sub(r'[^\w\-_.]', '_', name_stem)[:80] or "video"
+    j["original_name"] = name_stem
+    log.info(f"[{jid[:8]}] original filename: '{original_name}' → stem: '{name_stem}'")
+    
     uid = uuid.uuid4().hex
     vpath = os.path.join(TMP, f"dub_in_{uid}.mp4")
     size = 0
@@ -1255,9 +1287,9 @@ async def job_upload(jid: str, video: UploadFile = File(...)):
                 if size > MAX_UPLOAD_MB * 1024 * 1024:
                     raise HTTPException(413, f"Max {MAX_UPLOAD_MB} MB")
                 now = time.time()
-                if now - last_t > 0.2:
+                if now - last_t > 0.05:
                     update(jid, step=0, step_progress=min(95, size/(MAX_UPLOAD_MB*1024*1024)*95),
-                           message=f"Ricezione server {size/1048576:.1f} MB")
+                           message=f"Ricezione server {size/1048576:.2f} MB")
                     last_t = now
         
         if size < MIN_FILE_BYTES:
@@ -1265,10 +1297,10 @@ async def job_upload(jid: str, video: UploadFile = File(...)):
         
         update(jid, step_progress=97, message="Validazione…")
         await validate_video(vpath)
-        log.info(f"[{jid[:8]}] upload OK: {size/1048576:.1f} MB")
-        update(jid, step=0, step_progress=100, message=f"Video pronto ({size/1048576:.1f} MB)",
+        log.info(f"[{jid[:8]}] upload OK: {size/1048576:.2f} MB")
+        update(jid, step=0, step_progress=100, message=f"Video pronto ({size/1048576:.2f} MB)",
                video_path=vpath, video_ready=True)
-        return {"ok": True, "size_mb": round(size/1048576, 2)}
+        return {"ok": True, "size_mb": round(size/1048576, 2), "name": name_stem}
     except HTTPException as e:
         cleanup_paths([vpath])
         update(jid, error=str(e.detail), done=True)
@@ -1278,8 +1310,6 @@ async def job_upload(jid: str, video: UploadFile = File(...)):
         cleanup_paths([vpath])
         update(jid, error=str(e), done=True)
         raise HTTPException(500, str(e))
-
-
 @app.post("/job/{jid}/url", tags=["Jobs"])
 async def job_url(jid: str, video: str = Query(...)):
     j = JOBS.get(jid)
@@ -1294,6 +1324,15 @@ async def job_url(jid: str, video: str = Query(...)):
         update(jid, error="URL non valido", done=True)
         raise HTTPException(400, "URL deve iniziare con http/https")
     
+    # Estrai nome dall'URL
+    from urllib.parse import urlparse, unquote
+    url_path = unquote(urlparse(video).path)
+    original_name = os.path.basename(url_path) or "video.mp4"
+    name_stem = os.path.splitext(original_name)[0]
+    name_stem = re.sub(r'[^\w\-_.]', '_', name_stem)[:80] or "video"
+    j["original_name"] = name_stem
+    log.info(f"[{jid[:8]}] URL filename: '{original_name}' → stem: '{name_stem}'")
+    
     uid = uuid.uuid4().hex
     vpath = os.path.join(TMP, f"dub_in_{uid}.mp4")
     
@@ -1315,21 +1354,21 @@ async def job_url(jid: str, video: str = Query(...)):
                         if size > MAX_UPLOAD_MB * 1024 * 1024:
                             raise HTTPException(413, f"Max {MAX_UPLOAD_MB} MB")
                         now = time.time()
-                        if now - last_t > 0.2:
+                        if now - last_t > 0.05:
                             pct = (size/total*95) if total else min(95, size/(1024*1024))
                             update(jid, step_progress=round(pct, 2),
-                                   message=f"Download {size/1048576:.1f}/{total/1048576:.1f} MB" if total
-                                           else f"Download {size/1048576:.1f} MB")
+                                   message=f"Download {size/1048576:.2f}/{total/1048576:.2f} MB" if total
+                                           else f"Download {size/1048576:.2f} MB")
                             last_t = now
         
         if size < MIN_FILE_BYTES:
             raise HTTPException(400, "File troppo piccolo")
         update(jid, step_progress=97, message="Validazione…")
         await validate_video(vpath)
-        log.info(f"[{jid[:8]}] download OK: {size/1048576:.1f} MB")
-        update(jid, step=0, step_progress=100, message=f"Video pronto ({size/1048576:.1f} MB)",
+        log.info(f"[{jid[:8]}] download OK: {size/1048576:.2f} MB")
+        update(jid, step=0, step_progress=100, message=f"Video pronto ({size/1048576:.2f} MB)",
                video_path=vpath, video_ready=True)
-        return {"ok": True, "size_mb": round(size/1048576, 2)}
+        return {"ok": True, "size_mb": round(size/1048576, 2), "name": name_stem}
     except HTTPException as e:
         cleanup_paths([vpath])
         update(jid, error=str(e.detail), done=True)
@@ -1409,7 +1448,7 @@ async def api_dub_get(request: Request,
                             if size > MAX_UPLOAD_MB * 1024 * 1024:
                                 raise Exception(f"Max {MAX_UPLOAD_MB} MB")
                             now = time.time()
-                            if now - last_t > 0.2:
+                            if now - last_t > 0.05:
                                 pct = (size/total*95) if total else min(95, size/(1024*1024))
                                 update(jid, step_progress=round(pct, 2),
                                        message=f"Download {size/1048576:.1f} MB")
@@ -1485,7 +1524,7 @@ async def api_dub_post(request: Request,
                 if size > MAX_UPLOAD_MB * 1024 * 1024:
                     raise HTTPException(413, f"Max {MAX_UPLOAD_MB} MB")
                 now = time.time()
-                if now - last_t > 0.2:
+                if now - last_t > 0.05:
                     update(jid, step_progress=min(95, size/(MAX_UPLOAD_MB*1024*1024)*95),
                            message=f"Upload {size/1048576:.1f} MB")
                     last_t = now
@@ -1549,7 +1588,7 @@ async def voices():
 
 @app.get("/health", tags=["Meta"])
 async def health():
-    return {"status":"ok", "version": "2.4.8",
+    return {"status":"ok", "version": "2.5.0",
             "jobs_active": sum(1 for j in JOBS.values() if not j["done"]),
             "jobs_total": len(JOBS),
             "max_upload_mb": MAX_UPLOAD_MB}
@@ -1619,7 +1658,7 @@ input:focus,select:focus{border-color:#a78bfa;box-shadow:0 0 0 3px rgba(167,139,
 
 <div class="max-w-5xl mx-auto pt-10 px-6 pb-20">
 <header class="mb-8">
-<p class="label mb-2">Engine v2.4.8 — Real-time + REST API</p>
+<p class="label mb-2">Engine v2.5.0 — Real-time + REST API</p>
 <h1 class="text-4xl md:text-5xl font-semibold tracking-tight">DubFlow <span class="text-slate-400 font-light">Web</span></h1>
 <p class="text-slate-400 mt-2 text-sm">Pipeline: upload · estrazione · traduzione · TTS · dub</p>
 </header>
@@ -1891,7 +1930,7 @@ function uploadFile(jid, file){
    const elapsed=(Date.now()-uploadStartTime)/1000;
    const speed=e.loaded/elapsed/1048576;
    const eta=e.loaded>0 ? (e.total-e.loaded)/(e.loaded/elapsed) : 0;
-   $('upSpeed').textContent=`${speed.toFixed(1)} MB/s · ETA ${eta.toFixed(0)}s`;
+   $('upSpeed').textContent=`${speed.toFixed(2)} MB/s · ETA ${eta.toFixed(1)}s`;
   };
   xhr.upload.onload=()=>{$('upSpeed').textContent='in elaborazione…';};
   xhr.onload=()=>{