Update app.py

app.py

@@ -4,64 +4,11 @@ import json
 import pathlib
 import requests
 import gradio as gr
-from fastapi import FastAPI, Request
-from typing import Optional, Tuple
 
-# ========== Konfigurasi dasar ==========
 BASE = "https://api.kie.ai/api/v1"
 CREATE_URL = f"{BASE}/jobs/createTask"
 
-# Global store untuk callback terakhir
-LAST_CALLBACK_JSON = {}
-LAST_VIDEO_URL = None
-LAST_TASK_ID = None
-
-# ========== FastAPI untuk menerima callback ==========
-fastapi_app = FastAPI()
-
-def try_extract_video_url(obj: dict) -> Optional[str]:
-    # Coba berbagai nama field yang umum dipakai layanan
-    for k in [
-        "result_url", "output_url", "video_url", "download_url",
-        # nested:
-        "data.result_url", "data.output_url", "data.video_url", "data.download_url",
-    ]:
-        parts = k.split(".")
-        cur = obj
-        for p in parts:
-            if isinstance(cur, dict) and p in cur:
-                cur = cur[p]
-            else:
-                cur = None
-                break
-        if isinstance(cur, str) and cur.startswith("http"):
-            return cur
-    return None
-
-@fastapi_app.post("/api/callback")
-async def kie_callback(req: Request):
-    global LAST_CALLBACK_JSON, LAST_VIDEO_URL, LAST_TASK_ID
-    try:
-        payload = await req.json()
-    except Exception:
-        payload = {"raw": await req.body()}
-    LAST_CALLBACK_JSON = payload
-    # Simpan task id jika ada
-    for key in ["taskId", "task_id", "id"]:
-        if isinstance(payload, dict) and key in payload:
-            LAST_TASK_ID = payload[key]
-            break
-        if "data" in payload and isinstance(payload["data"], dict) and key in payload["data"]:
-            LAST_TASK_ID = payload["data"][key]
-            break
-    # Ambil link video jika dikirim
-    video_url = try_extract_video_url(payload)
-    if video_url:
-        LAST_VIDEO_URL = video_url
-    return {"ok": True}
-
-# ========== Gradio helpers ==========
-def make_headers(user_key: Optional[str]):
+def make_headers(user_key: str | None):
     api_key = (user_key or os.getenv("KIE_API_KEY") or "").strip()
     if not api_key:
         raise gr.Error("Masukkan KIE API key atau set KIE_API_KEY di Secrets.")
@@ -70,26 +17,21 @@ def make_headers(user_key: Optional[str]):
         "Content-Type": "application/json",
     }
 
-def create_task(headers, prompt: str, aspect_ratio: str, duration: str | None, callback_url: str | None) -> Tuple[str, Optional[str], str]:
+def create_task(headers, prompt: str, aspect_ratio: str, duration: str | None):
     payload = {
         "model": "sora-2-text-to-video",
         "input": {
             "prompt": prompt,
             "aspect_ratio": aspect_ratio,
-            # Patuhi ToS: jangan hapus watermark
-            "remove_watermark": False,
+            "remove_watermark": False,  # patuh ToS
         },
     }
-    if callback_url:
-        payload["callBackUrl"] = callback_url.strip()
-
-    # Durasi (opsional); hanya sertakan jika valid integer > 0
     if duration:
         try:
             d = int(duration)
             if d > 0:
                 payload["input"]["duration"] = d
-        except:
+        except Exception:
             pass
 
     r = requests.post(CREATE_URL, headers=headers, json=payload, timeout=60)
@@ -99,7 +41,6 @@ def create_task(headers, prompt: str, aspect_ratio: str, duration: str | None, c
     data = r.json()
     raw_preview = json.dumps(data)[:500]
 
-    # Ambil task-id dan status_url kalau disediakan
     task_id = (
         data.get("task_id") or data.get("taskId") or data.get("id") or
         (data.get("data") or {}).get("taskId") or (data.get("data") or {}).get("id")
@@ -109,18 +50,30 @@ def create_task(headers, prompt: str, aspect_ratio: str, duration: str | None, c
         (data.get("data") or {}).get("status_url") or (data.get("data") or {}).get("statusUrl")
     )
     if not task_id:
-        raise gr.Error(f"Tidak menemukan task_id pada response createTask: {raw_preview}")
+        raise gr.Error(f"Tidak menemukan task_id: {raw_preview}")
 
     return task_id, status_url, raw_preview
 
 def infer_status_and_result(obj: dict):
     status = obj.get("status") or obj.get("state") or (obj.get("data") or {}).get("status")
     progress = obj.get("progress") or (obj.get("data") or {}).get("progress")
-    video_url = try_extract_video_url(obj)
-    return status, progress, video_url
+    # cari link video pada beberapa kemungkinan field
+    for key in [
+        "result_url","output_url","video_url","download_url",
+    ]:
+        if key in obj and isinstance(obj[key], str) and obj[key].startswith("http"):
+            return status, progress, obj[key]
+    data = obj.get("data") or {}
+    for key in [
+        "result_url","output_url","video_url","download_url",
+    ]:
+        v = data.get(key)
+        if isinstance(v, str) and v.startswith("http"):
+            return status, progress, v
+    return status, progress, None
 
-def probe_status_url(headers, task_id: str) -> Optional[str]:
-    # Coba beberapa pola umum. Ganti jika dokumentasi Kie AI menyebutkan URL spesifik.
+def probe_status_url(headers, task_id: str):
+    # Coba beberapa pola umum sampai ada yang OK
     candidates = [
         f"{BASE}/jobs/getTask?taskId={task_id}",
         f"{BASE}/jobs/get-task?taskId={task_id}",
@@ -143,7 +96,7 @@ def probe_status_url(headers, task_id: str) -> Optional[str]:
                     return url
         except Exception:
             pass
-    # Beberapa API memakai POST untuk getTask
+    # Beberapa layanan pakai POST getTask
     post_url = f"{BASE}/jobs/getTask"
     try:
         r = requests.post(post_url, headers=headers, json={"taskId": task_id}, timeout=30)
@@ -159,27 +112,24 @@ def probe_status_url(headers, task_id: str) -> Optional[str]:
 def poll_until_done(headers, status_url: str, task_id: str, interval=5, max_wait=60*40):
     waited = 0
     last_status = None
-    used_post_mode = status_url.endswith("(POST)")
-
+    used_post = status_url.endswith("(POST)")
     while waited <= max_wait:
         try:
-            if used_post_mode:
+            if used_post:
                 r = requests.post(status_url.replace(" (POST)", ""), headers=headers, json={"taskId": task_id}, timeout=60)
             else:
                 r = requests.get(status_url, headers=headers, timeout=60)
         except Exception as e:
             yield f"[WARN] Poll error: {e}", None
-            time.sleep(interval)
-            waited += interval
-            continue
+            time.sleep(interval); waited += interval; continue
 
         if r.status_code == 404:
-            yield f"[WARN] Poll 404 di {status_url} — mencari endpoint lain...", None
+            yield f"[WARN] Poll 404 di {status_url} — mencoba endpoint lain...", None
             new_url = probe_status_url(headers, task_id)
             if not new_url:
-                raise gr.Error("Gagal menemukan endpoint status. Mohon cek dokumentasi Kie AI.")
+                raise gr.Error("Tidak menemukan endpoint status. Mohon cek dokumentasi Kie AI.")
             status_url = new_url
-            used_post_mode = status_url.endswith("(POST)")
+            used_post = status_url.endswith("(POST)")
             continue
 
         if r.status_code >= 400:
@@ -188,8 +138,8 @@ def poll_until_done(headers, status_url: str, task_id: str, interval=5, max_wait
             try:
                 data = r.json()
             except Exception:
-                yield "[WARN] Response status bukan JSON yang valid.", None
                 data = {}
+                yield "[WARN] Response status bukan JSON.", None
 
             status, progress, result_url = infer_status_and_result(data)
             if status != last_status:
@@ -197,15 +147,13 @@ def poll_until_done(headers, status_url: str, task_id: str, interval=5, max_wait
                 last_status = status
 
             s = (str(status) or "").lower()
-            if s in {"succeeded", "completed", "success", "done"}:
-                yield "Selesai (server) — mengunduh hasil...", result_url
+            if s in {"succeeded","completed","success","done"}:
+                yield "Selesai di server — mengunduh...", result_url
                 return
-            if s in {"failed", "error", "canceled", "cancelled"}:
+            if s in {"failed","error","canceled","cancelled"}:
                 raise gr.Error(f"Task gagal:\n{json.dumps(data, indent=2)}")
 
-        time.sleep(interval)
-        waited += interval
-
+        time.sleep(interval); waited += interval
     raise gr.Error("Timeout menunggu task selesai.")
 
 def download_result(url: str, task_id: str):
@@ -218,102 +166,58 @@ def download_result(url: str, task_id: str):
             raise gr.Error(f"Gagal download hasil: {r.status_code} {r.text}")
         with open(out, "wb") as f:
             for chunk in r.iter_content(chunk_size=1 << 20):
-                if chunk:
-                    f.write(chunk)
+                if chunk: f.write(chunk)
     return str(out)
 
-# ========== Gradio flows ==========
-def run_job(user_api_key, prompt, aspect_ratio, duration, callback_url):
+def run_job(user_api_key, prompt, aspect_ratio, duration):
     headers = make_headers(user_api_key)
+    task_id, status_url, preview = create_task(headers, prompt, aspect_ratio, duration)
+    yield f"Task dibuat: {task_id}\nStatus URL (server): {status_url or '-'}\nCreate resp: {preview}", None
 
-    # 1) Buat task
-    task_id, status_url, raw_preview = create_task(headers, prompt, aspect_ratio, duration, callback_url)
-    yield f"Task dibuat: {task_id}\nStatus URL (server): {status_url or '-'}\nCreate resp: {raw_preview}", None
-
-    # 2) Jika callback URL diisi, kita tunggu callback sambil tetap coba polling kalau status_url tersedia.
-    result_link = None
-
-    if status_url:
-        for status_msg, maybe_url in poll_until_done(headers, status_url, task_id):
-            yield status_msg, None
-            if maybe_url:
-                result_link = maybe_url
-
-    if not result_link and callback_url:
-        # Tunggu callback hingga video_url diterima
-        yield "Menunggu callback dari Kie AI di endpoint /api/callback ...", None
-        for _ in range(60 * 10 // 3):  # ~10 menit
-            if LAST_VIDEO_URL:
-                result_link = LAST_VIDEO_URL
-                break
-            time.sleep(3)
-        if not result_link:
-            raise gr.Error("Belum menerima callback berisi video_url. Periksa bahwa callback URL publik benar.")
-
-    if not result_link:
-        # Tidak ada callback dan tidak ada status_url yang bisa dipakai
-        # Coba auto-probe
+    if not status_url:
         found = probe_status_url(headers, task_id)
         if not found:
-            raise gr.Error("Tidak ada result_url. Endpoint status tidak diketahui. Coba isi Callback URL atau kirim response createTask lengkap.")
-        for status_msg, maybe_url in poll_until_done(headers, found, task_id):
-            yield status_msg, None
-            if maybe_url:
-                result_link = maybe_url
+            raise gr.Error("Tidak bisa menentukan endpoint status. Kirim response createTask penuh agar saya mappingkan field yang benar.")
+        status_url = found
+
+    result_link = None
+    for status_msg, maybe_url in poll_until_done(headers, status_url, task_id):
+        yield status_msg, None
+        if maybe_url:
+            result_link = maybe_url
 
-    # 3) Unduh & tampilkan
     path = download_result(result_link, task_id)
     yield f"Selesai ✅ (task {task_id})", path
 
-def show_callback():
-    preview = json.dumps(LAST_CALLBACK_JSON, indent=2) if LAST_CALLBACK_JSON else "(belum ada)"
-    hint = LAST_VIDEO_URL or "(belum ada video_url)"
-    return f"Last callback JSON:\n{preview}\n\nExtracted video_url: {hint}"
-
 def runtime_info(user_api_key):
     key = (user_api_key or os.getenv("KIE_API_KEY") or "").strip()
     src = "BYOK (user input)" if user_api_key else ("ENV KIE_API_KEY" if os.getenv("KIE_API_KEY") else "NONE")
     masked = (key[:4] + "..." + key[-4:]) if key else "(none)"
-    return f"Key source: {src}\nKey hint: {masked}\nBase: {BASE}\nCallback endpoint on this Space: /api/callback"
+    return f"Key source: {src}\nKey hint: {masked}\nBase: {BASE}"
 
-# Gradio UI
-with gr.Blocks(title="Kie AI — Sora‑2 Text‑to‑Video (HF Space)") as demo:
-    gr.Markdown("## Kie AI — Sora‑2 Text‑to‑Video\n- Gunakan API key Kie AI (bukan OpenAI).\n- Jika pakai callback, set ke URL publik Space ini: https://<subdomain>.hf.space/api/callback\n- remove_watermark diset False (patuh ToS).")
+# ============ Gradio UI (Pure Gradio) ============
+with gr.Blocks(title="Kie AI — Sora‑2 Text‑to‑Video (Polling)") as demo:
+    gr.Markdown("## Kie AI — Sora‑2 Text‑to‑Video\n- Gunakan API key Kie AI (bukan OpenAI).\n- remove_watermark dimatikan (False).")
     api = gr.Textbox(label="KIE API Key (opsional, BYOK)", type="password", placeholder="kie-...")
+    prompt = gr.Textbox(
+        label="Prompt",
+        lines=7,
+        value=(
+            "Photorealistic handheld POV at night in a foggy tropical forest; "
+            "a large animal silhouette crosses the path, eyes reflecting light; "
+            "volumetric fog, wet leaves; vertical 9:16; no blood, no gore, no text, no watermark."
+        ),
+    )
     with gr.Row():
-        prompt = gr.Textbox(
-            label="Prompt",
-            lines=7,
-            value=(
-                "Photorealistic handheld POV at night in a foggy tropical forest; "
-                "a large animal silhouette crosses the path, eyes reflecting light; "
-                "volumetric fog, wet leaves; vertical 9:16; no blood, no gore, no text, no watermark."
-            ),
-        )
-        callback_url = gr.Textbox(
-            label="Callback URL (opsional)",
-            placeholder="https://<your-space>.hf.space/api/callback atau https://webhook.site/xxx",
-            value="",
-        )
-    with gr.Row():
-        aspect = gr.Dropdown(
-            choices=["portrait", "landscape", "square", "9:16", "16:9"],
-            value="portrait",
-            label="Aspect ratio"
-        )
+        aspect = gr.Dropdown(["portrait", "landscape", "square", "9:16", "16:9"], value="portrait", label="Aspect ratio")
         duration = gr.Textbox(value="", label="Duration (detik, opsional)", placeholder="mis. 12 (kosongkan jika ragu)")
     run = gr.Button("Generate")
     status = gr.Textbox(label="Status", lines=6)
     video = gr.Video(label="Hasil video")
-    with gr.Row():
-        check = gr.Button("Check runtime")
-        info = gr.Textbox(label="Runtime info")
-        see_cb = gr.Button("Show last callback")
-        cb = gr.Textbox(label="Callback payload (preview)", lines=10)
+    check = gr.Button("Check runtime")
+    info = gr.Textbox(label="Runtime info")
 
-    run.click(run_job, inputs=[api, prompt, aspect, duration, callback_url], outputs=[status, video])
+    run.click(run_job, inputs=[api, prompt, aspect, duration], outputs=[status, video])
     check.click(runtime_info, inputs=[api], outputs=[info])
-    see_cb.click(lambda: (show_callback()), outputs=[cb])
 
-# Mount Gradio di FastAPI agar /api/callback bisa diakses dari luar
-app = gr.mount_gradio_app(fastapi_app, demo, path="/")
+# Penting untuk Spaces: expose variable 'demo'