Upload app.py

app.py

@@ -1,703 +1,763 @@
-"""
-🚀 FunCaptcha Solver API - Hugging Face Spaces Deployment
-Optimized for speed, memory efficiency, and scalability
-
-Features:
-- FastAPI async operations
-- API key authentication via HF secrets
-- Fuzzy label matching
-- Memory-efficient model loading
-- ONNX CPU optimization
-- Request caching for performance
-"""
-
-import os
-import io
-import base64
-import hashlib
-import asyncio
-from datetime import datetime
-from typing import Optional, Dict, Any, List
-import logging
-
-import cv2
-import numpy as np
-from PIL import Image
-import yaml
-import difflib
-
-# Try to import ML backends dengan multiple fallbacks
-ONNX_AVAILABLE = False
-TORCH_AVAILABLE = False
-TF_AVAILABLE = False
-ort = None
-
-# Try ONNX Runtime first
-try:
-    import onnxruntime as ort
-    ONNX_AVAILABLE = True
-    print("✅ ONNX Runtime imported successfully")
-except ImportError as e:
-    print(f"❌ ONNX Runtime import failed: {e}")
-    
-    # Try PyTorch as fallback
-    try:
-        import torch
-        TORCH_AVAILABLE = True
-        print("✅ PyTorch imported as ONNX Runtime alternative")
-    except ImportError:
-        print("❌ PyTorch not available")
-        
-        # Try TensorFlow as final fallback
-        try:
-            import tensorflow as tf
-            TF_AVAILABLE = True
-            print("✅ TensorFlow imported as ONNX Runtime alternative")
-        except ImportError:
-            print("❌ TensorFlow not available")
-            print("⚠️ Running without ML backend - model inference will be disabled")
-
-ML_BACKEND_AVAILABLE = ONNX_AVAILABLE or TORCH_AVAILABLE or TF_AVAILABLE
-
-from fastapi import FastAPI, HTTPException, Depends, status
-from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
-from fastapi.middleware.cors import CORSMiddleware
-from pydantic import BaseModel, Field
-import uvicorn
-
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-# =================================================================
-# CONFIGURATION & MODELS
-# =================================================================
-
-class FunCaptchaRequest(BaseModel):
-    """Request model untuk FunCaptcha solving"""
-    challenge_type: str = Field(..., description="Type of challenge (pick_the, upright)")
-    image_b64: str = Field(..., description="Base64 encoded image")
-    target_label: Optional[str] = Field(None, description="Target label untuk pick_the challenges")
-
-class FunCaptchaResponse(BaseModel):
-    """Response model untuk FunCaptcha solving"""
-    status: str = Field(..., description="Status: success, not_found, error")
-    box: Optional[List[float]] = Field(None, description="Bounding box coordinates [x, y, w, h]")
-    button_index: Optional[int] = Field(None, description="Button index untuk upright challenges")
-    confidence: Optional[float] = Field(None, description="Detection confidence")
-    message: Optional[str] = Field(None, description="Additional message")
-    processing_time: Optional[float] = Field(None, description="Processing time in seconds")
-
-# =================================================================
-# AUTHENTICATION
-# =================================================================
-
-security = HTTPBearer()
-
-def get_api_key_from_secrets() -> str:
-    """Get API key dari Hugging Face Secrets"""
-    api_key = os.getenv("FUNCAPTCHA_API_KEY")
-    if not api_key:
-        logger.error("FUNCAPTCHA_API_KEY not found in environment variables")
-        raise ValueError("API key tidak ditemukan dalam HF Secrets")
-    return api_key
-
-def verify_api_key(credentials: HTTPAuthorizationCredentials = Depends(security)) -> bool:
-    """Verify API key dari request header"""
-    expected_key = get_api_key_from_secrets()
-    if credentials.credentials != expected_key:
-        raise HTTPException(
-            status_code=status.HTTP_401_UNAUTHORIZED,
-            detail="Invalid API key",
-            headers={"WWW-Authenticate": "Bearer"}
-        )
-    return True
-
-# =================================================================
-# MODEL CONFIGURATION & MANAGEMENT
-# =================================================================
-
-CONFIGS = {
-    'default': {
-        'model_path': 'best.onnx',
-        'yaml_path': 'data.yaml',
-        'input_size': 640,
-        'confidence_threshold': 0.4,
-        'nms_threshold': 0.2
-    },
-    'spiral_galaxy': {
-        'model_path': 'bestspiral.onnx',
-        'yaml_path': 'dataspiral.yaml', 
-        'input_size': 416,
-        'confidence_threshold': 0.30,
-        'nms_threshold': 0.45
-    },
-    'upright': {
-        'model_path': 'best_Upright.onnx',
-        'yaml_path': 'data_upright.yaml',
-        'input_size': 640,
-        'confidence_threshold': 0.45,
-        'nms_threshold': 0.45
-    }
-}
-
-MODEL_ROUTING = [
-    (['spiral', 'galaxy'], 'spiral_galaxy')
-]
-
-# Global cache untuk models dan responses
-LOADED_MODELS: Dict[str, Dict[str, Any]] = {}
-RESPONSE_CACHE: Dict[str, Dict[str, Any]] = {}
-CACHE_MAX_SIZE = 100
-
-class ModelManager:
-    """Manager untuk loading dan caching models"""
-    
-    @staticmethod
-    async def get_model(config_key: str) -> Optional[Dict[str, Any]]:
-        """Load model dengan caching untuk efficiency"""
-        # Check if any ML backend is available
-        if not ML_BACKEND_AVAILABLE:
-            logger.error("❌ No ML backend available - cannot load models")
-            return None
-            
-        if config_key not in LOADED_MODELS:
-            logger.info(f"Loading model: {config_key}")
-            
-            try:
-                config = CONFIGS[config_key]
-                
-                # Check if files exist
-                if not os.path.exists(config['model_path']):
-                    logger.warning(f"Model file not found: {config['model_path']}")
-                    return None
-                
-                if not os.path.exists(config['yaml_path']):
-                    logger.warning(f"YAML file not found: {config['yaml_path']}")
-                    return None
-                
-                # Load model dengan available backend
-                session = None
-                
-                if ONNX_AVAILABLE:
-                    # Load ONNX session dengan CPU optimization
-                    providers = ['CPUExecutionProvider']
-                    session_options = ort.SessionOptions()
-                    session_options.intra_op_num_threads = 2  # Optimize untuk CPU
-                    session_options.inter_op_num_threads = 2
-                    session_options.execution_mode = ort.ExecutionMode.ORT_SEQUENTIAL
-                    session_options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
-                    
-                    session = ort.InferenceSession(
-                        config['model_path'],
-                        providers=providers,
-                        sess_options=session_options
-                    )
-                else:
-                    # For now, only ONNX Runtime is supported for model loading
-                    # PyTorch/TensorFlow alternatives would need model conversion
-                    logger.error("❌ ONNX models require ONNX Runtime - other backends not yet implemented")
-                    return None
-                
-                # Load class names
-                with open(config['yaml_path'], 'r', encoding='utf-8') as file:
-                    class_names = yaml.safe_load(file)['names']
-                
-                LOADED_MODELS[config_key] = {
-                    'session': session,
-                    'class_names': class_names,
-                    'input_name': session.get_inputs()[0].name,
-                    'input_size': config['input_size'],
-                    'confidence': config['confidence_threshold'],
-                    'nms': config.get('nms_threshold', 0.45)
-                }
-                
-                logger.info(f"✅ Model loaded successfully: {config_key}")
-                
-            except Exception as e:
-                logger.error(f"❌ Error loading model {config_key}: {e}")
-                return None
-                
-        return LOADED_MODELS[config_key]
-
-# =================================================================
-# IMAGE PROCESSING & UTILITIES
-# =================================================================
-
-def preprocess_image(image_bytes: bytes, input_size: int) -> np.ndarray:
-    """Preprocess image untuk ONNX inference dengan optimasi memory"""
-    image = Image.open(io.BytesIO(image_bytes)).convert('RGB')
-    image_np = np.array(image)
-    h, w, _ = image_np.shape
-    
-    scale = min(input_size / w, input_size / h)
-    new_w, new_h = int(w * scale), int(h * scale)
-    
-    resized_image = cv2.resize(image_np, (new_w, new_h))
-    padded_image = np.full((input_size, input_size, 3), 114, dtype=np.uint8)
-    
-    # Calculate padding
-    y_offset = (input_size - new_h) // 2
-    x_offset = (input_size - new_w) // 2
-    
-    padded_image[y_offset:y_offset + new_h, x_offset:x_offset + new_w, :] = resized_image
-    
-    # Convert untuk ONNX
-    input_tensor = padded_image.astype(np.float32) / 255.0
-    input_tensor = np.transpose(input_tensor, (2, 0, 1))
-    input_tensor = np.expand_dims(input_tensor, axis=0)
-    
-    return input_tensor
-
-def fuzzy_match_label(target_label: str, class_names: List[str], threshold: float = 0.6) -> Optional[str]:
-    """Fuzzy matching untuk label variations"""
-    target_normalized = target_label.lower().strip()
-    
-    # Dictionary untuk common variations
-    label_variants = {
-        'ice cream': ['ice cream', 'icecream', 'ice'],
-        'hotdog': ['hot dog', 'hotdog', 'hot-dog'],  
-        'hot dog': ['hot dog', 'hotdog', 'hot-dog'],
-        'sunglasses': ['sunglasses', 'sun glasses', 'sunglass'],
-        'sun glasses': ['sunglasses', 'sun glasses', 'sunglass']
-    }
-    
-    # 1. Exact match
-    if target_normalized in class_names:
-        return target_normalized
-    
-    # 2. Check known variants
-    for main_label, variants in label_variants.items():
-        if target_normalized in variants and main_label in class_names:
-            return main_label
-    
-    # 3. Fuzzy matching
-    best_matches = difflib.get_close_matches(
-        target_normalized,
-        [name.lower() for name in class_names],
-        n=3,
-        cutoff=threshold
-    )
-    
-    if best_matches:
-        for match in best_matches:
-            for class_name in class_names:
-                if class_name.lower() == match:
-                    return class_name
-    
-    # 4. Partial matching
-    for class_name in class_names:
-        if target_normalized in class_name.lower() or class_name.lower() in target_normalized:
-            return class_name
-    
-    return None
-
-def get_config_key_for_label(target_label: str) -> str:
-    """Determine which model config to use"""
-    for keywords, config_key in MODEL_ROUTING:
-        if any(keyword in target_label for keyword in keywords):
-            return config_key
-    return 'default'
-
-def get_button_index(x_center: float, y_center: float, img_width: int, img_height: int, 
-                    grid_cols: int = 3, grid_rows: int = 2) -> int:
-    """Calculate button index dari coordinates"""
-    col = int(x_center // (img_width / grid_cols))
-    row = int(y_center // (img_height / grid_rows))
-    return row * grid_cols + col + 1
-
-# =================================================================
-# CACHING SYSTEM
-# =================================================================
-
-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"""
-    start_time = datetime.now()
-    
-    target_label_original = data['target_label']
-    image_b64 = data['image_b64']
-    target_label = target_label_original
-    
-    config_key = get_config_key_for_label(target_label)
-    
-    if config_key == 'spiral_galaxy':
-        target_label = 'spiral'
-    
-    model_data = await ModelManager.get_model(config_key)
-    if not model_data:
-        if not ML_BACKEND_AVAILABLE:
-            return {
-                'status': 'error', 
-                'message': 'No ML backend available - model inference disabled',
-                'processing_time': (datetime.now() - start_time).total_seconds()
-            }
-        return {
-            'status': 'error', 
-            'message': f'Model {config_key} tidak ditemukan',
-            'processing_time': (datetime.now() - start_time).total_seconds()
-        }
-    
-    try:
-        # Decode image
-        image_bytes = base64.b64decode(image_b64.split(',')[1])
-        
-        # Fuzzy matching untuk label
-        matched_label = fuzzy_match_label(target_label, model_data['class_names'])
-        if not matched_label:
-            return {
-                'status': 'not_found', 
-                'message': f'Label "{target_label}" tidak ditemukan dalam model',
-                'processing_time': (datetime.now() - start_time).total_seconds()
-            }
-        
-        target_label = matched_label
-        
-        # Preprocessing
-        input_tensor = preprocess_image(image_bytes, model_data['input_size'])
-        
-        # Inference
-        outputs = model_data['session'].run(None, {model_data['input_name']: input_tensor})[0]
-        predictions = np.squeeze(outputs).T
-        
-        # Process detections
-        boxes = []
-        confidences = []
-        class_ids = []
-        
-        for pred in predictions:
-            class_scores = pred[4:]
-            class_id = np.argmax(class_scores)
-            max_confidence = class_scores[class_id]
-            
-            if max_confidence > model_data['confidence']:
-                confidences.append(float(max_confidence))
-                class_ids.append(class_id)
-                box_model = pred[:4]
-                x_center, y_center, width, height = box_model
-                x1 = x_center - width / 2
-                y1 = y_center - height / 2
-                boxes.append([int(x1), int(y1), int(width), int(height)])
-        
-        if not boxes:
-            return {
-                'status': 'not_found',
-                'processing_time': (datetime.now() - start_time).total_seconds()
-            }
-        
-        # Non-Maximum Suppression
-        indices = cv2.dnn.NMSBoxes(
-            np.array(boxes), 
-            np.array(confidences), 
-            model_data['confidence'], 
-            model_data['nms']
-        )
-        
-        if len(indices) == 0:
-            return {
-                'status': 'not_found',
-                'processing_time': (datetime.now() - start_time).total_seconds()
-            }
-        
-        # Find target
-        target_class_id = model_data['class_names'].index(target_label)
-        best_match_box = None
-        highest_score = 0
-        
-        for i in indices.flatten():
-            if class_ids[i] == target_class_id:
-                current_score = confidences[i]
-                if current_score > highest_score:
-                    highest_score = current_score
-                    best_match_box = boxes[i]
-        
-        if best_match_box is not None:
-            # Scale back to original coordinates
-            img = Image.open(io.BytesIO(image_bytes))
-            original_w, original_h = img.size
-            scale = min(model_data['input_size'] / original_w, model_data['input_size'] / original_h)
-            pad_x = (model_data['input_size'] - original_w * scale) / 2
-            pad_y = (model_data['input_size'] - original_h * scale) / 2
-            
-            x_orig = (best_match_box[0] - pad_x) / scale
-            y_orig = (best_match_box[1] - pad_y) / scale
-            w_orig = best_match_box[2] / scale
-            h_orig = best_match_box[3] / scale
-            
-            return {
-                'status': 'success',
-                'box': [x_orig, y_orig, w_orig, h_orig],
-                'confidence': highest_score,
-                'processing_time': (datetime.now() - start_time).total_seconds()
-            }
-        
-    except Exception as e:
-        logger.error(f"Error in handle_pick_the_challenge: {e}")
-        return {
-            'status': 'error', 
-            'message': str(e),
-            'processing_time': (datetime.now() - start_time).total_seconds()
-        }
-    
-    return {
-        'status': 'not_found',
-        'processing_time': (datetime.now() - start_time).total_seconds()
-    }
-
-async def handle_upright_challenge(data: dict) -> dict:
-    """Handle 'upright' challenges"""
-    start_time = datetime.now()
-    
-    try:
-        image_b64 = data['image_b64']
-        model_data = await ModelManager.get_model('upright')
-        
-        if not model_data:
-            if not ML_BACKEND_AVAILABLE:
-                return {
-                    'status': 'error',
-                    'message': 'No ML backend available - model inference disabled',
-                    'processing_time': (datetime.now() - start_time).total_seconds()
-                }
-            return {
-                'status': 'error', 
-                'message': 'Model upright tidak ditemukan',
-                'processing_time': (datetime.now() - start_time).total_seconds()
-            }
-        
-        image_bytes = base64.b64decode(image_b64.split(',')[1])
-        reconstructed_image_pil = Image.open(io.BytesIO(image_bytes))
-        original_w, original_h = reconstructed_image_pil.size
-        
-        input_tensor = preprocess_image(image_bytes, model_data['input_size'])
-        outputs = model_data['session'].run(None, {model_data['input_name']: input_tensor})[0]
-        
-        predictions = np.squeeze(outputs).T
-        confident_preds = predictions[predictions[:, 4] > model_data['confidence']]
-        
-        if len(confident_preds) == 0:
-            return {
-                'status': 'not_found',
-                'message': 'Tidak ada objek terdeteksi',
-                'processing_time': (datetime.now() - start_time).total_seconds()
-            }
-        
-        best_detection = confident_preds[np.argmax(confident_preds[:, 4])]
-        box_model = best_detection[:4]
-        
-        scale = min(model_data['input_size'] / original_w, model_data['input_size'] / original_h)
-        pad_x = (model_data['input_size'] - original_w * scale) / 2
-        pad_y = (model_data['input_size'] - original_h * scale) / 2
-        
-        x_center_orig = (box_model[0] - pad_x) / scale
-        y_center_orig = (box_model[1] - pad_y) / scale
-        
-        button_to_click = get_button_index(x_center_orig, y_center_orig, original_w, original_h)
-        
-        return {
-            'status': 'success',
-            'button_index': button_to_click,
-            'confidence': float(best_detection[4]),
-            'processing_time': (datetime.now() - start_time).total_seconds()
-        }
-        
-    except Exception as e:
-        logger.error(f"Error in handle_upright_challenge: {e}")
-        return {
-            'status': 'error',
-            'message': str(e),
-            'processing_time': (datetime.now() - start_time).total_seconds()
-        }
-
-# =================================================================
-# FASTAPI APPLICATION
-# =================================================================
-
-app = FastAPI(
-    title="🧩 FunCaptcha Solver API",
-    description="High-performance FunCaptcha solver dengan fuzzy matching untuk Hugging Face Spaces",
-    version="1.0.0",
-    docs_url="/docs",
-    redoc_url="/redoc"
-)
-
-# CORS middleware
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-@app.get("/")
-async def root():
-    """Root endpoint dengan info API"""
-    return {
-        "service": "FunCaptcha Solver API",
-        "version": "1.0.0",
-        "status": "running",
-        "endpoints": {
-            "/solve": "POST - Solve FunCaptcha challenges",
-            "/health": "GET - Health check",
-            "/docs": "GET - API documentation"
-        },
-        "models_loaded": len(LOADED_MODELS),
-        "cache_size": len(RESPONSE_CACHE)
-    }
-
-@app.get("/health")
-async def health_check():
-    """Health check endpoint"""
-    warnings = []
-    if not ONNX_AVAILABLE:
-        warnings.append("ONNX Runtime not available")
-    if not ML_BACKEND_AVAILABLE:
-        warnings.append("No ML backend available - model inference disabled")
-    
-    backend_status = "none"
-    if ONNX_AVAILABLE:
-        backend_status = "onnxruntime"
-    elif TORCH_AVAILABLE:
-        backend_status = "pytorch"
-    elif TF_AVAILABLE:
-        backend_status = "tensorflow"
-    
-    return {
-        "status": "healthy" if ML_BACKEND_AVAILABLE else "degraded",
-        "service": "FunCaptcha Solver",
-        "ml_backend": backend_status,
-        "onnx_runtime_available": ONNX_AVAILABLE,
-        "pytorch_available": TORCH_AVAILABLE,
-        "tensorflow_available": TF_AVAILABLE,
-        "models_loaded": len(LOADED_MODELS),
-        "available_models": list(CONFIGS.keys()),
-        "cache_entries": len(RESPONSE_CACHE),
-        "warnings": warnings
-    }
-
-@app.post("/solve", response_model=FunCaptchaResponse)
-async def solve_funcaptcha(
-    request: FunCaptchaRequest,
-    authenticated: bool = Depends(verify_api_key)
-) -> FunCaptchaResponse:
-    """
-    🧩 Solve FunCaptcha challenges
-    
-    Supports:
-    - pick_the: Pick specific objects dari images  
-    - upright: Find correctly oriented objects
-    
-    Features:
-    - Fuzzy label matching
-    - Response caching
-    - 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)
-    
-    # Process request
-    if request.challenge_type == 'pick_the':
-        if not request.target_label:
-            raise HTTPException(status_code=400, detail="target_label required for pick_the challenges")
-        result = await handle_pick_the_challenge(request_dict)
-    elif request.challenge_type == 'upright':
-        result = await handle_upright_challenge(request_dict)
-    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']}")
-    
-    return FunCaptchaResponse(**result)
-
-# =================================================================
-# APPLICATION STARTUP
-# =================================================================
-
-@app.on_event("startup")
-async def startup_event():
-    """Initialize aplikasi saat startup"""
-    logger.info("🚀 Starting FunCaptcha Solver API...")
-    
-    # Verify API key ada
-    try:
-        api_key = get_api_key_from_secrets()
-        logger.info("✅ API key loaded successfully")
-    except ValueError as e:
-        logger.error(f"❌ API key error: {e}")
-        raise e
-    
-    # Preload default model jika ada dan ML backend available
-    if ML_BACKEND_AVAILABLE and os.path.exists('best.onnx') and os.path.exists('data.yaml'):
-        logger.info("Preloading default model...")
-        try:
-            await ModelManager.get_model('default')
-            logger.info("✅ Default model preloaded successfully")
-        except Exception as e:
-            logger.warning(f"⚠️ Failed to preload default model: {e}")
-    elif not ML_BACKEND_AVAILABLE:
-        logger.warning("⚠️ No ML backend available - skipping model preload")
-    else:
-        logger.warning("⚠️ Model files (best.onnx, data.yaml) not found - upload them to enable solving")
-    
-    if ML_BACKEND_AVAILABLE:
-        backend_name = "ONNX Runtime" if ONNX_AVAILABLE else "PyTorch" if TORCH_AVAILABLE else "TensorFlow"
-        logger.info(f"✅ FunCaptcha Solver API started successfully with {backend_name} backend")
-    else:
-        logger.warning("⚠️ FunCaptcha Solver API started with limited functionality (No ML backend available)")
-
-@app.on_event("shutdown")
-async def shutdown_event():
-    """Cleanup saat shutdown"""
-    logger.info("🛑 Shutting down FunCaptcha Solver API...")
-    
-    # Clear caches
-    LOADED_MODELS.clear()
-    RESPONSE_CACHE.clear()
-    
-    logger.info("✅ Cleanup completed")
-
-# =================================================================
-# DEVELOPMENT SERVER
-# =================================================================
-
-if __name__ == "__main__":
-    uvicorn.run(
-        "app:app",
-        host="0.0.0.0",
-        port=7860,
-        reload=False,  # Disabled untuk production
-        workers=1      # Single worker untuk HF Spaces
-    )
+"""
+🚀 FunCaptcha Solver API - Hugging Face Spaces Deployment
+Optimized for speed, memory efficiency, and scalability
+
+Features:
+- FastAPI async operations
+- API key authentication via HF secrets
+- Fuzzy label matching
+- Memory-efficient model loading
+- ONNX CPU optimization
+- Request caching for performance
+"""
+
+import os
+import io
+import base64
+import hashlib
+import asyncio
+from datetime import datetime
+from typing import Optional, Dict, Any, List
+import logging
+
+import cv2
+import numpy as np
+from PIL import Image
+import yaml
+import difflib
+
+# Try to import ML backends dengan multiple fallbacks
+ONNX_AVAILABLE = False
+TORCH_AVAILABLE = False
+TF_AVAILABLE = False
+ort = None
+
+# Try ONNX Runtime first
+try:
+    import onnxruntime as ort
+    ONNX_AVAILABLE = True
+    print("✅ ONNX Runtime imported successfully")
+except ImportError as e:
+    print(f"❌ ONNX Runtime import failed: {e}")
+    
+    # Try PyTorch as fallback
+    try:
+        import torch
+        TORCH_AVAILABLE = True
+        print("✅ PyTorch imported as ONNX Runtime alternative")
+    except ImportError:
+        print("❌ PyTorch not available")
+        
+        # Try TensorFlow as final fallback
+        try:
+            import tensorflow as tf
+            TF_AVAILABLE = True
+            print("✅ TensorFlow imported as ONNX Runtime alternative")
+        except ImportError:
+            print("❌ TensorFlow not available")
+            print("⚠️ Running without ML backend - model inference will be disabled")
+
+ML_BACKEND_AVAILABLE = ONNX_AVAILABLE or TORCH_AVAILABLE or TF_AVAILABLE
+
+from fastapi import FastAPI, HTTPException, Depends, status
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel, Field
+import uvicorn
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# =================================================================
+# CONFIGURATION & MODELS
+# =================================================================
+
+class FunCaptchaRequest(BaseModel):
+    """Request model untuk FunCaptcha solving"""
+    challenge_type: str = Field(..., description="Type of challenge (pick_the, upright)")
+    image_b64: str = Field(..., description="Base64 encoded image")
+    target_label: Optional[str] = Field(None, description="Target label untuk pick_the challenges")
+
+class FunCaptchaResponse(BaseModel):
+    """Response model untuk FunCaptcha solving"""
+    status: str = Field(..., description="Status: success, not_found, error")
+    box: Optional[List[float]] = Field(None, description="Bounding box coordinates [x, y, w, h]")
+    button_index: Optional[int] = Field(None, description="Button index untuk upright challenges")
+    confidence: Optional[float] = Field(None, description="Detection confidence")
+    message: Optional[str] = Field(None, description="Additional message")
+    processing_time: Optional[float] = Field(None, description="Processing time in seconds")
+
+# =================================================================
+# AUTHENTICATION
+# =================================================================
+
+security = HTTPBearer()
+
+def get_api_key_from_secrets() -> str:
+    """Get API key dari Hugging Face Secrets"""
+    api_key = os.getenv("FUNCAPTCHA_API_KEY")
+    if not api_key:
+        logger.error("FUNCAPTCHA_API_KEY not found in environment variables")
+        raise ValueError("API key tidak ditemukan dalam HF Secrets")
+    return api_key
+
+def verify_api_key(credentials: HTTPAuthorizationCredentials = Depends(security)) -> bool:
+    """Verify API key dari request header"""
+    expected_key = get_api_key_from_secrets()
+    if credentials.credentials != expected_key:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid API key",
+            headers={"WWW-Authenticate": "Bearer"}
+        )
+    return True
+
+# =================================================================
+# MODEL CONFIGURATION & MANAGEMENT
+# =================================================================
+
+CONFIGS = {
+    'default': {
+        'model_path': 'best.onnx',
+        'yaml_path': 'data.yaml',
+        'input_size': 640,
+        'confidence_threshold': 0.4,
+        'nms_threshold': 0.2
+    },
+    'spiral_galaxy': {
+        'model_path': 'bestspiral.onnx',
+        'yaml_path': 'dataspiral.yaml', 
+        'input_size': 416,
+        'confidence_threshold': 0.30,
+        'nms_threshold': 0.45
+    },
+    'upright': {
+        'model_path': 'best_upright.onnx',
+        'yaml_path': 'data_upright.yaml',
+        'input_size': 640,
+        'confidence_threshold': 0.45,
+        'nms_threshold': 0.45
+    }
+}
+
+MODEL_ROUTING = [
+    (['spiral', 'galaxy'], 'spiral_galaxy')
+]
+
+# Global cache untuk models dan responses
+LOADED_MODELS: Dict[str, Dict[str, Any]] = {}
+RESPONSE_CACHE: Dict[str, Dict[str, Any]] = {}
+CACHE_MAX_SIZE = 100
+
+class ModelManager:
+    """Manager untuk loading dan caching models"""
+    
+    @staticmethod
+    async def get_model(config_key: str) -> Optional[Dict[str, Any]]:
+        """Load model dengan caching untuk efficiency"""
+        # Check if any ML backend is available
+        if not ML_BACKEND_AVAILABLE:
+            logger.error("❌ No ML backend available - cannot load models")
+            return None
+            
+        if config_key not in LOADED_MODELS:
+            logger.info(f"Loading model: {config_key}")
+            
+            try:
+                config = CONFIGS[config_key]
+                
+                # Check if files exist
+                if not os.path.exists(config['model_path']):
+                    logger.warning(f"Model file not found: {config['model_path']}")
+                    return None
+                
+                if not os.path.exists(config['yaml_path']):
+                    logger.warning(f"YAML file not found: {config['yaml_path']}")
+                    return None
+                
+                # Load model dengan available backend
+                session = None
+                
+                if ONNX_AVAILABLE:
+                    # Load ONNX session dengan CPU optimization
+                    providers = ['CPUExecutionProvider']
+                    session_options = ort.SessionOptions()
+                    session_options.intra_op_num_threads = 2  # Optimize untuk CPU
+                    session_options.inter_op_num_threads = 2
+                    session_options.execution_mode = ort.ExecutionMode.ORT_SEQUENTIAL
+                    session_options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
+                    
+                    session = ort.InferenceSession(
+                        config['model_path'],
+                        providers=providers,
+                        sess_options=session_options
+                    )
+                else:
+                    # For now, only ONNX Runtime is supported for model loading
+                    # PyTorch/TensorFlow alternatives would need model conversion
+                    logger.error("❌ ONNX models require ONNX Runtime - other backends not yet implemented")
+                    return None
+                
+                # Load class names
+                with open(config['yaml_path'], 'r', encoding='utf-8') as file:
+                    class_names = yaml.safe_load(file)['names']
+                
+                LOADED_MODELS[config_key] = {
+                    'session': session,
+                    'class_names': class_names,
+                    'input_name': session.get_inputs()[0].name,
+                    'input_size': config['input_size'],
+                    'confidence': config['confidence_threshold'],
+                    'nms': config.get('nms_threshold', 0.45)
+                }
+                
+                logger.info(f"✅ Model loaded successfully: {config_key}")
+                
+            except Exception as e:
+                logger.error(f"❌ Error loading model {config_key}: {e}")
+                return None
+                
+        return LOADED_MODELS[config_key]
+
+# =================================================================
+# IMAGE PROCESSING & UTILITIES
+# =================================================================
+
+def preprocess_image(image_bytes: bytes, input_size: int) -> np.ndarray:
+    """Preprocess image untuk ONNX inference dengan optimasi memory"""
+    image = Image.open(io.BytesIO(image_bytes)).convert('RGB')
+    image_np = np.array(image)
+    h, w, _ = image_np.shape
+    
+    scale = min(input_size / w, input_size / h)
+    new_w, new_h = int(w * scale), int(h * scale)
+    
+    resized_image = cv2.resize(image_np, (new_w, new_h))
+    padded_image = np.full((input_size, input_size, 3), 114, dtype=np.uint8)
+    
+    # Calculate padding
+    y_offset = (input_size - new_h) // 2
+    x_offset = (input_size - new_w) // 2
+    
+    padded_image[y_offset:y_offset + new_h, x_offset:x_offset + new_w, :] = resized_image
+    
+    # Convert untuk ONNX
+    input_tensor = padded_image.astype(np.float32) / 255.0
+    input_tensor = np.transpose(input_tensor, (2, 0, 1))
+    input_tensor = np.expand_dims(input_tensor, axis=0)
+    
+    return input_tensor
+
+def fuzzy_match_label(target_label: str, class_names: List[str], threshold: float = 0.6) -> Optional[str]:
+    """Fuzzy matching untuk label variations"""
+    target_normalized = target_label.lower().strip()
+    
+    # Dictionary untuk common variations
+    label_variants = {
+        'ice cream': ['ice cream', 'icecream', 'ice'],
+        'hotdog': ['hot dog', 'hotdog', 'hot-dog'],  
+        'hot dog': ['hot dog', 'hotdog', 'hot-dog'],
+        'sunglasses': ['sunglasses', 'sun glasses', 'sunglass'],
+        'sun glasses': ['sunglasses', 'sun glasses', 'sunglass']
+    }
+    
+    # 1. Exact match
+    if target_normalized in class_names:
+        return target_normalized
+    
+    # 2. Check known variants
+    for main_label, variants in label_variants.items():
+        if target_normalized in variants and main_label in class_names:
+            return main_label
+    
+    # 3. Fuzzy matching
+    best_matches = difflib.get_close_matches(
+        target_normalized,
+        [name.lower() for name in class_names],
+        n=3,
+        cutoff=threshold
+    )
+    
+    if best_matches:
+        for match in best_matches:
+            for class_name in class_names:
+                if class_name.lower() == match:
+                    return class_name
+    
+    # 4. Partial matching
+    for class_name in class_names:
+        if target_normalized in class_name.lower() or class_name.lower() in target_normalized:
+            return class_name
+    
+    return None
+
+def get_config_key_for_label(target_label: str) -> str:
+    """Determine which model config to use"""
+    for keywords, config_key in MODEL_ROUTING:
+        if any(keyword in target_label for keyword in keywords):
+            return config_key
+    return 'default'
+
+def get_button_index(x_center: float, y_center: float, img_width: int, img_height: int, 
+                    grid_cols: int = 3, grid_rows: int = 2) -> int:
+    """Calculate button index dari coordinates"""
+    
+    # Calculate grid cell dimensions
+    cell_width = img_width / grid_cols
+    cell_height = img_height / grid_rows
+    
+    # Calculate which cell the center point falls into
+    col = int(x_center // cell_width)
+    row = int(y_center // cell_height)
+    
+    # Ensure col and row are within bounds
+    col = max(0, min(col, grid_cols - 1))
+    row = max(0, min(row, grid_rows - 1))
+    
+    # Calculate button index (1-based)
+    button_index = row * grid_cols + col + 1
+    
+    # Debug logging
+    logger.info(f"🔍 BUTTON INDEX DEBUG: Input coordinates: ({x_center:.2f}, {y_center:.2f})")
+    logger.info(f"🔍 BUTTON INDEX DEBUG: Image dimensions: {img_width}x{img_height}")
+    logger.info(f"🔍 BUTTON INDEX DEBUG: Grid: {grid_cols}x{grid_rows}")
+    logger.info(f"🔍 BUTTON INDEX DEBUG: Cell dimensions: {cell_width:.2f}x{cell_height:.2f}")
+    logger.info(f"🔍 BUTTON INDEX DEBUG: Grid position: col={col}, row={row}")
+    logger.info(f"🔍 BUTTON INDEX DEBUG: Calculated button index: {button_index}")
+    logger.info(f"🔍 BUTTON INDEX DEBUG: Grid layout visualization:")
+    logger.info(f"🔍 BUTTON INDEX DEBUG: [1] [2] [3]")
+    logger.info(f"🔍 BUTTON INDEX DEBUG: [4] [5] [6]")
+    logger.info(f"🔍 BUTTON INDEX DEBUG: X ranges: [0-{cell_width:.1f}] [{cell_width:.1f}-{cell_width*2:.1f}] [{cell_width*2:.1f}-{img_width}]")
+    logger.info(f"🔍 BUTTON INDEX DEBUG: Y ranges: [0-{cell_height:.1f}] [{cell_height:.1f}-{img_height}]")
+    
+    return button_index
+
+# =================================================================
+# CACHING SYSTEM
+# =================================================================
+
+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"""
+    start_time = datetime.now()
+    
+    target_label_original = data['target_label']
+    image_b64 = data['image_b64']
+    target_label = target_label_original
+    
+    config_key = get_config_key_for_label(target_label)
+    
+    if config_key == 'spiral_galaxy':
+        target_label = 'spiral'
+    
+    model_data = await ModelManager.get_model(config_key)
+    if not model_data:
+        if not ML_BACKEND_AVAILABLE:
+            return {
+                'status': 'error', 
+                'message': 'No ML backend available - model inference disabled',
+                'processing_time': (datetime.now() - start_time).total_seconds()
+            }
+        return {
+            'status': 'error', 
+            'message': f'Model {config_key} tidak ditemukan',
+            'processing_time': (datetime.now() - start_time).total_seconds()
+        }
+    
+    try:
+        # Decode image
+        image_bytes = base64.b64decode(image_b64.split(',')[1])
+        
+        # Fuzzy matching untuk label
+        matched_label = fuzzy_match_label(target_label, model_data['class_names'])
+        if not matched_label:
+            return {
+                'status': 'not_found', 
+                'message': f'Label "{target_label}" tidak ditemukan dalam model',
+                'processing_time': (datetime.now() - start_time).total_seconds()
+            }
+        
+        target_label = matched_label
+        
+        # Preprocessing
+        input_tensor = preprocess_image(image_bytes, model_data['input_size'])
+        
+        # Inference
+        outputs = model_data['session'].run(None, {model_data['input_name']: input_tensor})[0]
+        predictions = np.squeeze(outputs).T
+        
+        # Process detections
+        boxes = []
+        confidences = []
+        class_ids = []
+        
+        for pred in predictions:
+            class_scores = pred[4:]
+            class_id = np.argmax(class_scores)
+            max_confidence = class_scores[class_id]
+            
+            if max_confidence > model_data['confidence']:
+                confidences.append(float(max_confidence))
+                class_ids.append(class_id)
+                box_model = pred[:4]
+                x_center, y_center, width, height = box_model
+                x1 = x_center - width / 2
+                y1 = y_center - height / 2
+                boxes.append([int(x1), int(y1), int(width), int(height)])
+        
+        if not boxes:
+            return {
+                'status': 'not_found',
+                'processing_time': (datetime.now() - start_time).total_seconds()
+            }
+        
+        # Non-Maximum Suppression
+        indices = cv2.dnn.NMSBoxes(
+            np.array(boxes), 
+            np.array(confidences), 
+            model_data['confidence'], 
+            model_data['nms']
+        )
+        
+        if len(indices) == 0:
+            return {
+                'status': 'not_found',
+                'processing_time': (datetime.now() - start_time).total_seconds()
+            }
+        
+        # Find target
+        target_class_id = model_data['class_names'].index(target_label)
+        best_match_box = None
+        highest_score = 0
+        
+        for i in indices.flatten():
+            if class_ids[i] == target_class_id:
+                current_score = confidences[i]
+                if current_score > highest_score:
+                    highest_score = current_score
+                    best_match_box = boxes[i]
+        
+        if best_match_box is not None:
+            # Scale back to original coordinates
+            img = Image.open(io.BytesIO(image_bytes))
+            original_w, original_h = img.size
+            scale = min(model_data['input_size'] / original_w, model_data['input_size'] / original_h)
+            pad_x = (model_data['input_size'] - original_w * scale) / 2
+            pad_y = (model_data['input_size'] - original_h * scale) / 2
+            
+            x_orig = (best_match_box[0] - pad_x) / scale
+            y_orig = (best_match_box[1] - pad_y) / scale
+            w_orig = best_match_box[2] / scale
+            h_orig = best_match_box[3] / scale
+            
+            return {
+                'status': 'success',
+                'box': [x_orig, y_orig, w_orig, h_orig],
+                'confidence': highest_score,
+                'processing_time': (datetime.now() - start_time).total_seconds()
+            }
+        
+    except Exception as e:
+        logger.error(f"Error in handle_pick_the_challenge: {e}")
+        return {
+            'status': 'error', 
+            'message': str(e),
+            'processing_time': (datetime.now() - start_time).total_seconds()
+        }
+    
+    return {
+        'status': 'not_found',
+        'processing_time': (datetime.now() - start_time).total_seconds()
+    }
+
+async def handle_upright_challenge(data: dict) -> dict:
+    """Handle 'upright' challenges"""
+    start_time = datetime.now()
+    
+    try:
+        image_b64 = data['image_b64']
+        model_data = await ModelManager.get_model('upright')
+        
+        if not model_data:
+            if not ML_BACKEND_AVAILABLE:
+                return {
+                    'status': 'error',
+                    'message': 'No ML backend available - model inference disabled',
+                    'processing_time': (datetime.now() - start_time).total_seconds()
+                }
+            return {
+                'status': 'error', 
+                'message': 'Model upright tidak ditemukan',
+                'processing_time': (datetime.now() - start_time).total_seconds()
+            }
+        
+        image_bytes = base64.b64decode(image_b64.split(',')[1])
+        reconstructed_image_pil = Image.open(io.BytesIO(image_bytes))
+        original_w, original_h = reconstructed_image_pil.size
+        
+        # Debug: Log image dimensions
+        logger.info(f"🔍 UPRIGHT DEBUG: Original image dimensions: {original_w}x{original_h}")
+        
+        input_tensor = preprocess_image(image_bytes, model_data['input_size'])
+        outputs = model_data['session'].run(None, {model_data['input_name']: input_tensor})[0]
+        
+        predictions = np.squeeze(outputs).T
+        confident_preds = predictions[predictions[:, 4] > model_data['confidence']]
+        
+        # Debug: Log predictions info
+        logger.info(f"🔍 UPRIGHT DEBUG: Total predictions: {len(predictions)}, Confident predictions: {len(confident_preds)}")
+        logger.info(f"🔍 UPRIGHT DEBUG: Confidence threshold: {model_data['confidence']}")
+        
+        if len(confident_preds) == 0:
+            return {
+                'status': 'not_found',
+                'message': 'Tidak ada objek terdeteksi',
+                'processing_time': (datetime.now() - start_time).total_seconds()
+            }
+        
+        # Debug: Log all confident predictions
+        for i, pred in enumerate(confident_preds):
+            logger.info(f"🔍 UPRIGHT DEBUG: Prediction {i+1}: x_center={pred[0]:.2f}, y_center={pred[1]:.2f}, width={pred[2]:.2f}, height={pred[3]:.2f}, confidence={pred[4]:.4f}")
+        
+        best_detection = confident_preds[np.argmax(confident_preds[:, 4])]
+        box_model = best_detection[:4]
+        
+        # Debug: Log model space coordinates
+        logger.info(f"🔍 UPRIGHT DEBUG: Best detection (model space): x_center={box_model[0]:.2f}, y_center={box_model[1]:.2f}, width={box_model[2]:.2f}, height={box_model[3]:.2f}")
+        
+        scale = min(model_data['input_size'] / original_w, model_data['input_size'] / original_h)
+        pad_x = (model_data['input_size'] - original_w * scale) / 2
+        pad_y = (model_data['input_size'] - original_h * scale) / 2
+        
+        # Debug: Log scaling parameters
+        logger.info(f"🔍 UPRIGHT DEBUG: Scaling parameters: scale={scale:.4f}, pad_x={pad_x:.2f}, pad_y={pad_y:.2f}")
+        logger.info(f"🔍 UPRIGHT DEBUG: Model input size: {model_data['input_size']}")
+        
+        x_center_orig = (box_model[0] - pad_x) / scale
+        y_center_orig = (box_model[1] - pad_y) / scale
+        
+        # Debug: Log original space coordinates
+        logger.info(f"🔍 UPRIGHT DEBUG: Original space coordinates: x_center={x_center_orig:.2f}, y_center={y_center_orig:.2f}")
+        
+        # Debug: Log grid calculation details
+        grid_cols, grid_rows = 3, 2
+        col = int(x_center_orig // (original_w / grid_cols))
+        row = int(y_center_orig // (original_h / grid_rows))
+        logger.info(f"🔍 UPRIGHT DEBUG: Grid calculation: grid_cols={grid_cols}, grid_rows={grid_rows}")
+        logger.info(f"🔍 UPRIGHT DEBUG: Cell calculation: col={col}, row={row}")
+        logger.info(f"🔍 UPRIGHT DEBUG: Grid cell dimensions: width={original_w/grid_cols:.2f}, height={original_h/grid_rows:.2f}")
+        
+        button_to_click = get_button_index(x_center_orig, y_center_orig, original_w, original_h)
+        
+        # Debug: Log final result
+        logger.info(f"🔍 UPRIGHT DEBUG: Final button index: {button_to_click}")
+        logger.info(f"🔍 UPRIGHT DEBUG: Button layout (3x2 grid): [1, 2, 3] [4, 5, 6]")
+        
+        return {
+            'status': 'success',
+            'button_index': button_to_click,
+            'confidence': float(best_detection[4]),
+            'processing_time': (datetime.now() - start_time).total_seconds()
+        }
+        
+    except Exception as e:
+        logger.error(f"Error in handle_upright_challenge: {e}")
+        return {
+            'status': 'error',
+            'message': str(e),
+            'processing_time': (datetime.now() - start_time).total_seconds()
+        }
+
+# =================================================================
+# FASTAPI APPLICATION
+# =================================================================
+
+app = FastAPI(
+    title="🧩 FunCaptcha Solver API",
+    description="High-performance FunCaptcha solver dengan fuzzy matching untuk Hugging Face Spaces",
+    version="1.0.0",
+    docs_url="/docs",
+    redoc_url="/redoc"
+)
+
+# CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+@app.get("/")
+async def root():
+    """Root endpoint dengan info API"""
+    return {
+        "service": "FunCaptcha Solver API",
+        "version": "1.0.0",
+        "status": "running",
+        "endpoints": {
+            "/solve": "POST - Solve FunCaptcha challenges",
+            "/health": "GET - Health check",
+            "/docs": "GET - API documentation"
+        },
+        "models_loaded": len(LOADED_MODELS),
+        "cache_size": len(RESPONSE_CACHE)
+    }
+
+@app.get("/health")
+async def health_check():
+    """Health check endpoint"""
+    warnings = []
+    if not ONNX_AVAILABLE:
+        warnings.append("ONNX Runtime not available")
+    if not ML_BACKEND_AVAILABLE:
+        warnings.append("No ML backend available - model inference disabled")
+    
+    backend_status = "none"
+    if ONNX_AVAILABLE:
+        backend_status = "onnxruntime"
+    elif TORCH_AVAILABLE:
+        backend_status = "pytorch"
+    elif TF_AVAILABLE:
+        backend_status = "tensorflow"
+    
+    return {
+        "status": "healthy" if ML_BACKEND_AVAILABLE else "degraded",
+        "service": "FunCaptcha Solver",
+        "ml_backend": backend_status,
+        "onnx_runtime_available": ONNX_AVAILABLE,
+        "pytorch_available": TORCH_AVAILABLE,
+        "tensorflow_available": TF_AVAILABLE,
+        "models_loaded": len(LOADED_MODELS),
+        "available_models": list(CONFIGS.keys()),
+        "cache_entries": len(RESPONSE_CACHE),
+        "warnings": warnings
+    }
+
+@app.post("/solve", response_model=FunCaptchaResponse)
+async def solve_funcaptcha(
+    request: FunCaptchaRequest,
+    authenticated: bool = Depends(verify_api_key)
+) -> FunCaptchaResponse:
+    """
+    🧩 Solve FunCaptcha challenges
+    
+    Supports:
+    - pick_the: Pick specific objects dari images  
+    - upright: Find correctly oriented objects
+    
+    Features:
+    - Fuzzy label matching
+    - Response caching
+    - 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)
+    
+    # Process request
+    if request.challenge_type == 'pick_the':
+        if not request.target_label:
+            raise HTTPException(status_code=400, detail="target_label required for pick_the challenges")
+        result = await handle_pick_the_challenge(request_dict)
+    elif request.challenge_type == 'upright':
+        result = await handle_upright_challenge(request_dict)
+    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']}")
+    
+    return FunCaptchaResponse(**result)
+
+# =================================================================
+# APPLICATION STARTUP
+# =================================================================
+
+@app.on_event("startup")
+async def startup_event():
+    """Initialize aplikasi saat startup"""
+    logger.info("🚀 Starting FunCaptcha Solver API...")
+    
+    # Verify API key ada
+    try:
+        api_key = get_api_key_from_secrets()
+        logger.info("✅ API key loaded successfully")
+    except ValueError as e:
+        logger.error(f"❌ API key error: {e}")
+        raise e
+    
+    # Preload default model jika ada dan ML backend available
+    if ML_BACKEND_AVAILABLE and os.path.exists('best.onnx') and os.path.exists('data.yaml'):
+        logger.info("Preloading default model...")
+        try:
+            await ModelManager.get_model('default')
+            logger.info("✅ Default model preloaded successfully")
+        except Exception as e:
+            logger.warning(f"⚠️ Failed to preload default model: {e}")
+    elif not ML_BACKEND_AVAILABLE:
+        logger.warning("⚠️ No ML backend available - skipping model preload")
+    else:
+        logger.warning("⚠️ Model files (best.onnx, data.yaml) not found - upload them to enable solving")
+    
+    if ML_BACKEND_AVAILABLE:
+        backend_name = "ONNX Runtime" if ONNX_AVAILABLE else "PyTorch" if TORCH_AVAILABLE else "TensorFlow"
+        logger.info(f"✅ FunCaptcha Solver API started successfully with {backend_name} backend")
+    else:
+        logger.warning("⚠️ FunCaptcha Solver API started with limited functionality (No ML backend available)")
+
+@app.on_event("shutdown")
+async def shutdown_event():
+    """Cleanup saat shutdown"""
+    logger.info("🛑 Shutting down FunCaptcha Solver API...")
+    
+    # Clear caches
+    LOADED_MODELS.clear()
+    RESPONSE_CACHE.clear()
+    
+    logger.info("✅ Cleanup completed")
+
+# =================================================================
+# DEVELOPMENT SERVER
+# =================================================================
+
+if __name__ == "__main__":
+    uvicorn.run(
+        "app:app",
+        host="0.0.0.0",
+        port=7860,
+        reload=False,  # Disabled untuk production
+        workers=1      # Single worker untuk HF Spaces
+    )