Update app.py

app.py

@@ -4,17 +4,18 @@ import time
 import threading
 import requests
 import json
-from flask import Flask, request, jsonify, send_file
+from flask import Flask, request, jsonify, send_file, make_response
 from flask_cors import CORS
-from concurrent.futures import ThreadPoolExecutor
 
 app = Flask(__name__)
-CORS(app)
+# Enable CORS secara explicit dan permissive
+CORS(app, resources={r"/*": {"origins": "*"}})
 
-# --- KONFIGURASI TARGET ---
-TARGET_SPACE_URL = "https://black-forest-labs-flux-2-dev.hf.space"
+# --- TARGET CONFIG ---
+# URL Space Flux kamu
+BASE_URL = "https://black-forest-labs-flux-2-dev.hf.space"
 
-# --- TOKEN LIST (Tetap ditanam) ---
+# --- TOKEN LIST (HARDCODED) ---
 RAW_TOKENS = [
     "hf_+PiRCDDtPcPFMLWkTkVaZmzoleHOunXnLIA",
     "hf_+BHvZXGICstaktSwycmwNmzHGrTNmKxnlRZ",
@@ -30,7 +31,6 @@ RAW_TOKENS = [
     "hf_+ivSBboJYQVcifWkCNcOTOnxUQrZOtOglnU"
 ]
 
-# --- TOKEN MANAGER ---
 class TokenManager:
     def __init__(self, raw_tokens):
         self.tokens = [t.replace("+", "").strip() for t in raw_tokens if t.strip()]
@@ -39,42 +39,36 @@ class TokenManager:
 
     def get_token(self):
         with self.lock:
-            if not self.tokens: raise Exception("List token kosong!")
+            if not self.tokens: raise Exception("No tokens available")
             token = self.tokens[self.current_index]
             self.current_index = (self.current_index + 1) % len(self.tokens)
             return token
 
 token_manager = TokenManager(RAW_TOKENS)
 
-# --- FUNGSI REQUEST MANUAL (CARA LAIN) ---
-def request_flux_manual(prompt, width, height, guidance_scale, seed):
+def request_flux_gradio4(prompt, width, height, guidance_scale, seed):
     """
-    Menggunakan requests murni, tanpa gradio_client.
-    Menembak endpoint /api/predict milik Space.
+    Menangani request khusus untuk Gradio 4 (Flux Standard)
+    Endpoint: /gradio_api/call/infer
     """
     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"
+    
+    # Endpoint Gradio 4 yang Benar
+    api_url = f"{BASE_URL}/gradio_api/call/infer"
 
     while attempt < max_retries:
-        current_token = token_manager.get_token()
-        print(f"[LOG] Attempt {attempt+1} - Token: ...{current_token[-5:]}")
-
+        token = token_manager.get_token()
+        print(f"[LOG] Attempt {attempt+1} - Token: ...{token[-5:]}")
+        
         headers = {
-            "Authorization": f"Bearer {current_token}",
+            "Authorization": f"Bearer {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 Gradio 4 (Tanpa fn_index, langsung data array)
         payload = {
-            "fn_index": 0, # Index fungsi default (biasanya 0 untuk generate)
             "data": [
                 prompt,
                 int(seed) if seed is not None else 0,
@@ -82,83 +76,94 @@ def request_flux_manual(prompt, width, height, guidance_scale, seed):
                 int(width),
                 int(height),
                 float(guidance_scale),
-                28 # num_inference_steps (default flux)
+                28 # num_inference_steps
             ]
         }
 
         try:
-            # 1. Kirim Request Generate
-            response = requests.post(api_url, headers=headers, json=payload, timeout=120)
+            # 1. Kirim Job ID Request
+            response = requests.post(api_url, headers=headers, json=payload, timeout=30)
             
             if response.status_code != 200:
-                raise Exception(f"Status {response.status_code}: {response.text[:100]}")
-            
+                raise Exception(f"HTTP Error {response.status_code}: {response.text}")
+
             resp_json = response.json()
+            # Gradio 4 mengembalikan { "event_id": "..." }
+            event_id = resp_json.get("event_id")
+            if not event_id:
+                raise Exception(f"No event_id returned: {resp_json}")
+
+            # 2. Polling Hasil (Gradio 4 butuh polling status request)
+            # Kita tembak endpoint result untuk event_id tersebut
+            result_url = f"{BASE_URL}/gradio_api/call/infer/{event_id}"
             
-            # 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]
+            # Tunggu proses selesai (polling loop)
+            # Karena flux cepat, kita poll tiap 1 detik
+            for _ in range(60): # Max tunggu 60 detik
+                time.sleep(1) 
+                poll_resp = requests.get(result_url, headers=headers, stream=True) # Stream true untuk jaga2
                 
-                # Cek apakah response berupa URL atau Path
-                # Flux space sering mengembalikan object seperti {"path": "...", "url": "..."} atau string path langsung
-                download_url = ""
+                # Gradio 4 streaming response berbentuk text event stream
+                # Kita cari baris yang mengandung "complete" atau data url
+                content = poll_resp.text
                 
-                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}")
+                if "process_completed" in content and "url" in content:
+                    # Parsing manual dari format event-stream
+                    # Biasanya format: event: complete \n data: [...]
+                    lines = content.split('\n')
+                    for line in lines:
+                        if line.startswith('data:'):
+                            try:
+                                data_block = json.loads(line[5:])
+                                # Cari URL output
+                                if isinstance(data_block, list) and len(data_block) > 0:
+                                    file_info = data_block[0]
+                                    final_url = file_info.get("url")
+                                    if final_url:
+                                        # Download Gambar Akhir
+                                        print(f"[LOG] Downloading: {final_url}")
+                                        img_res = requests.get(final_url, timeout=60)
+                                        temp_filename = f"/tmp/flux_{int(time.time())}_{random.randint(0,999)}.webp"
+                                        with open(temp_filename, 'wb') as f:
+                                            f.write(img_res.content)
+                                        return temp_filename
+                            except:
+                                continue
+            
+            raise Exception("Timeout waiting for Gradio 4 result")
 
         except Exception as e:
             err_msg = str(e)
             print(f"[ERROR] {err_msg}")
-            
             if "429" in err_msg or "quota" in err_msg.lower():
-                 print("[INFO] Rate limit/Quota, lanjut token berikutnya.")
+                print("Rate limit detected.")
             else:
                 last_error = err_msg
-            
             attempt += 1
             time.sleep(1)
 
-    raise Exception(f"Gagal total setelah {max_retries}x coba. Error: {last_error}")
-
+    raise Exception(f"Gagal Total: {last_error}")
 
 # --- ROUTES ---
-@app.route('/')
+
+@app.route('/', methods=['GET'])
 def home():
-    return jsonify({
-        "status": "Online (Requests Mode)", 
-        "target": TARGET_SPACE_URL,
-        "mode": "No-Gradio-Client"
-    })
+    return jsonify({"status": "Online", "mode": "Gradio 4 Native"})
+
+# Handle OPTIONS request manual untuk mencegah Failed to Fetch
+@app.route('/generate', methods=['OPTIONS'])
+def options_generate():
+    response = make_response()
+    response.headers.add("Access-Control-Allow-Origin", "*")
+    response.headers.add("Access-Control-Allow-Headers", "*")
+    response.headers.add("Access-Control-Allow-Methods", "POST, OPTIONS")
+    return response
 
 @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
+        return jsonify({"error": "Prompt required"}), 400
 
     prompt = data.get('prompt')
     width = data.get('width', 1024)
@@ -167,10 +172,13 @@ def generate():
     seed = data.get('seed', None)
 
     try:
-        image_path = request_flux_manual(prompt, width, height, guidance, seed)
+        image_path = request_flux_gradio4(prompt, width, height, guidance, seed)
         return send_file(image_path, mimetype='image/webp')
     except Exception as e:
-        return jsonify({"error": str(e)}), 500
+        # Return JSON error tapi dengan CORS header agar terbaca di frontend
+        resp = jsonify({"error": str(e)})
+        resp.headers.add("Access-Control-Allow-Origin", "*")
+        return resp, 500
 
 if __name__ == '__main__':
     app.run(host='0.0.0.0', port=7860)