Create app.py

app.py

@@ -0,0 +1,650 @@
+# ═══════════════════════════════════════════════════════════════════════════════
+# 🧅 SODA-GEN ANONYMOUS RELAY V1.2 — HF SPACE CPU (BACKEND ONLY)
+# 
+# MODE: Anonymous + Tor IP Rotation
+# QUOTA: 120s per Tor exit node (auto-rotate on exhaustion)
+# TARGET: https://r3gm-wan2-2-fp8da-aoti-preview-2.hf.space
+# PLATFORM: Hugging Face Spaces (Docker / CPU Basic)
+#
+# INI BACKEND ONLY — Relay 1 (HF Space) tetap full stack dengan UI
+# V1.2: Adapted for HF Space (no ngrok, Docker-native Tor)
+# ═══════════════════════════════════════════════════════════════════════════════
+
+import json
+import os
+import random
+import re
+import shutil
+import subprocess
+import time
+import uuid
+from pathlib import Path
+from typing import Dict, Any, Optional
+
+import httpx
+from fastapi import FastAPI, UploadFile, File, Form, BackgroundTasks, Request
+from fastapi.responses import FileResponse, JSONResponse, StreamingResponse
+from fastapi.middleware.cors import CORSMiddleware
+from gradio_client import Client, handle_file
+from PIL import Image
+from stem import Signal
+from stem.control import Controller
+import threading
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# ⚙️ CONFIGURATION
+# ═══════════════════════════════════════════════════════════════════════════════
+
+TARGET_URL = "https://r3gm-wan2-2-fp8da-aoti-preview-2.hf.space"
+TOR_PROXY = "socks5h://127.0.0.1:9050"
+PREDICT_TIMEOUT = 300          # 5 minutes for full generation
+MAX_TOR_RETRIES = 5            # Max circuit rotations per request
+GPU_RETRY_DELAY = 15           # Wait before GPU cold retry
+
+WAN_NEG = (
+    "色调艳丽, 过曝, 静态, 细节模糊不清, 字幕, 风格, 作品, 画作, 画面, 静止, "
+    "整体发灰, 最差质量, 低质量, JPEG压缩残留, 丑陋的, 残缺的, 多余手指, "
+    "画不好手部, 畸形, 毁容"
+)
+
+OUTPUT_DIR = Path("outputs")
+OUTPUT_DIR.mkdir(exist_ok=True)
+UPLOAD_DIR = Path("uploads")
+UPLOAD_DIR.mkdir(exist_ok=True)
+
+TASKS: Dict[str, Dict[str, Any]] = {}
+
+# Track last known Tor IP for caching
+_last_tor_ip = {"ip": "unknown", "time": 0}
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# 🧅 TOR ENGINE
+# ═══════════════════════════════════════════════════════════════════════════════
+
+def ensure_tor_running():
+    """Ensure Tor daemon is active"""
+    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")
+    except:
+        subprocess.run(["service", "tor", "start"], capture_output=True, timeout=10)
+        time.sleep(3)
+
+
+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()
+        _last_tor_ip["ip"] = ip
+        _last_tor_ip["time"] = now
+        return ip
+    except Exception as e:
+        print(f"⚠️ get_tor_ip failed: {e}")
+        return "unknown"
+
+
+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"  # Force refresh
+            new_ip = get_tor_ip()
+            print(f"🔄 Tor rotated → {new_ip}")
+            return new_ip
+    except Exception as e:
+        # Fallback: restart Tor entirely
+        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"
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# 📡 GRADIO CLIENT WITH PROXY
+# ═══════════════════════════════════════════════════════════════════════════════
+
+class GradioClientWithProxy:
+    """
+    Wrapper untuk gradio_client yang route traffic via Tor proxy.
+    
+    gradio_client internal menggunakan httpx, yang respect env vars.
+    Kita set HTTP_PROXY/HTTPS_PROXY sebelum Client() dibuat.
+    """
+    
+    def __init__(self, base_url: str, proxy: str = None):
+        self.base_url = base_url
+        self.proxy = proxy
+        self.client = None
+        self._old_env = {}
+        self._setup_client()
+    
+    def _setup_client(self):
+        """Setup gradio_client dengan proxy"""
+        if self.proxy:
+            # Save old values
+            for key in ["HTTP_PROXY", "HTTPS_PROXY", "http_proxy", "https_proxy"]:
+                self._old_env[key] = os.environ.get(key)
+            # Set proxy
+            os.environ["HTTP_PROXY"] = self.proxy
+            os.environ["HTTPS_PROXY"] = self.proxy
+            os.environ["http_proxy"] = self.proxy
+            os.environ["https_proxy"] = self.proxy
+        
+        self.client = Client(
+            self.base_url,
+            headers={"User-Agent": "SodaGen-Anonymous/1.2"}
+        )
+    
+    def submit(self, **kwargs):
+        return self.client.submit(**kwargs)
+    
+    def predict(self, **kwargs):
+        return self.client.predict(**kwargs)
+    
+    def _restore_env(self):
+        """Restore original env vars"""
+        for key, val in self._old_env.items():
+            if val is None:
+                os.environ.pop(key, None)
+            else:
+                os.environ[key] = val
+    
+    def __del__(self):
+        self._restore_env()
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# 📊 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)
+    if m:
+        retry_str = m.group(1).strip()
+        try:
+            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
+    return None
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# 🎬 VIDEO POST-PROCESSING
+# ═══════════════════════════════════════════════════════════════════════════════
+
+def get_video_info(video_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}
+    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}
+
+
+def generate_thumbnail(video_path: str, output_path: str) -> bool:
+    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
+
+
+def resize_image_for_video(image_path, width=768, height=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
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# 🚀 GENERATION TASK (ANONYMOUS MODE)
+# ═══════════════════════════════════════════════════════════════════════════════
+
+def run_generation_task(
+    task_id: str,
+    prompt: str,
+    img1_path: Optional[str],
+    img2_path: Optional[str],
+    duration: float,
+    steps: float,
+    frame_mult: int,
+):
+    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"⏱️ Timeout: {PREDICT_TIMEOUT}s | Max Tor retries: {MAX_TOR_RETRIES}\n"
+        
+        ensure_tor_running()
+        
+        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
+        
+        safe_img1 = handle_file(img1_resized) if img1_resized else None
+        safe_img2 = handle_file(img2_resized) if img2_resized else None
+        
+        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"
+            
+            try:
+                client_wrapper = GradioClientWithProxy(TARGET_URL, proxy=TOR_PROXY)
+                
+                task["log"] += f"🚀 Submitting to HF Space (anonymous via Tor)...\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,
+                    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,
+                    frame_multiplier=int(frame_mult),
+                    safe_mode=False,
+                    video_component=True,
+                    api_name="/generate_video",
+                )
+                
+                task["log"] += f"⏳ Waiting for result (timeout: {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"
+                    break
+                else:
+                    task["log"] += f"⚠️ No video in result: {str(result)[:200]}\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"
+                    retry_time = parse_retry_time(err_msg)
+                    if retry_time:
+                        task["log"] += f"   ⏰ Retry in: {retry_time}s\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"
+                    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"
+                    time.sleep(GPU_RETRY_DELAY)
+                    new_ip = rotate_tor_circuit()
+                    task["log"] += f"   🧅 New IP: {new_ip}\n"
+                    tor_retry += 1
+                    continue
+                
+                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
+        
+        # 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"
+        else:
+            task["status"] = "error"
+            task["log"] += f"❌ Failed after {tor_retry + 1} Tor IP rotations\n"
+            
+    except Exception as e:
+        task["status"] = "error"
+        task["log"] += f"❌ FATAL: {str(e)[:150]}\n"
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# ⚡ 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',
+            }
+        )
+    else:
+        def iterfile():
+            with open(video_path, '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',
+            }
+        )
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# 🌐 FASTAPI APPLICATION (BACKEND ONLY — NO UI)
+# ═══════════════════════════════════════════════════════════════════════════════
+
+app = FastAPI(title="SODA-GEN Anonymous Relay V1.2")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+@app.get("/api/health")
+async def health_check():
+    ip = get_tor_ip()
+    tor_ok = ip != "unknown" and ip != "rotation_failed"
+    return JSONResponse({
+        "status": "ok",
+        "mode": "anonymous",
+        "version": "1.2",
+        "tor_ip": ip,
+        "tor_active": tor_ok,
+        "ffmpeg": shutil.which("ffmpeg") is not None,
+    })
+
+
+@app.post("/api/generate")
+async def api_generate(
+    background_tasks: BackgroundTasks,
+    prompt: str = Form(...),
+    duration: float = Form(5.0),
+    steps: float = Form(6.0),
+    frame_mult: int = Form(16),
+    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
+
+    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())
+
+    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())
+
+    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,
+    )
+
+    return JSONResponse({"task_id": task_id})
+
+
+@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/stats")
+async def api_stats():
+    ip = get_tor_ip()
+    return JSONResponse({
+        "mode": "anonymous",
+        "tor_ip": ip,
+        "quota_per_ip": 120,
+        "total_tokens": "infinity (Tor rotation)",
+        "active_tokens": "∞",
+        "cooldown_tokens": 0,
+        "version": "1.2",
+    })
+
+
+@app.get("/api/tor-ip")
+async def api_tor_ip():
+    _last_tor_ip["ip"] = "unknown"  # Force fresh check
+    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"})
+
+
+@app.on_event("startup")
+async def on_startup():
+    ensure_tor_running()
+    ip = get_tor_ip()
+    print("=" * 60)
+    print("🧅 SODA-GEN Anonymous Relay V1.2 — HF Space CPU")
+    print(f"   🌐 Tor IP: {ip}")
+    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"   🎬 ffprobe: {'✅' if shutil.which('ffprobe') else '❌'}")
+    print("=" * 60)