Update app_relay2.py

app_relay2.py

@@ -1,10 +1,11 @@
 # ═══════════════════════════════════════════════════════════════════════════════
-# 🧅 SODA-GEN ANONYMOUS RELAY V1.4 — HF SPACE CPU (BACKEND ONLY)
+# 🧅 SODA-GEN ANONYMOUS RELAY V1.5 — HF SPACE CPU (BACKEND ONLY)
 # 
-# V1.4 FIX: Non-blocking startup (was causing 503 on HF Space)
-#   - on_startup: lightweight only, no Tor network calls
-#   - Tor IP check runs in background thread
-#   - Health endpoint always responds instantly
+# V1.5: ULTRA-MINIMAL startup — ZERO blocking calls
+#   - Root endpoint `/` added (HF Space health check)
+#   - Tor runs as background process (not service)
+#   - All Tor init deferred to background thread
+#   - First generate request triggers lazy Tor check
 # ═══════════════════════════════════════════════════════════════════════════════
 
 import json
@@ -52,37 +53,25 @@ UPLOAD_DIR.mkdir(exist_ok=True)
 TASKS: Dict[str, Dict[str, Any]] = {}
 
 _last_tor_ip = {"ip": "unknown", "time": 0}
-_tor_ready = False  # Set True once Tor is confirmed working
+_tor_ready = False
 
 # ═══════════════════════════════════════════════════════════════════════════════
-# 🧅 TOR ENGINE
+# 🧅 TOR ENGINE (Lazy — only runs when needed)
 # ═══════════════════════════════════════════════════════════════════════════════
 
-def ensure_tor_running():
-    """Ensure Tor daemon is active (no network calls)"""
+def check_tor_alive() -> bool:
+    """Quick check if Tor SOCKS proxy is responding (non-blocking, 3s timeout)"""
     try:
-        result = subprocess.run(
-            ["service", "tor", "status"],
-            capture_output=True, text=True, timeout=5
-        )
-        if "running" not in result.stdout.lower():
-            subprocess.run(["service", "tor", "start"], capture_output=True, timeout=10)
-            time.sleep(3)
-            print("🧅 Tor started")
+        r = httpx.get("https://api.ipify.org", proxy=TOR_PROXY, timeout=3)
+        return r.status_code == 200
     except:
-        try:
-            subprocess.run(["service", "tor", "start"], capture_output=True, timeout=10)
-            time.sleep(3)
-        except Exception as e:
-            print(f"⚠️ Cannot start Tor: {e}")
+        return False
 
 
 def get_tor_ip() -> str:
-    """Get current Tor exit node IP (cached for 10s)"""
     now = time.time()
     if now - _last_tor_ip["time"] < 10 and _last_tor_ip["ip"] != "unknown":
         return _last_tor_ip["ip"]
-    
     try:
         r = httpx.get("https://api.ipify.org", proxy=TOR_PROXY, timeout=15)
         ip = r.text.strip()
@@ -95,61 +84,37 @@ def get_tor_ip() -> str:
 
 
 def rotate_tor_circuit() -> str:
-    """Request new Tor circuit → new exit node → new IP"""
     try:
         with Controller.from_port(port=9051) as controller:
             controller.authenticate()
             controller.signal(Signal.NEWNYM)
             time.sleep(5)
             _last_tor_ip["ip"] = "unknown"
-            new_ip = get_tor_ip()
-            print(f"🔄 Tor rotated → {new_ip}")
-            return new_ip
+            return get_tor_ip()
     except Exception as e:
-        print(f"⚠️ Tor rotation method 1 failed: {e}, trying restart...")
-        try:
-            subprocess.run(["service", "tor", "restart"], capture_output=True, timeout=15)
-            time.sleep(8)
-            with Controller.from_port(port=9051) as controller:
-                controller.authenticate()
-                controller.signal(Signal.NEWNYM)
-                time.sleep(5)
-                _last_tor_ip["ip"] = "unknown"
-                new_ip = get_tor_ip()
-                print(f"🔄 Tor restarted & rotated → {new_ip}")
-                return new_ip
-        except Exception as e2:
-            print(f"❌ Tor rotation failed entirely: {e2}")
-            return "rotation_failed"
-
-
-def _background_tor_init():
+        print(f"⚠️ Tor rotation failed: {e}")
+        return "rotation_failed"
+
+
+def _lazy_tor_init():
     """
-    Run in background thread AFTER server is ready.
-    This prevents blocking the startup event.
+    Background thread: wait for Tor to be ready, then get IP.
+    Called once on first generate request or after startup.
     """
     global _tor_ready
-    print("🧅 Background Tor init starting...")
-    
-    # Wait extra time for Tor to build circuits
-    time.sleep(10)
-    
-    ensure_tor_running()
-    
-    # Try to get IP (might take time)
-    ip = get_tor_ip()
-    if ip != "unknown":
-        _tor_ready = True
-        print(f"🧅 Tor ready! IP: {ip}")
-    else:
-        # Retry once after short delay
-        time.sleep(5)
-        ip = get_tor_ip()
-        if ip != "unknown":
+    for attempt in range(6):
+        if check_tor_alive():
             _tor_ready = True
-            print(f"🧅 Tor ready (retry)! IP: {ip}")
-        else:
-            print("⚠️ Tor init incomplete — will retry on first request")
+            ip = get_tor_ip()
+            print(f"🧅 Tor ready! IP: {ip} (attempt {attempt+1})")
+            return
+        print(f"⏳ Tor not ready, waiting 5s... (attempt {attempt+1}/6)")
+        time.sleep(5)
+    print("⚠️ Tor init incomplete — will retry on requests")
+
+
+# Start lazy init in background (non-blocking)
+threading.Thread(target=_lazy_tor_init, daemon=True).start()
 
 
 # ═══════════════════════════════════════════════════════════════════════════════
@@ -169,31 +134,21 @@ class GradioClientWithProxy:
             for key in ["HTTP_PROXY", "HTTPS_PROXY", "http_proxy", "https_proxy",
                         "ALL_PROXY", "all_proxy"]:
                 self._old_env[key] = os.environ.get(key)
-            
             os.environ["HTTP_PROXY"] = self.proxy
             os.environ["HTTPS_PROXY"] = self.proxy
             os.environ["http_proxy"] = self.proxy
             os.environ["https_proxy"] = self.proxy
             os.environ["ALL_PROXY"] = self.proxy
             os.environ["all_proxy"] = self.proxy
-        
-        self.client = Client(
-            self.base_url,
-            headers={"User-Agent": "SodaGen-Anonymous/1.4"}
-        )
+        self.client = Client(self.base_url, headers={"User-Agent": "SodaGen/1.5"})
     
     def submit(self, **kwargs):
         return self.client.submit(**kwargs)
     
-    def predict(self, **kwargs):
-        return self.client.predict(**kwargs)
-    
     def _restore_env(self):
         for key, val in self._old_env.items():
-            if val is None:
-                os.environ.pop(key, None)
-            else:
-                os.environ[key] = val
+            if val is None: os.environ.pop(key, None)
+            else: os.environ[key] = val
     
     def __del__(self):
         self._restore_env()
@@ -203,266 +158,154 @@ class GradioClientWithProxy:
 # 📊 ERROR DETECTION
 # ═══════════════════════════════════════════════════════════════════════════════
 
-def is_quota_error(error_msg: str) -> bool:
-    msg = error_msg.lower()
-    return any(kw in msg for kw in [
-        "exceeded", "quota", "rate limit", "too many requests",
-        "daily limit", "usage limit"
-    ])
-
-def is_tor_blocked(error_msg: str) -> bool:
-    msg = error_msg.lower()
-    return any(kw in msg for kw in [
-        "403", "forbidden", "blocked", "banned", "denied",
-        "access denied", "ip blocked"
-    ])
-
-def is_gpu_cold_error(error_msg: str) -> bool:
-    msg = error_msg.lower()
-    return any(kw in msg for kw in [
-        "no gpu", "gpu was available", "available after",
-        "no gpu was", "gpu is not available", "not ready",
-    ])
-
-def parse_retry_time(error_msg: str) -> Optional[int]:
-    m = re.search(r'(?:try again in|retry in)\s+(.+?)(?:\.|$)', error_msg, re.IGNORECASE)
+def is_quota_error(msg: str) -> bool:
+    return any(kw in msg.lower() for kw in ["exceeded","quota","rate limit","too many requests","daily limit","usage limit"])
+
+def is_tor_blocked(msg: str) -> bool:
+    return any(kw in msg.lower() for kw in ["403","forbidden","blocked","banned","denied","access denied","ip blocked"])
+
+def is_gpu_cold(msg: str) -> bool:
+    return any(kw in msg.lower() for kw in ["no gpu","gpu was available","available after","not ready"])
+
+def parse_retry_time(msg: str) -> Optional[int]:
+    m = re.search(r'(?:try again in|retry in)\s+(.+?)(?:\.|$)', msg, re.IGNORECASE)
     if m:
-        retry_str = m.group(1).strip()
         try:
+            s = m.group(1).strip()
             days = 0
-            day_match = re.search(r'(\d+)\s+day', retry_str)
-            if day_match:
-                days = int(day_match.group(1))
-            time_match = re.search(r'(\d+):(\d+):(\d+)', retry_str)
-            if time_match:
-                h, mi, s = int(time_match.group(1)), int(time_match.group(2)), int(time_match.group(3))
-                return (days * 86400) + (h * 3600) + (mi * 60) + s
-        except:
-            pass
+            d = re.search(r'(\d+)\s+day', s)
+            if d: days = int(d.group(1))
+            t = re.search(r'(\d+):(\d+):(\d+)', s)
+            if t: return (days*86400)+(int(t.group(1))*3600)+(int(t.group(2))*60)+int(t.group(3))
+        except: pass
     return None
 
 
 # ════════════════════════════���══════════════════════════════════════════════════
-# 🎬 VIDEO POST-PROCESSING
+# 🎬 POST-PROCESSING
 # ═══════════════════════════════════════════════════════════════════════════════
 
-def get_video_info(video_path: str) -> dict:
+def get_video_info(path: str) -> dict:
     try:
-        result = subprocess.run(
-            ['ffprobe', '-v', 'quiet', '-print_format', 'json',
-             '-show_format', '-show_streams', str(video_path)],
-            capture_output=True, text=True, timeout=10
-        )
-        info = json.loads(result.stdout)
-        duration = float(info.get('format', {}).get('duration', 0))
-        size = int(info.get('format', {}).get('size', 0))
-        vs = next((s for s in info.get('streams', []) if s.get('codec_type') == 'video'), {})
-        width = int(vs.get('width', 768))
-        height = int(vs.get('height', 512))
-        return {'duration': duration, 'size': size, 'width': width, 'height': height}
+        r = subprocess.run(['ffprobe','-v','quiet','-print_format','json','-show_format','-show_streams',path], capture_output=True, text=True, timeout=10)
+        info = json.loads(r.stdout)
+        d = float(info.get('format',{}).get('duration',0))
+        s = int(info.get('format',{}).get('size',0))
+        vs = next((x for x in info.get('streams',[]) if x.get('codec_type')=='video'), {})
+        return {'duration':d,'size':s,'width':int(vs.get('width',768)),'height':int(vs.get('height',512))}
     except:
-        file_size = os.path.getsize(video_path) if os.path.exists(video_path) else 0
-        return {'duration': 0, 'size': file_size, 'width': 768, 'height': 512}
+        sz = os.path.getsize(path) if os.path.exists(path) else 0
+        return {'duration':0,'size':sz,'width':768,'height':512}
 
-
-def generate_thumbnail(video_path: str, output_path: str) -> bool:
+def gen_thumb(vpath, opath):
     try:
-        subprocess.run(
-            ['ffmpeg', '-y', '-i', str(video_path),
-             '-vframes', '1', '-q:v', '3', '-vf', 'scale=640:-1', str(output_path)],
-            capture_output=True, timeout=15
-        )
-        return os.path.exists(output_path)
-    except:
-        return False
+        subprocess.run(['ffmpeg','-y','-i',vpath,'-vframes','1','-q:v','3','-vf','scale=640:-1',opath], capture_output=True, timeout=15)
+        return os.path.exists(opath)
+    except: return False
 
-
-def resize_image_for_video(image_path, width=768, height=512):
+def resize_img(path, w=768, h=512):
     try:
-        if not image_path or not os.path.exists(image_path):
-            return None
-        img = Image.open(image_path).convert("RGB").resize(
-            (int(width), int(height)), Image.LANCZOS
-        )
-        img.save(image_path)
-        return image_path
-    except:
-        return image_path
+        if not path or not os.path.exists(path): return None
+        Image.open(path).convert("RGB").resize((int(w),int(h)), Image.LANCZOS).save(path)
+        return path
+    except: return path
 
 
 # ═══════════════════════════════════════════════════════════════════════════════
 # 🚀 GENERATION TASK
 # ═══════════════════════════════════════════════════════════════════════════════
 
-def run_generation_task(
-    task_id: str,
-    prompt: str,
-    img1_path: Optional[str],
-    img2_path: Optional[str],
-    duration: float,
-    steps: float,
-    frame_mult: int,
-):
-    global _tor_ready
+def run_generation_task(task_id, prompt, img1_path, img2_path, duration, steps, frame_mult):
     task = TASKS[task_id]
-    
     try:
         task["status"] = "processing"
-        task["log"] += f"🎬 [ANONYMOUS MODE] Prompt: {prompt[:80]}...\n"
-        task["log"] += f"⏱️ Duration: {duration}s | Steps: {steps} | FPS Mult: {frame_mult}\n"
+        task["log"] += f"🎬 [ANONYMOUS] {prompt[:80]}...\n"
+        task["log"] += f"⏱️ {duration}s | Steps: {steps} | FPS: {frame_mult}\n"
         
-        # Ensure Tor is running (may not be ready yet on first call)
-        ensure_tor_running()
-        
-        # Get Tor IP (might fail first time, that's ok)
-        current_ip = get_tor_ip()
-        task["log"] += f"🧅 Tor IP: {current_ip}\n"
+        ip = get_tor_ip()
+        task["log"] += f"🧅 Tor IP: {ip}\n"
         
-        if current_ip == "unknown":
-            task["log"] += f"⚠️ Tor not ready yet, waiting 15s for circuits...\n"
+        if ip == "unknown":
+            task["log"] += "⚠️ Tor not ready, waiting 15s...\n"
             time.sleep(15)
-            current_ip = get_tor_ip()
-            task["log"] += f"🧅 Tor IP (retry): {current_ip}\n"
+            ip = get_tor_ip()
+            task["log"] += f"🧅 Tor IP retry: {ip}\n"
         
-        img1_resized = resize_image_for_video(img1_path) if img1_path else None
-        img2_resized = resize_image_for_video(img2_path) if img2_path else None
+        i1 = resize_img(img1_path) if img1_path else None
+        i2 = resize_img(img2_path) if img2_path else None
+        f1 = handle_file(i1) if i1 else None
+        f2 = handle_file(i2) if i2 else None
         
-        safe_img1 = handle_file(img1_resized) if img1_resized else None
-        safe_img2 = handle_file(img2_resized) if img2_resized else None
+        ok = False
+        vid = None
+        retry = 0
         
-        tor_retry = 0
-        success = False
-        final_video = None
-        
-        while tor_retry <= MAX_TOR_RETRIES:
-            current_ip = get_tor_ip()
-            task["log"] += f"🧅 Tor IP: {current_ip} (attempt {tor_retry + 1}/{MAX_TOR_RETRIES + 1})\n"
-            
+        while retry <= MAX_TOR_RETRIES:
+            cip = get_tor_ip()
+            task["log"] += f"🧅 IP: {cip} ({retry+1}/{MAX_TOR_RETRIES+1})\n"
             try:
-                client_wrapper = GradioClientWithProxy(TARGET_URL, proxy=TOR_PROXY)
-                
-                task["log"] += f"🚀 Submitting to HF Space (anonymous via Tor)...\n"
+                cw = GradioClientWithProxy(TARGET_URL, proxy=TOR_PROXY)
+                task["log"] += "🚀 Submitting...\n"
                 task["progress"] = 20
-                
-                job = client_wrapper.submit(
-                    input_image=safe_img1,
-                    last_image=safe_img2,
-                    prompt=prompt,
-                    steps=float(steps),
-                    negative_prompt=WAN_NEG,
+                job = cw.submit(
+                    input_image=f1, last_image=f2, prompt=prompt,
+                    steps=float(steps), negative_prompt=WAN_NEG,
                     duration_seconds=float(duration),
-                    guidance_scale=1.0,
-                    guidance_scale_2=1.0,
-                    seed=float(random.randint(0, 999999)),
-                    randomize_seed=True,
-                    quality=6.0,
-                    scheduler="UniPCMultistep",
-                    flow_shift=3.0,
+                    guidance_scale=1.0, guidance_scale_2=1.0,
+                    seed=float(random.randint(0,999999)),
+                    randomize_seed=True, quality=6.0,
+                    scheduler="UniPCMultistep", flow_shift=3.0,
                     frame_multiplier=int(frame_mult),
-                    safe_mode=False,
-                    video_component=True,
+                    safe_mode=False, video_component=True,
                     api_name="/generate_video",
                 )
-                
-                task["log"] += f"⏳ Waiting for result (timeout: {PREDICT_TIMEOUT}s)...\n"
+                task["log"] += f"⏳ Waiting ({PREDICT_TIMEOUT}s)...\n"
                 task["progress"] = 50
-                
                 result = job.result(timeout=PREDICT_TIMEOUT)
-                
-                task["log"] += f"📥 Processing result...\n"
                 task["progress"] = 80
-                
-                if isinstance(result, (list, tuple)):
-                    final_video = result[0]
-                else:
-                    final_video = result
-                
-                if final_video:
-                    success = True
-                    task["log"] += f"✅ Generation SUCCESS via Tor IP: {current_ip}\n"
+                vid = result[0] if isinstance(result,(list,tuple)) else result
+                if vid:
+                    ok = True
+                    task["log"] += f"✅ SUCCESS via {cip}\n"
                     break
                 else:
-                    task["log"] += f"⚠️ No video in result: {str(result)[:200]}\n"
-                    
+                    task["log"] += f"⚠️ Empty result\n"
             except Exception as e:
-                err_msg = str(e)
-                
-                if is_quota_error(err_msg):
-                    task["log"] += f"⚠️ QUOTA EXCEEDED on IP {current_ip}\n"
-                    task["log"] += f"🔄 Rotating Tor circuit...\n"
-                    new_ip = rotate_tor_circuit()
-                    task["log"] += f"   🧅 New IP: {new_ip}\n"
-                    tor_retry += 1
-                    continue
-                
-                elif is_tor_blocked(err_msg):
-                    task["log"] += f"⚠️ Tor IP BLOCKED: {current_ip}\n"
-                    new_ip = rotate_tor_circuit()
-                    task["log"] += f"   🧅 New IP: {new_ip}\n"
-                    tor_retry += 1
-                    continue
-                
-                elif is_gpu_cold_error(err_msg):
-                    task["log"] += f"⏳ GPU cold start. Waiting {GPU_RETRY_DELAY}s...\n"
+                em = str(e)
+                if is_quota_error(em) or is_tor_blocked(em):
+                    task["log"] += f"⚠️ {'Quota' if is_quota_error(em) else 'Blocked'}. Rotating...\n"
+                    nip = rotate_tor_circuit()
+                    task["log"] += f"🧅 New: {nip}\n"
+                elif is_gpu_cold(em):
+                    task["log"] += f"⏳ GPU cold, wait {GPU_RETRY_DELAY}s...\n"
                     time.sleep(GPU_RETRY_DELAY)
                     continue
-                
-                elif "timeout" in err_msg.lower() or "timed out" in err_msg.lower():
-                    task["log"] += f"⏰ Timeout! Retrying with new IP...\n"
+                elif "timeout" in em.lower():
+                    task["log"] += "⏰ Timeout, retry...\n"
                     time.sleep(GPU_RETRY_DELAY)
-                    new_ip = rotate_tor_circuit()
-                    task["log"] += f"   🧅 New IP: {new_ip}\n"
-                    tor_retry += 1
-                    continue
-                
+                    nip = rotate_tor_circuit()
+                    task["log"] += f"🧅 New: {nip}\n"
                 else:
-                    task["log"] += f"⚠️ Error: {err_msg[:200]}\n"
-                    if tor_retry < MAX_TOR_RETRIES:
-                        new_ip = rotate_tor_circuit()
-                        task["log"] += f"   🧅 New IP: {new_ip}\n"
-                    tor_retry += 1
-                    continue
+                    task["log"] += f"⚠️ {em[:150]}\n"
+                    if retry < MAX_TOR_RETRIES:
+                        nip = rotate_tor_circuit()
+                        task["log"] += f"🧅 New: {nip}\n"
+                retry += 1
         
-        # POST-PROCESSING
-        if success and final_video:
-            out_filename = f"{task_id}.mp4"
-            out_path = OUTPUT_DIR / out_filename
-            
-            if isinstance(final_video, dict) and "video" in final_video:
-                src = final_video["video"]
-            elif isinstance(final_video, str):
-                src = final_video
-            else:
-                src = str(final_video)
-            
-            task["log"] += f"💾 Saving video...\n"
-            
-            try:
-                shutil.copy2(src, str(out_path))
-                
-                thumb_filename = f"{task_id}.jpg"
-                thumb_path = OUTPUT_DIR / thumb_filename
-                has_thumb = generate_thumbnail(str(out_path), str(thumb_path))
-                
-                video_info = get_video_info(str(out_path))
-                
-                task["video_path"] = out_filename
-                task["thumbnail_path"] = thumb_filename if has_thumb else None
-                task["video_info"] = video_info
-                task["status"] = "complete"
-                task["progress"] = 100
-                task["log"] += (
-                    f"✅ SUCCESS: {video_info['width']}x{video_info['height']}, "
-                    f"{video_info['duration']:.1f}s, {video_info['size'] // 1024}KB\n"
-                )
-                
-            except Exception as e:
-                task["status"] = "error"
-                task["log"] += f"❌ Save failed: {str(e)[:150]}\n"
+        if ok and vid:
+            outf = f"{task_id}.mp4"
+            outp = OUTPUT_DIR / outf
+            src = vid["video"] if isinstance(vid,dict) and "video" in vid else str(vid)
+            shutil.copy2(src, str(outp))
+            tf = f"{task_id}.jpg"
+            tp = OUTPUT_DIR / tf
+            ht = gen_thumb(str(outp), str(tp))
+            vi = get_video_info(str(outp))
+            task.update(video_path=outf, thumbnail_path=tf if ht else None, video_info=vi, status="complete", progress=100)
+            task["log"] += f"✅ {vi['width']}x{vi['height']}, {vi['duration']:.1f}s, {vi['size']//1024}KB\n"
         else:
             task["status"] = "error"
-            task["log"] += f"❌ Failed after {tor_retry + 1} Tor IP rotations\n"
-            
+            task["log"] += f"❌ Failed after {retry+1} rotations\n"
     except Exception as e:
         task["status"] = "error"
         task["log"] += f"❌ FATAL: {str(e)[:150]}\n"
@@ -472,62 +315,38 @@ def run_generation_task(
 # ⚡ VIDEO STREAMING
 # ═══════════════════════════════════════════════════════════════════════════════
 
-def stream_video(video_path: str, request: Request):
-    file_size = os.path.getsize(video_path)
-    range_header = request.headers.get('range')
-
-    if range_header:
-        range_match = range_header.replace('bytes=', '').split('-')
-        start = int(range_match[0]) if range_match[0] else 0
-        end = int(range_match[1]) if len(range_match) > 1 and range_match[1] else file_size - 1
-        start = min(start, file_size - 1)
-        end = min(end, file_size - 1)
-        content_length = end - start + 1
-
-        def iterfile():
-            with open(video_path, 'rb') as f:
-                f.seek(start)
-                remaining = content_length
-                while remaining > 0:
-                    chunk = f.read(min(1024 * 1024, remaining))
-                    if not chunk: break
-                    remaining -= len(chunk)
-                    yield chunk
-
-        return StreamingResponse(
-            iterfile(), status_code=206, media_type='video/mp4',
-            headers={
-                'Content-Range': f'bytes {start}-{end}/{file_size}',
-                'Accept-Ranges': 'bytes',
-                'Content-Length': str(content_length),
-                'Cache-Control': 'public, max-age=86400',
-                'Content-Disposition': 'inline',
-            }
-        )
+def stream_video(vpath, req):
+    fsz = os.path.getsize(vpath)
+    rh = req.headers.get('range')
+    if rh:
+        m = rh.replace('bytes=','').split('-')
+        s = int(m[0]) if m[0] else 0
+        e = int(m[1]) if len(m)>1 and m[1] else fsz-1
+        s,e = min(s,fsz-1),min(e,fsz-1)
+        cl = e-s+1
+        def it():
+            with open(vpath,'rb') as f:
+                f.seek(s); r=cl
+                while r>0:
+                    c=f.read(min(1048576,r))
+                    if not c: break
+                    r-=len(c); yield c
+        return StreamingResponse(it(),status_code=206,media_type='video/mp4',headers={'Content-Range':f'bytes {s}-{e}/{fsz}','Accept-Ranges':'bytes','Content-Length':str(cl),'Cache-Control':'public, max-age=86400'})
     else:
-        def iterfile():
-            with open(video_path, 'rb') as f:
+        def it():
+            with open(vpath,'rb') as f:
                 while True:
-                    chunk = f.read(1024 * 1024)
-                    if not chunk: break
-                    yield chunk
-
-        return StreamingResponse(
-            iterfile(), status_code=200, media_type='video/mp4',
-            headers={
-                'Accept-Ranges': 'bytes',
-                'Content-Length': str(file_size),
-                'Cache-Control': 'public, max-age=86400',
-                'Content-Disposition': 'inline',
-            }
-        )
+                    c=f.read(1048576)
+                    if not c: break
+                    yield c
+        return StreamingResponse(it(),status_code=200,media_type='video/mp4',headers={'Accept-Ranges':'bytes','Content-Length':str(fsz),'Cache-Control':'public, max-age=86400'})
 
 
 # ═══════════════════════════════════════════════════════════════════════════════
-# 🌐 FASTAPI APPLICATION
+# 🌐 FASTAPI — ZERO BLOCKING STARTUP
 # ═══════════════════════════════════════════════════════════════════════════════
 
-app = FastAPI(title="SODA-GEN Anonymous Relay V1.4")
+app = FastAPI(title="SODA-GEN Relay V1.5")
 
 app.add_middleware(
     CORSMiddleware,
@@ -538,47 +357,20 @@ app.add_middleware(
 )
 
 
-# ═══════════════════════════════════════════════════════════
-# 🔧 V1.4 FIX: STARTUP IS LIGHTWEIGHT — NO BLOCKING CALLS
-# ═══════════════════════════════════════════════════════════
-
-@app.on_event("startup")
-async def on_startup():
-    """
-    V1.4: Startup event is FAST and NON-BLOCKING.
-    Only prints basic info. Tor IP check runs in background thread.
-    This ensures HF Space health check gets instant response → no 503.
-    """
-    print("=" * 60)
-    print("🧅 SODA-GEN Anonymous Relay V1.4 — HF Space CPU")
-    print(f"   📡 Target: {TARGET_URL}")
-    print(f"   🧅 Proxy: {TOR_PROXY}")
-    print(f"   ⏱️ Timeout: {PREDICT_TIMEOUT}s")
-    print(f"   🎬 ffmpeg: {'✅' if shutil.which('ffmpeg') else '❌'}")
-    print(f"   🧅 Tor init: running in background thread...")
-    print("=" * 60)
-    
-    # Start Tor initialization in BACKGROUND thread
-    # This does NOT block the startup event
-    t = threading.Thread(target=_background_tor_init, daemon=True)
-    t.start()
+# ══════════════════════════════════════════════════════
+# 🔑 ROOT ENDPOINT — HF Space health check butuh ini!
+# ══════════════════════════════════════════════════════
+@app.get("/")
+async def root():
+    """HF Space checks this to determine if space is alive"""
+    return {"status": "ok", "service": "SODA-GEN Relay V1.5", "tor_ready": _tor_ready}
 
 
 @app.get("/api/health")
-async def health_check():
-    """
-    Lightweight health check — responds INSTANTLY.
-    Tor IP is optional (shows cached or 'initializing').
-    HF Space uses this to determine if space is alive.
-    """
+async def health():
     return JSONResponse({
-        "status": "ok",
-        "mode": "anonymous",
-        "version": "1.4",
-        "tor_ip": _last_tor_ip["ip"],
-        "tor_ready": _tor_ready,
-        "proxy_scheme": "socks5://",
-        "ffmpeg": shutil.which("ffmpeg") is not None,
+        "status": "ok", "mode": "anonymous", "version": "1.5",
+        "tor_ip": _last_tor_ip["ip"], "tor_ready": _tor_ready,
     })
 
 
@@ -592,103 +384,63 @@ async def api_generate(
     img_start: Optional[UploadFile] = File(None),
     img_end: Optional[UploadFile] = File(None),
 ):
-    task_id = uuid.uuid4().hex[:12]
-    task_dir = UPLOAD_DIR / task_id
-    task_dir.mkdir(exist_ok=True)
-
-    img1_path = None
-    img2_path = None
-
+    tid = uuid.uuid4().hex[:12]
+    td = UPLOAD_DIR / tid
+    td.mkdir(exist_ok=True)
+    i1 = i2 = None
     if img_start and img_start.filename:
-        img1_path = str(task_dir / "start.png")
-        with open(img1_path, "wb") as f:
-            f.write(await img_start.read())
-
+        i1 = str(td/"start.png")
+        with open(i1,"wb") as f: f.write(await img_start.read())
     if img_end and img_end.filename:
-        img2_path = str(task_dir / "end.png")
-        with open(img2_path, "wb") as f:
-            f.write(await img_end.read())
+        i2 = str(td/"end.png")
+        with open(i2,"wb") as f: f.write(await img_end.read())
+    TASKS[tid] = {"status":"queued","progress":0,"log":"","video_path":None,"thumbnail_path":None,"video_info":None}
+    background_tasks.add_task(run_generation_task, task_id=tid, prompt=prompt, img1_path=i1, img2_path=i2, duration=duration, steps=steps, frame_mult=frame_mult)
+    return JSONResponse({"task_id": tid})
 
-    TASKS[task_id] = {
-        "status": "queued",
-        "progress": 0,
-        "log": "",
-        "video_path": None,
-        "thumbnail_path": None,
-        "video_info": None,
-    }
 
-    background_tasks.add_task(
-        run_generation_task,
-        task_id=task_id, prompt=prompt,
-        img1_path=img1_path, img2_path=img2_path,
-        duration=duration, steps=steps, frame_mult=frame_mult,
-    )
+@app.get("/api/task/{task_id}")
+async def api_task(task_id: str):
+    t = TASKS.get(task_id)
+    if not t: return JSONResponse({"error":"Not found"}, status_code=404)
+    r = {"status":t["status"],"progress":t["progress"],"log":t["log"]}
+    if t["status"]=="complete" and t.get("video_path"):
+        r["video_url"] = f"/api/video/{t['video_path']}"
+        if t.get("thumbnail_path"): r["thumbnail_url"] = f"/api/thumbnail/{t['thumbnail_path']}"
+        if t.get("video_info"): r["video_info"] = t["video_info"]
+    return JSONResponse(r)
 
-    return JSONResponse({"task_id": task_id})
 
+@app.get("/api/video/{fn}")
+async def vid(fn: str, request: Request):
+    p = OUTPUT_DIR/fn
+    if not p.exists(): return JSONResponse({"error":"Not found"}, status_code=404)
+    return stream_video(str(p), request)
 
-@app.get("/api/task/{task_id}")
-async def api_task_status(task_id: str):
-    task = TASKS.get(task_id)
-    if not task:
-        return JSONResponse({"error": "Task not found"}, status_code=404)
-
-    resp = {
-        "status": task["status"],
-        "progress": task["progress"],
-        "log": task["log"],
-    }
-    if task["status"] == "complete" and task.get("video_path"):
-        resp["video_url"] = f"/api/video/{task['video_path']}"
-        if task.get("thumbnail_path"):
-            resp["thumbnail_url"] = f"/api/thumbnail/{task['thumbnail_path']}"
-        if task.get("video_info"):
-            resp["video_info"] = task["video_info"]
-
-    return JSONResponse(resp)
-
-
-@app.get("/api/video/{filename}")
-async def serve_video(filename: str, request: Request):
-    video_path = OUTPUT_DIR / filename
-    if not video_path.exists():
-        return JSONResponse({"error": "Video not found"}, status_code=404)
-    return stream_video(str(video_path), request)
-
-
-@app.get("/api/thumbnail/{filename}")
-async def serve_thumbnail(filename: str):
-    thumb_path = OUTPUT_DIR / filename
-    if not thumb_path.exists():
-        return JSONResponse({"error": "Thumbnail not found"}, status_code=404)
-    return FileResponse(
-        str(thumb_path), media_type="image/jpeg",
-        headers={"Cache-Control": "public, max-age=86400"}
-    )
+
+@app.get("/api/thumbnail/{fn}")
+async def thumb(fn: str):
+    p = OUTPUT_DIR/fn
+    if not p.exists(): return JSONResponse({"error":"Not found"}, status_code=404)
+    return FileResponse(str(p), media_type="image/jpeg", headers={"Cache-Control":"public, max-age=86400"})
 
 
 @app.get("/api/stats")
-async def api_stats():
+async def stats():
     return JSONResponse({
-        "mode": "anonymous",
-        "tor_ip": _last_tor_ip["ip"],
-        "tor_ready": _tor_ready,
-        "quota_per_ip": 120,
-        "total_tokens": "infinity (Tor rotation)",
-        "active_tokens": "∞",
-        "cooldown_tokens": 0,
-        "version": "1.4",
+        "mode":"anonymous","tor_ip":_last_tor_ip["ip"],"tor_ready":_tor_ready,
+        "quota_per_ip":120,"total_tokens":"infinity","active_tokens":"∞",
+        "cooldown_tokens":0,"version":"1.5",
     })
 
 
 @app.get("/api/tor-ip")
-async def api_tor_ip():
+async def torip():
     _last_tor_ip["ip"] = "unknown"
     return JSONResponse({"ip": get_tor_ip()})
 
 
 @app.post("/api/tor-rotate")
-async def api_tor_rotate():
-    new_ip = rotate_tor_circuit()
-    return JSONResponse({"new_ip": new_ip, "success": new_ip != "rotation_failed"})
+async def torrot():
+    nip = rotate_tor_circuit()
+    return JSONResponse({"new_ip": nip, "success": nip != "rotation_failed"})