Update app.py

app.py

@@ -4,25 +4,24 @@ import fitz  # PyMuPDF
 import json
 import os
 import urllib.parse
+import base64 # Diperlukan untuk client-side API call
 
-# --- KONFIGURASI API KEY ---
+# --- KONFIGURASI API KEY (TETAP SAMA) ---
 API_CONFIGURED = False
 try:
-    api_key = os.environ.get('GEMINI_API_KEY')
+    api_key = os.environ.get('GEMINI_API_KEY') 
     if api_key:
         genai.configure(api_key=api_key)
-        # Model paling murah & tersedia di Free Tier
-        model = genai.GenerativeModel('models/gemini-2.5-flash')
+        model = genai.GenerativeModel('gemini-2.5-flash-lite')
         API_CONFIGURED = True
-        print("✅ Konfigurasi API dan model (gemini-2.5-flash) berhasil.")
+        print("✅ Konfigurasi API dan model berhasil.")
     else:
         print("🛑 Secret 'GEMINI_API_KEY' tidak ditemukan.")
 except Exception as e:
     print(f"🛑 Terjadi error saat inisialisasi: {e}")
 
-# --- KONSTANTA TOKEN ---
-MAX_OUTPUT_TOKENS = 90000   # Batas token output (hemat kuota)
-MAX_INPUT_CHARS   = 12000  # Batas karakter teks CV agar tidak meledak input token
+# --- KONSTANTA BATAS TOKEN OUTPUT ---
+MAX_OUTPUT_TOKENS = 8192
 
 # --- FUNGSI-FUNGSI UTAMA ---
 
@@ -37,45 +36,19 @@ def ekstrak_teks_dari_pdf(path_file_pdf):
 def generate_search_links(keywords):
     if not keywords:
         return {}
-    keywords_encoded    = urllib.parse.quote_plus(keywords)
+    keywords_encoded = urllib.parse.quote_plus(keywords)
     keywords_hyphenated = keywords.lower().replace(" ", "-").replace("(", "").replace(")", "")
-    return {
-        "LinkedIn"   : f"https://www.linkedin.com/jobs/search/?keywords={keywords_encoded}&location=Indonesia",
-        "JobStreet"  : f"https://www.jobstreet.co.id/id/job-search/{keywords_hyphenated}-jobs/",
-        "Glints"     : f"https://glints.com/id/opportunities/jobs/explore?keyword={keywords_encoded}",
-        "Indeed"     : f"https://id.indeed.com/jobs?q={keywords_encoded}",
+    links = {
+        "LinkedIn": f"https://www.linkedin.com/jobs/search/?keywords={keywords_encoded}&location=Indonesia",
+        "JobStreet": f"https://www.jobstreet.co.id/id/job-search/{keywords_hyphenated}-jobs/",
+        "Glints": f"https://glints.com/id/opportunities/jobs/explore?keyword={keywords_encoded}",
+        "Indeed": f"https://id.indeed.com/jobs?q={keywords_encoded}",
         "Google Jobs": f"https://www.google.com/search?q={keywords_encoded}+jobs+in+Indonesia&ibp=htl;jobs"
     }
-
-def format_token_info(usage_metadata) -> str:
-    """Mengubah usage_metadata Gemini menjadi tabel markdown yang rapi."""
-    if usage_metadata is None:
-        return "ℹ️ Data penggunaan token tidak tersedia."
-
-    prompt_tokens    = getattr(usage_metadata, 'prompt_token_count',     'N/A')
-    candidate_tokens = getattr(usage_metadata, 'candidates_token_count', 'N/A')
-    total_tokens     = getattr(usage_metadata, 'total_token_count',      'N/A')
-
-    def fmt(val):
-        return f"{val:,}" if isinstance(val, int) else str(val)
-
-    lines = [
-        "---",
-        "### 📊 Penggunaan Token — gemini-2.0-flash",
-        "| Kategori | Jumlah |",
-        "|---|---|",
-        f"| 🔼 Input (prompt) | {fmt(prompt_tokens)} token |",
-        f"| 🔽 Output (response) | {fmt(candidate_tokens)} token |",
-        f"| **Total** | **{fmt(total_tokens)} token** |",
-        f"| ⚙️ Limit output dikonfigurasi | {MAX_OUTPUT_TOKENS:,} token |",
-    ]
-    return "\n".join(lines)
+    return links
 
 def parse_json_safe(text: str) -> dict:
-    """Parse JSON dari respons Gemini secara robust — tangani markdown fences & teks ekstra."""
     clean = text.strip()
-
-    # Hapus markdown code fences: ```json...``` atau ```...```
     if clean.startswith("```"):
         parts = clean.split("```")
         for part in parts:
@@ -83,17 +56,29 @@ def parse_json_safe(text: str) -> dict:
             if candidate.startswith("{"):
                 clean = candidate
                 break
-
-    # Ambil substring dari { pertama sampai } terakhir
     start = clean.find("{")
     end   = clean.rfind("}")
     if start != -1 and end != -1 and end > start:
         clean = clean[start:end + 1]
-
     return json.loads(clean)
 
+def log_token_usage(usage_metadata):
+    """Log penggunaan token dari usage_metadata ke console."""
+    if usage_metadata is None:
+        print("⚠️  Token usage: data tidak tersedia.")
+        return
+    prompt_tokens    = getattr(usage_metadata, 'prompt_token_count',     'N/A')
+    candidate_tokens = getattr(usage_metadata, 'candidates_token_count', 'N/A')
+    total_tokens     = getattr(usage_metadata, 'total_token_count',      'N/A')
+    print("=" * 40)
+    print("📊 TOKEN USAGE")
+    print(f"   🔼 Input  (prompt)  : {prompt_tokens}")
+    print(f"   🔽 Output (response): {candidate_tokens}  [limit: {MAX_OUTPUT_TOKENS}]")
+    print(f"   ➕ Total            : {total_tokens}")
+    print("=" * 40)
+
 def analyze_career_path(cv_file):
-    """Pipeline utama: Analisis CV → Laporan JSON → Link → Gabung + Info Token."""
+    """Fungsi utama pipeline: Analisis CV -> Buat Laporan JSON -> Buat Link -> Gabungkan."""
     if not API_CONFIGURED:
         raise gr.Error("API Key Gemini belum terkonfigurasi. Periksa Logs aplikasi.")
     if cv_file is None:
@@ -101,109 +86,71 @@ def analyze_career_path(cv_file):
 
     try:
         print("--- Memulai Proses Analisis Karir ---")
-
-        # 1. Ekstrak teks PDF
+        
         teks_cv = ekstrak_teks_dari_pdf(cv_file.name)
-        if not teks_cv or not teks_cv.strip():
-            raise gr.Error("PDF kosong atau tidak dapat dibaca (kemungkinan file scan/gambar).")
-
-        # Potong teks CV agar tidak melebihi batas input
-        if len(teks_cv) > MAX_INPUT_CHARS:
-            teks_cv = teks_cv[:MAX_INPUT_CHARS]
-            print(f"⚠️ Teks CV dipotong hingga {MAX_INPUT_CHARS} karakter.")
-        print(f"✅ Teks berhasil diekstrak ({len(teks_cv)} karakter).")
-
-        # 2. Kirim ke Gemini
-        print("2. Mengirim permintaan ke gemini-2.0-flash...")
-        prompt = f"""
-Anda adalah "Career Analyst AI". Baca CV berikut dan hasilkan laporan karir ringkas dalam format JSON.
-
-Teks CV:
----
-{teks_cv}
----
-
-Hasilkan JSON dengan PERSIS struktur berikut, jawab singkat dan padat:
-{{
-  "jabatan_ideal": "<string>",
-  "alasan_kecocokan": ["<poin 1>", "<poin 2>", "<poin 3>"],
-  "deskripsi_pekerjaan": ["<poin 1>", "<poin 2>", "<poin 3>", "<poin 4>"],
-  "potensi_karir": ["<jalur 1>", "<jalur 2>", "<jalur 3>"],
-  "kisaran_gaji": {{
-    "junior": "<estimasi IDR/bulan>",
-    "mid_level": "<estimasi IDR/bulan>",
-    "senior": "<estimasi IDR/bulan>"
-  }},
-  "kelebihan_tambahan": ["<saran 1>", "<saran 2>"]
-}}
-
-PENTING: Output HANYA JSON di atas. Tidak ada teks, penjelasan, atau markdown di luar JSON.
-"""
-
+        if not teks_cv:
+            raise gr.Error("PDF kosong atau tidak dapat dibaca.")
+        print("✅ Teks berhasil diekstrak.")
+
+        print("2. Mengirim permintaan analisis karir ke Gemini...")
+        prompt_analisis_karir = f"""
+        Anda adalah seorang "Career Analyst AI". Baca teks CV dan buat laporan peluang karir dalam format JSON.
+        Teks CV: --- {teks_cv} ---
+        Struktur JSON yang diinginkan:
+        - "jabatan_ideal": Jabatan paling ideal untuk kandidat.
+        - "alasan_kecocokan": Array (list) berisi 3-4 poin MENGAPA kandidat cocok.
+        - "deskripsi_pekerjaan": Array (list) berisi 5 poin deskripsi pekerjaan umum.
+        - "potensi_karir": Array (list) berisi 3-4 jalur pengembangan karir.
+        - "kisaran_gaji": Objek JSON berisi estimasi gaji untuk level "junior", "mid_level", dan "senior".
+        - "kelebihan_tambahan": Array (list) berisi 1-2 poin saran atau kelebihan unik kandidat.
+        Pastikan output hanya berupa JSON saja.
+        """
+        
+        # ✅ Tambahan: max_output_tokens untuk membatasi token output
         generation_config = genai.types.GenerationConfig(
             response_mime_type="application/json",
             max_output_tokens=MAX_OUTPUT_TOKENS,
-            temperature=0.3,
         )
-
-        response = model.generate_content(prompt, generation_config=generation_config)
-
-        # 3. Parse JSON secara robust
-        raw_text = response.text
-        print(f"📝 Raw response preview: {raw_text[:150]!r}")
-
-        try:
-            response_json = parse_json_safe(raw_text)
-        except json.JSONDecodeError as je:
-            print(f"🛑 JSON parse gagal: {je}")
-            print(f"🛑 Raw text lengkap:\n{raw_text}")
-            raise gr.Error(
-                f"Respons Gemini bukan JSON valid. "
-                f"Pastikan CV berisi teks yang bisa dibaca (bukan scan/gambar). "
-                f"Detail: {je}"
-            )
-
-        print("✅ Laporan karir berhasil di-parse.")
-
-        # 4. Tambahkan link pencarian
-        keywords = response_json.get("jabatan_ideal", "")
-        response_json["tautan_pencarian"] = generate_search_links(keywords)
-        print("✅ Tautan pencarian ditambahkan.")
-
-        # 5. Info token
-        token_info = format_token_info(getattr(response, 'usage_metadata', None))
-        print(f"📊 Usage metadata: {getattr(response, 'usage_metadata', 'N/A')}")
+        response = model.generate_content(prompt_analisis_karir, generation_config=generation_config)
+
+        # ✅ Tambahan: log penggunaan token ke console
+        log_token_usage(getattr(response, 'usage_metadata', None))
+        
+        print(f"📝 Raw response preview: {response.text[:120]!r}")
+        response_json = parse_json_safe(response.text)
+        print("✅ Laporan karir komprehensif berhasil diterima.")
+
+        print("3. Membuat tautan pencarian dari hasil analisis...")
+        keywords_from_analysis = response_json.get("jabatan_ideal", "")
+        search_links = generate_search_links(keywords_from_analysis)
+        
+        response_json["tautan_pencarian"] = search_links
+        print("✅ Tautan pencarian ditambahkan ke JSON.")
 
         print("--- Proses Selesai ---")
-        return response_json, token_info
+        return response_json
 
-    except gr.Error:
-        raise  # teruskan gr.Error apa adanya tanpa dibungkus lagi
     except Exception as e:
-        print(f"🛑 ERROR TIDAK TERDUGA: {e}")
-        raise gr.Error(f"Terjadi kesalahan tidak terduga: {e}")
+        print(f"🛑 ERROR DALAM FUNGSI ANALISIS: {e}")
+        raise gr.Error(f"Terjadi kesalahan: {e}")
 
-# --- INTERFACE GRADIO ---
+# --- MEMBUAT INTERFACE GRADIO ---
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# 🚀 Analis Peluang Karir Personal")
-    gr.Markdown(
-        "Powered by **Gemini 2.0 Flash** — model tercepat & termurah di Free Tier.  \n"
-        f"⚙️ Batas output: **{MAX_OUTPUT_TOKENS} token** per analisis."
-    )
-
+    gr.Markdown("# 🚀 API Analis Peluang Karir Personal")
+    gr.Markdown("Antarmuka ini dapat digunakan untuk pengujian. Endpoint API publik tersedia di `/run/predict` untuk integrasi ke website Anda.")
+    
     with gr.Row():
         with gr.Column(scale=1):
-            cv_pdf         = gr.File(label="📄 Upload CV (PDF)", file_types=[".pdf"])
+            cv_pdf = gr.File(label="Upload CV (PDF) untuk Uji Coba", file_types=[".pdf"])
             analyze_button = gr.Button("🔍 Analisis Karir Saya", variant="primary")
-
+        
         with gr.Column(scale=2):
-            output_analysis = gr.JSON(label="📋 Hasil Analisis (JSON)")
-            token_display   = gr.Markdown(label="📊 Info Token", value="*Belum ada analisis.*")
-
+            output_analysis = gr.JSON(label="Output JSON dari API")
+            
     analyze_button.click(
         fn=analyze_career_path,
         inputs=[cv_pdf],
-        outputs=[output_analysis, token_display],
+        outputs=[output_analysis],
         show_progress='full'
     )