Upload app.py

app.py

@@ -8,7 +8,10 @@ Features:
 - Fuzzy label matching
 - Memory-efficient model loading
 - ONNX CPU optimization
-- Request caching for performance
+- NO RESPONSE CACHING for fresh/accurate predictions
+- Model caching only (for performance)
+
+🔄 IMPORTANT: Response caching DISABLED untuk memastikan prediksi selalu fresh dan akurat
 """
 
 import os
@@ -146,10 +149,10 @@ MODEL_ROUTING = [
     (['spiral', 'galaxy'], 'spiral_galaxy')
 ]
 
-# Global cache untuk models dan responses
+# Global cache untuk models saja (response cache DISABLED untuk prediksi fresh)
 LOADED_MODELS: Dict[str, Dict[str, Any]] = {}
-RESPONSE_CACHE: Dict[str, Dict[str, Any]] = {}
-CACHE_MAX_SIZE = 100
+# RESPONSE_CACHE: Dict[str, Dict[str, Any]] = {}  # ❌ DISABLED - No response caching
+# CACHE_MAX_SIZE = 100  # ❌ DISABLED
 
 class ModelManager:
     """Manager untuk loading dan caching models"""
@@ -348,35 +351,39 @@ def get_button_index(x_center: float, y_center: float, img_width: int, img_heigh
     return button_index
 
 # =================================================================
-# CACHING SYSTEM
+# CACHING SYSTEM - DISABLED FOR FRESH PREDICTIONS
 # =================================================================
 
-def get_cache_key(request_data: dict) -> str:
-    """Generate cache key dari request data"""
-    cache_string = f"{request_data.get('challenge_type')}_{request_data.get('target_label')}_{request_data.get('image_b64', '')[:100]}"
-    return hashlib.md5(cache_string.encode()).hexdigest()
-
-def get_cached_response(cache_key: str) -> Optional[dict]:
-    """Get response dari cache jika ada"""
-    return RESPONSE_CACHE.get(cache_key)
-
-def cache_response(cache_key: str, response: dict):
-    """Cache response dengan size limit"""
-    if len(RESPONSE_CACHE) >= CACHE_MAX_SIZE:
-        # Remove oldest entry
-        oldest_key = next(iter(RESPONSE_CACHE))
-        del RESPONSE_CACHE[oldest_key]
-    
-    RESPONSE_CACHE[cache_key] = response
+# ❌ CACHE FUNCTIONS DISABLED - No response caching for fresh predictions
+# def get_cache_key(request_data: dict) -> str:
+#     """Generate cache key dari request data"""
+#     cache_string = f"{request_data.get('challenge_type')}_{request_data.get('target_label')}_{request_data.get('image_b64', '')[:100]}"
+#     return hashlib.md5(cache_string.encode()).hexdigest()
+
+# def get_cached_response(cache_key: str) -> Optional[dict]:
+#     """Get response dari cache jika ada"""
+#     return RESPONSE_CACHE.get(cache_key)
+
+# def cache_response(cache_key: str, response: dict):
+#     """Cache response dengan size limit"""
+#     if len(RESPONSE_CACHE) >= CACHE_MAX_SIZE:
+#         # Remove oldest entry
+#         oldest_key = next(iter(RESPONSE_CACHE))
+#         del RESPONSE_CACHE[oldest_key]
+#     
+#     RESPONSE_CACHE[cache_key] = response
 
 # =================================================================
 # CHALLENGE HANDLERS
 # =================================================================
 
 async def handle_pick_the_challenge(data: dict) -> dict:
-    """Handle 'pick the' challenges dengan fuzzy matching"""
+    """Handle 'pick the' challenges dengan fuzzy matching - ALWAYS FRESH PREDICTIONS"""
     start_time = datetime.now()
     
+    # 🔄 ALWAYS FRESH - No response caching for accurate pick_the predictions
+    logger.info(f"🔄 Processing FRESH pick_the prediction (no response cache)")
+    
     target_label_original = data['target_label']
     image_b64 = data['image_b64']
     target_label = target_label_original
@@ -552,9 +559,12 @@ async def handle_pick_the_challenge(data: dict) -> dict:
     }
 
 async def handle_upright_challenge(data: dict) -> dict:
-    """Handle 'upright' challenges"""
+    """Handle 'upright' challenges - ALWAYS FRESH PREDICTIONS"""
     start_time = datetime.now()
     
+    # 🔄 ALWAYS FRESH - No response caching for accurate upright predictions
+    logger.info(f"🔄 Processing FRESH upright prediction (no response cache)")
+    
     try:
         image_b64 = data['image_b64']
         model_data = await ModelManager.get_model('upright')
@@ -708,7 +718,7 @@ async def root():
             "/docs": "GET - API documentation"
         },
         "models_loaded": len(LOADED_MODELS),
-        "cache_size": len(RESPONSE_CACHE)
+        "response_caching": "disabled"  # ❌ No response caching for fresh predictions
     }
 
 @app.get("/health")
@@ -737,27 +747,27 @@ async def health_check():
         "tensorflow_available": TF_AVAILABLE,
         "models_loaded": len(LOADED_MODELS),
         "available_models": list(CONFIGS.keys()),
-        "cache_entries": len(RESPONSE_CACHE),
+        "response_caching": "disabled",  # ❌ No response caching for fresh predictions
+        "cache_entries": 0,  # Always 0 since response cache disabled
         "warnings": warnings
     }
 
 @app.post("/clear-cache")
 async def clear_cache(authenticated: bool = Depends(verify_api_key)):
-    """🗑️ Clear model and response caches - useful after fixes"""
+    """🗑️ Clear model cache only (response cache disabled for fresh predictions)"""
     try:
         models_cleared = len(LOADED_MODELS)
-        cache_cleared = len(RESPONSE_CACHE)
         
         LOADED_MODELS.clear()
-        RESPONSE_CACHE.clear()
+        # RESPONSE_CACHE.clear()  # ❌ DISABLED - No response caching
         
-        logger.info(f"🗑️ Cache cleared: {models_cleared} models, {cache_cleared} responses")
+        logger.info(f"🗑️ Model cache cleared: {models_cleared} models (response cache disabled)")
         
         return {
             "status": "success",
-            "message": "Cache cleared successfully",
+            "message": "Model cache cleared successfully (response cache disabled for fresh predictions)",
             "models_cleared": models_cleared,
-            "cache_entries_cleared": cache_cleared
+            "response_caching": "disabled"
         }
     except Exception as e:
         logger.error(f"❌ Error clearing cache: {e}")
@@ -769,7 +779,7 @@ async def solve_funcaptcha(
     authenticated: bool = Depends(verify_api_key)
 ) -> FunCaptchaResponse:
     """
-    🧩 Solve FunCaptcha challenges
+    🧩 Solve FunCaptcha challenges - ALWAYS FRESH PREDICTIONS
     
     Supports:
     - pick_the: Pick specific objects dari images  
@@ -777,19 +787,14 @@ async def solve_funcaptcha(
     
     Features:
     - Fuzzy label matching
-    - Response caching
+    - NO response caching (always fresh predictions)
     - Multi-model support
     """
     
-    # Generate cache key
     request_dict = request.dict()
-    cache_key = get_cache_key(request_dict)
     
-    # Check cache first
-    cached_response = get_cached_response(cache_key)
-    if cached_response:
-        logger.info(f"Cache hit for challenge: {request.challenge_type}")
-        return FunCaptchaResponse(**cached_response)
+    # ❌ NO CACHING - Always process fresh for accurate results
+    logger.info(f"🔄 Processing FRESH prediction for challenge: {request.challenge_type} (no cache)")
     
     # Process request
     if request.challenge_type == 'pick_the':
@@ -801,10 +806,8 @@ async def solve_funcaptcha(
     else:
         raise HTTPException(status_code=400, detail=f"Unsupported challenge type: {request.challenge_type}")
     
-    # Cache response
-    cache_response(cache_key, result)
-    
-    logger.info(f"Challenge solved: {request.challenge_type} -> {result['status']}")
+    # ❌ NO CACHING - Direct return for fresh results
+    logger.info(f"✅ Fresh challenge solved: {request.challenge_type} -> {result['status']}")
     
     return FunCaptchaResponse(**result)
 
@@ -849,11 +852,11 @@ async def shutdown_event():
     """Cleanup saat shutdown"""
     logger.info("🛑 Shutting down FunCaptcha Solver API...")
     
-    # Clear caches
+    # Clear model cache only (response cache disabled)
     LOADED_MODELS.clear()
-    RESPONSE_CACHE.clear()
+    # RESPONSE_CACHE.clear()  # ❌ DISABLED - No response caching
     
-    logger.info("✅ Cleanup completed")
+    logger.info("✅ Cleanup completed (response cache disabled)")
 
 # =================================================================
 # DEVELOPMENT SERVER