Upload server.py

server.py

@@ -55,8 +55,8 @@ else:
 
 GEMINI_API_KEY = os.environ.get('GEMINI_API_KEY', "AIzaSyAhVnCOblQvDvq9VIG6A4ztOdGh_yqarfk")
 GEMINI_BASE_URL = os.environ.get('GEMINI_BASE_URL', "https://generativelanguage.googleapis.com/v1beta")
-GEMINI_MODEL = os.environ.get('GEMINI_MODEL', "gemini-2.5-flash")
-GEMINI_ANALYSIS_MODEL = os.environ.get('GEMINI_ANALYSIS_MODEL', "gemini-3-flash-preview")
+GEMINI_MODEL = os.environ.get('GEMINI_MODEL', "gemini-1.5-flash")
+GEMINI_ANALYSIS_MODEL = os.environ.get('GEMINI_ANALYSIS_MODEL', "gemini-1.5-pro")
 
 GROQ_API_KEY = os.environ.get('GROQ_API_KEY', "")
 GROQ_MODEL = os.environ.get('GROQ_MODEL', "llama-3.3-70b-versatile")
@@ -604,35 +604,26 @@ async def _analyze_pdf_legacy(file_path: str, user: User) -> dict:
 
 
 async def analyze_pdf(file_path: str, user: User) -> dict:
-    """Analyze PDF using adaptive chunked strategy for large documents."""
-    # Kasih jeda awal (permintaan user)
+    """Analyze PDF using single-pass strategy for high quality with Gemini 2.5."""
+    # Kasih jeda awal sesuai permintaan user
     await asyncio.sleep(2)
     
     reader = PdfReader(file_path)
     total_pages = len(reader.pages)
     
-    # Small documents: use legacy single-pass for quality
-    # Menaikkan threshold ke 5 halaman karena Gemini Pro/Flash sanggup
-    if total_pages <= 5:
+    # Gemini 2.5 memiliki context window 1jt+ token.
+    # Kita gunakan single-pass untuk dokumen sampai 200 halaman agar kualitas Anand Kumar maksimal.
+    if total_pages <= 200:
         return await _analyze_pdf_legacy(file_path, user)
     
-    # Perbesar chunk_size agar jumlah request lebih sedikit (hindari 429)
-    if total_pages <= 20:
-        chunk_size = 7
-    elif total_pages <= 50:
-        chunk_size = 12
-    else:
-        chunk_size = 15
-        
-    overlap = 2 # Overlap sedikit saja untuk menjaga konteks tanpa memboroskan request
+    # Chunking hanya untuk file ekstrim (> 200 halaman)
+    chunk_size = 50
+    overlap = 5
     step = chunk_size - overlap
     
-    # Calculate exact number of batches needed
+    # Calculate exact number of batches
     remaining = total_pages - chunk_size
-    if remaining <= 0:
-        total_batches = 1
-    else:
-        total_batches = (remaining + step - 1) // step + 1
+    total_batches = (remaining + step - 1) // step + 1 if remaining > 0 else 1
     
     all_concepts = []
     all_diagrams = []
@@ -640,10 +631,8 @@ async def analyze_pdf(file_path: str, user: User) -> dict:
     summaries = []
     
     for batch_idx in range(total_batches):
-        # Berikan jeda lebih lama jika file besar agar tidak menabrak Rate Limit Google
         if batch_idx > 0:
-            delay = 4 if total_pages > 30 else 1
-            await asyncio.sleep(delay)
+            await asyncio.sleep(5) # Jeda lebih lama untuk file raksasa
             
         start = 1 + batch_idx * step
         end = min(start + chunk_size - 1, total_pages)
@@ -657,16 +646,11 @@ async def analyze_pdf(file_path: str, user: User) -> dict:
         all_concepts.extend(batch.get("key_concepts", []))
         all_diagrams.extend(batch.get("diagrams", []))
         all_objectives.extend(batch.get("learning_objectives", []))
-        all_objectives.extend(batch.get("learning_objectives", []))
     
-    # Deduplicate and merge
-    unique_concepts = _deduplicate_concepts(all_concepts)
-    unique_concepts = unique_concepts[:20]
+    # Final merge logic
+    unique_concepts = _deduplicate_concepts(all_concepts)[:25]
+    merged_diagrams = _merge_diagrams(all_diagrams)[:12]
     
-    merged_diagrams = _merge_diagrams(all_diagrams)
-    merged_diagrams = merged_diagrams[:10]
-    
-    # Deduplicate objectives
     seen_obj = set()
     unique_objectives = []
     for obj in all_objectives:
@@ -674,56 +658,13 @@ async def analyze_pdf(file_path: str, user: User) -> dict:
         if norm and norm not in seen_obj:
             seen_obj.add(norm)
             unique_objectives.append(obj)
-    unique_objectives = unique_objectives[:10]
-    
-    # Synthesize final summary
-    final_summary = await _synthesize_summary_from_chunks(summaries, user)
-    
-    # Fallback: if very few concepts from chunked analysis on large doc, try legacy and merge
-    title = ""
-    if len(unique_concepts) < 5 and total_pages > 10:
-        try:
-            legacy = await _analyze_pdf_legacy(file_path, user)
-            # Merge: keep existing concepts, add any new from legacy up to cap
-            legacy_concepts = legacy.get("key_concepts", [])
-            for lc in legacy_concepts:
-                if len(unique_concepts) >= 20:
-                    break
-                norm = _normalize_concept_name(lc.get("concept", ""))
-                if norm and norm not in {_normalize_concept_name(c.get("concept", "")) for c in unique_concepts}:
-                    unique_concepts.append(lc)
-            # Merge diagrams similarly
-            legacy_diagrams = legacy.get("diagrams", [])
-            for ld in legacy_diagrams:
-                if len(merged_diagrams) >= 10:
-                    break
-                key = (_normalize_concept_name(ld.get("name", "")), ld.get("type", ""))
-                if key not in {(_normalize_concept_name(d.get("name", "")), d.get("type", "")) for d in merged_diagrams}:
-                    merged_diagrams.append(ld)
-            # Merge objectives
-            for lo in legacy.get("learning_objectives", []):
-                if len(unique_objectives) >= 10:
-                    break
-                norm = _normalize_concept_name(lo)
-                if norm and norm not in seen_obj:
-                    seen_obj.add(norm)
-                    unique_objectives.append(lo)
-            # Use legacy title if missing short summary
-            if not title and legacy.get("title"):
-                title = legacy.get("title")
-        except Exception as e:
-            logger.warning(f"Legacy fallback failed: {e}")
-    
-    # Estimate title from first batch if still empty
-    if not title:
-        title = f"Dokumen ({total_pages} halaman)"
-    
+            
     return {
-        "title": title,
-        "summary": final_summary,
+        "title": f"Analisis Dokumen ({total_pages} hal)",
+        "summary": await _synthesize_summary_from_chunks(summaries, user),
         "key_concepts": unique_concepts,
         "diagrams": merged_diagrams,
-        "learning_objectives": unique_objectives
+        "learning_objectives": unique_objectives[:12]
     }
 
 
@@ -3121,6 +3062,84 @@ async def _sync_local_audios_to_mongodb():
         for file_path_str in wav_files:
             file_path = Path(file_path_str)
             filename = file_path.name
+
+            if file_path.stat().st_size > 15 * 1024 * 1024:
+                logger.warning(f"File audio {filename} terlalu besar untuk MongoDB (>15MB), dilewati.")
+                continue
+
+            existing = await db.audio_files.find_one({"filename": filename}, {"_id": 1})
+            if not existing:
+                logger.info(f"Mengunggah file audio baru ke MongoDB: {filename}")
+                with open(file_path_str, "rb") as f:
+                    data = f.read()
+                await db.audio_files.update_one(
+                    {"filename": filename},
+                    {"$set": {
+                        "filename": filename,
+                        "data": Binary(data),
+                        "created_at": datetime.now(timezone.utc).isoformat()
+                    }},
+                    upsert=True
+                )
+        logger.info("Sinkronisasi audio selesai.")
+    except Exception as e:
+        logger.warning(f"Gagal melakukan sinkronisasi audio ke MongoDB: {e}")
+
+
+@fastapi_app.on_event("startup")
+async def startup():
+    await _ensure_pdfs_bucket()
+    await _sync_local_audios_to_mongodb()
+
+
+@fastapi_app.on_event("shutdown")
+async def shutdown_db_client():
+    client.close()
+
+
+# ============== Supabase Storage helpers ==============
+SUPABASE_STORAGE_URL = f"{SUPABASE_URL}/storage/v1" if SUPABASE_URL else ""
+
+
+async def _ensure_pdfs_bucket():
+    if not SUPABASE_STORAGE_URL or not SUPABASE_URL:
+        return
+    try:
+        async with httpx.AsyncClient() as hc:
+            await hc.post(
+                f"{SUPABASE_STORAGE_URL}/bucket",
+                headers={
+                    "Authorization": f"Bearer {SUPABASE_ANON_KEY}",
+                    "Content-Type": "application/json",
+                },
+                json={"id": "pdfs", "name": "pdfs", "public": True},
+            )
+    except Exception:
+        passi_app.include_router(api_router)
+fastapi_app.add_middleware(
+    CORSMiddleware,
+    allow_credentials=True,
+    allow_origins=os.environ.get('CORS_ORIGINS', '*').split(','),
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+async def _sync_local_audios_to_mongodb():
+    logger.info("Memulai sinkronisasi file audio lokal ke MongoDB...")
+    try:
+        if not AUDIO_DIR.exists():
+            return
+        import glob
+        wav_files = glob.glob(str(AUDIO_DIR / "*.wav"))
+        for file_path_str in wav_files:
+            file_path = Path(file_path_str)
+            filename = file_path.name
+
+            if file_path.stat().st_size > 15 * 1024 * 1024:
+                logger.warning(f"File audio {filename} terlalu besar untuk MongoDB (>15MB), dilewati.")
+                continue
+
             existing = await db.audio_files.find_one({"filename": filename}, {"_id": 1})
             if not existing:
                 logger.info(f"Mengunggah file audio baru ke MongoDB: {filename}")
@@ -3148,4 +3167,25 @@ async def startup():
 
 @fastapi_app.on_event("shutdown")
 async def shutdown_db_client():
-    client.close()
+    client.close()
+
+
+# ============== Supabase Storage helpers ==============
+SUPABASE_STORAGE_URL = f"{SUPABASE_URL}/storage/v1" if SUPABASE_URL else ""
+
+
+async def _ensure_pdfs_bucket():
+    if not SUPABASE_STORAGE_URL or not SUPABASE_URL:
+        return
+    try:
+        async with httpx.AsyncClient() as hc:
+            await hc.post(
+                f"{SUPABASE_STORAGE_URL}/bucket",
+                headers={
+                    "Authorization": f"Bearer {SUPABASE_ANON_KEY}",
+                    "Content-Type": "application/json",
+                },
+                json={"id": "pdfs", "name": "pdfs", "public": True},
+            )
+    except Exception:
+        pass