Update app.py

app.py

@@ -2,20 +2,19 @@ import os
 import random
 import time
 import threading
+import requests
+import json
 from flask import Flask, request, jsonify, send_file
 from flask_cors import CORS
-from gradio_client import Client
+from concurrent.futures import ThreadPoolExecutor
 
 app = Flask(__name__)
-# Aktifkan CORS untuk semua akses
 CORS(app)
 
-# --- KONFIGURASI TARGET (SESUAI PERINTAH) ---
-# Menggunakan direct link Spaces Flux yang kamu berikan
-TARGET_SPACE = "https://black-forest-labs-flux-2-dev.hf.space"
+# --- KONFIGURASI TARGET ---
+TARGET_SPACE_URL = "https://black-forest-labs-flux-2-dev.hf.space"
 
-# --- TOKEN LIST ---
-# Token sudah ditanam dengan tanda '+' agar lolos deteksi
+# --- TOKEN LIST (Tetap ditanam) ---
 RAW_TOKENS = [
     "hf_+PiRCDDtPcPFMLWkTkVaZmzoleHOunXnLIA",
     "hf_+BHvZXGICstaktSwycmwNmzHGrTNmKxnlRZ",
@@ -34,80 +33,130 @@ RAW_TOKENS = [
 # --- TOKEN MANAGER ---
 class TokenManager:
     def __init__(self, raw_tokens):
-        # Hapus tanda '+' dan spasi
         self.tokens = [t.replace("+", "").strip() for t in raw_tokens if t.strip()]
         self.current_index = 0
         self.lock = threading.Lock()
 
     def get_token(self):
         with self.lock:
-            if not self.tokens:
-                raise Exception("List token kosong!")
+            if not self.tokens: raise Exception("List token kosong!")
             token = self.tokens[self.current_index]
             self.current_index = (self.current_index + 1) % len(self.tokens)
             return token
 
 token_manager = TokenManager(RAW_TOKENS)
 
-# --- LOGIKA GENERATE ---
-def process_generation_with_retry(prompt, width, height, guidance_scale, seed):
-    # Batasi retry maksimal 5 kali agar tidak stuck
+# --- FUNGSI REQUEST MANUAL (CARA LAIN) ---
+def request_flux_manual(prompt, width, height, guidance_scale, seed):
+    """
+    Menggunakan requests murni, tanpa gradio_client.
+    Menembak endpoint /api/predict milik Space.
+    """
     max_retries = 5
     attempt = 0
     last_error = ""
 
+    # Endpoint API Gradio standar (Legacy & V4 compatible)
+    # Kita coba dua kemungkinan endpoint: /api/predict (Gradio 3/Lite) atau /run/predict (Gradio 4)
+    # Biasanya untuk space publik, /api/predict adalah yang paling umum terekspos.
+    api_url = f"{TARGET_SPACE_URL}/api/predict"
+
     while attempt < max_retries:
         current_token = token_manager.get_token()
-        print(f"[LOG] Mencoba request dengan token akhiran ...{current_token[-5:]}")
+        print(f"[LOG] Attempt {attempt+1} - Token: ...{current_token[-5:]}")
+
+        headers = {
+            "Authorization": f"Bearer {current_token}",
+            "Content-Type": "application/json"
+        }
+
+        # Payload JSON standar untuk Flux Dev Space
+        # Urutan 'data' sangat penting! Biasanya:
+        # [prompt, seed, randomize_seed, width, height, guidance, num_inference_steps]
+        payload = {
+            "fn_index": 0, # Index fungsi default (biasanya 0 untuk generate)
+            "data": [
+                prompt,
+                int(seed) if seed is not None else 0,
+                True if seed is None else False, # randomize_seed
+                int(width),
+                int(height),
+                float(guidance_scale),
+                28 # num_inference_steps (default flux)
+            ]
+        }
 
         try:
-            # Langsung konek ke URL yang kamu kasih
-            client = Client(TARGET_SPACE, hf_token=current_token)
+            # 1. Kirim Request Generate
+            response = requests.post(api_url, headers=headers, json=payload, timeout=120)
+            
+            if response.status_code != 200:
+                raise Exception(f"Status {response.status_code}: {response.text[:100]}")
             
-            # Parameter request
-            result = client.predict(
-                prompt=prompt,
-                seed=int(seed) if seed is not None else 0,
-                randomize_seed=(seed is None),
-                width=int(width),
-                height=int(height),
-                guidance_scale=float(guidance_scale),
-                num_inference_steps=28,
-                api_name="/infer"
-            )
+            resp_json = response.json()
             
-            # Flux biasanya return tuple path file di index 0
-            return result[0]
+            # 2. Parsing Hasil
+            # Gradio API biasanya mengembalikan: {"data": ["/tmp/..."], ...}
+            if "data" in resp_json and len(resp_json["data"]) > 0:
+                file_info = resp_json["data"][0]
+                
+                # Cek apakah response berupa URL atau Path
+                # Flux space sering mengembalikan object seperti {"path": "...", "url": "..."} atau string path langsung
+                download_url = ""
+                
+                if isinstance(file_info, dict) and "url" in file_info:
+                    download_url = file_info["url"]
+                elif isinstance(file_info, str):
+                    # Jika string path lokal (/tmp/...), kita harus fetch dari endpoint file=
+                    # Kecuali kalau dia sudah full URL
+                    if file_info.startswith("http"):
+                        download_url = file_info
+                    else:
+                        download_url = f"{TARGET_SPACE_URL}/file={file_info}"
+                else:
+                    raise Exception("Format response data tidak dikenali.")
+
+                # 3. Download Gambar Hasil ke Server Proxy (Memory)
+                print(f"[LOG] Downloading result from: {download_url}")
+                img_response = requests.get(download_url, timeout=60)
+                
+                # Simpan sementara di /tmp server kita untuk dikirim ke user
+                temp_filename = f"/tmp/flux_{int(time.time())}_{random.randint(0,1000)}.webp"
+                with open(temp_filename, 'wb') as f:
+                    f.write(img_response.content)
+                
+                return temp_filename
+
+            else:
+                raise Exception(f"Response data kosong/salah format: {resp_json}")
 
         except Exception as e:
-            error_msg = str(e)
-            print(f"[ERROR] Token ...{current_token[-5:]} gagal: {error_msg}")
+            err_msg = str(e)
+            print(f"[ERROR] {err_msg}")
             
-            # Cek limit atau kuota habis
-            if "429" in error_msg or "quota" in error_msg.lower():
-                print("[INFO] Rate limit kena, ganti token selanjutnya...")
+            if "429" in err_msg or "quota" in err_msg.lower():
+                 print("[INFO] Rate limit/Quota, lanjut token berikutnya.")
             else:
-                last_error = error_msg
+                last_error = err_msg
             
             attempt += 1
-            time.sleep(0.5)
+            time.sleep(1)
 
-    raise Exception(f"Gagal generate gambar. Error terakhir: {last_error}")
+    raise Exception(f"Gagal total setelah {max_retries}x coba. Error: {last_error}")
 
-# --- ROUTES ---
 
+# --- ROUTES ---
 @app.route('/')
 def home():
     return jsonify({
-        "status": "Ready",
-        "target": TARGET_SPACE,
-        "tokens_active": len(token_manager.tokens)
+        "status": "Online (Requests Mode)", 
+        "target": TARGET_SPACE_URL,
+        "mode": "No-Gradio-Client"
     })
 
 @app.route('/generate', methods=['POST'])
 def generate():
     data = request.json
-    
     if not data or 'prompt' not in data:
         return jsonify({"error": "Prompt wajib diisi"}), 400
 
@@ -118,12 +167,11 @@ def generate():
     seed = data.get('seed', None)
 
     try:
-        image_path = process_generation_with_retry(prompt, width, height, guidance, seed)
-        # Mengembalikan file gambar hasil generate
+        image_path = request_flux_manual(prompt, width, height, guidance, seed)
         return send_file(image_path, mimetype='image/webp')
-
     except Exception as e:
         return jsonify({"error": str(e)}), 500
 
 if __name__ == '__main__':
     app.run(host='0.0.0.0', port=7860)
+