Add Bangla model API

app.py

@@ -1,218 +1,22 @@
-from fastapi import FastAPI, HTTPException
-from pydantic import BaseModel
+from fastapi import FastAPI
 import joblib
-import os
-import logging
-import numpy as np
-import traceback
-
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
 
 app = FastAPI()
 
-class PredictRequest(BaseModel):
-    text: str
-
-# Global model variables
-model = None
-vectorizer = None
-label_encoder = None
-models_loaded = False
-
-def load_model_safe(filename):
-    """Safely load model with multiple methods"""
-    if not os.path.exists(filename):
-        raise FileNotFoundError(f"{filename} not found")
-    
-    try:
-        return joblib.load(filename)
-    except Exception as e1:
-        logger.warning(f"Joblib failed for {filename}: {e1}")
-        
-        try:
-            with open(filename, 'rb') as f:
-                return pickle.load(f)
-        except Exception as e2:
-            logger.error(f"Pickle also failed for {filename}: {e2}")
-            raise e1
-
-@app.on_event("startup")
-async def startup_event():
-    global model, vectorizer, label_encoder, models_loaded
-    
-    try:
-        logger.info("Loading models...")
-        model = load_model_safe("bangla_model.pkl")
-        vectorizer = load_model_safe("bangla_vectorizer.pkl")
-        label_encoder = load_model_safe("bangla_label_encoder.pkl")
-        
-        # Test pipeline
-        test_vect = vectorizer.transform(["test"])
-        test_pred = model.predict(test_vect)
-        test_label = label_encoder.inverse_transform(test_pred)
-        
-        models_loaded = True
-        logger.info("All models loaded successfully!")
-        
-    except Exception as e:
-        logger.error(f"Failed to load models: {str(e)}")
-        models_loaded = False
+# Load your model, vectorizer, label encoder
+model = joblib.load("bangla_model.pkl")
+vectorizer = joblib.load("bangla_vectorizer.pkl")
+label_encoder = joblib.load("bangla_label_encoder.pkl")
 
+# Root route to avoid 404
 @app.get("/")
 def root():
-    return {
-        "message": "Bangla model API is running!",
-        "models_loaded": models_loaded,
-        "status": "healthy" if models_loaded else "models_not_loaded"
-    }
-
-@app.get("/status")
-def status():
-    return {
-        "models_loaded": models_loaded,
-        "model_available": model is not None,
-        "vectorizer_available": vectorizer is not None,
-        "label_encoder_available": label_encoder is not None,
-        "current_directory": os.getcwd(),
-        "available_files": [f for f in os.listdir('.') if f.endswith('.pkl')]
-    }
-
-@app.post("/debug-predict")
-def debug_predict(request: PredictRequest):
-    """Debug version of predict with detailed logging"""
-    if not models_loaded:
-        raise HTTPException(status_code=503, detail="Models not loaded")
-    
-    debug_info = {"steps": []}
-    
-    try:
-        # Step 1: Input validation
-        debug_info["steps"].append("1. Input validation")
-        if not request.text or not request.text.strip():
-            raise HTTPException(status_code=400, detail="Text cannot be empty")
-        
-        debug_info["input_text"] = request.text
-        debug_info["input_length"] = len(request.text)
-        
-        # Step 2: Text preprocessing
-        debug_info["steps"].append("2. Text preprocessing")
-        text_to_process = request.text.strip()
-        debug_info["processed_text_length"] = len(text_to_process)
-        
-        # Step 3: Vectorization
-        debug_info["steps"].append("3. Vectorization")
-        try:
-            vect = vectorizer.transform([text_to_process])
-            debug_info["vectorized_shape"] = vect.shape
-            debug_info["vectorized_nnz"] = vect.nnz
-            debug_info["vectorized_dtype"] = str(vect.dtype)
-        except Exception as e:
-            debug_info["vectorization_error"] = str(e)
-            raise HTTPException(status_code=500, detail=f"Vectorization failed: {str(e)}")
-        
-        # Step 4: Model prediction
-        debug_info["steps"].append("4. Model prediction")
-        try:
-            pred = model.predict(vect)
-            debug_info["raw_prediction"] = pred.tolist() if hasattr(pred, 'tolist') else str(pred)
-            debug_info["prediction_type"] = str(type(pred))
-            debug_info["prediction_shape"] = pred.shape if hasattr(pred, 'shape') else "no shape"
-        except Exception as e:
-            debug_info["prediction_error"] = str(e)
-            raise HTTPException(status_code=500, detail=f"Model prediction failed: {str(e)}")
-        
-        # Step 5: Label transformation
-        debug_info["steps"].append("5. Label transformation")
-        try:
-            # Check if prediction is in valid range
-            if hasattr(label_encoder, 'classes_'):
-                debug_info["available_classes"] = label_encoder.classes_.tolist()
-                debug_info["num_classes"] = len(label_encoder.classes_)
-            
-            label = label_encoder.inverse_transform(pred)
-            debug_info["final_label"] = label[0] if len(label) > 0 else "no label"
-            debug_info["label_type"] = str(type(label[0])) if len(label) > 0 else "no label"
-        except Exception as e:
-            debug_info["label_transform_error"] = str(e)
-            raise HTTPException(status_code=500, detail=f"Label transformation failed: {str(e)}")
-        
-        debug_info["steps"].append("6. Success!")
-        debug_info["final_prediction"] = label[0]
-        
-        return debug_info
-        
-    except HTTPException:
-        raise
-    except Exception as e:
-        debug_info["unexpected_error"] = str(e)
-        debug_info["traceback"] = traceback.format_exc()
-        raise HTTPException(status_code=500, detail=f"Unexpected error: {str(e)}")
+    return {"message": "Bangla model API is running!"}
 
+# Example predict endpoint
 @app.post("/predict")
-def predict(request: PredictRequest):
-    """Production predict endpoint with better error handling"""
-    if not models_loaded:
-        raise HTTPException(status_code=503, detail="Models not loaded")
-    
-    try:
-        # Input validation
-        if not request.text or not request.text.strip():
-            raise HTTPException(status_code=400, detail="Text cannot be empty")
-        
-        text_to_process = request.text.strip()
-        logger.info(f"Processing text of length: {len(text_to_process)}")
-        
-        # Vectorization with error handling
-        try:
-            vect = vectorizer.transform([text_to_process])
-            logger.info(f"Vectorization successful: shape={vect.shape}, nnz={vect.nnz}")
-        except Exception as e:
-            logger.error(f"Vectorization error: {str(e)}")
-            raise HTTPException(status_code=500, detail="Text vectorization failed")
-        
-        # Prediction with error handling
-        try:
-            pred = model.predict(vect)
-            logger.info(f"Prediction successful: {pred}")
-        except Exception as e:
-            logger.error(f"Model prediction error: {str(e)}")
-            raise HTTPException(status_code=500, detail="Model prediction failed")
-        
-        # Label transformation with error handling
-        try:
-            # Validate prediction is in expected range
-            if hasattr(label_encoder, 'classes_'):
-                max_class = len(label_encoder.classes_) - 1
-                if np.any(pred < 0) or np.any(pred > max_class):
-                    logger.error(f"Prediction {pred} out of range [0, {max_class}]")
-                    raise ValueError(f"Prediction out of range")
-            
-            label = label_encoder.inverse_transform(pred)
-            logger.info(f"Label transformation successful: {label[0]}")
-        except Exception as e:
-            logger.error(f"Label transformation error: {str(e)}")
-            raise HTTPException(status_code=500, detail="Label transformation failed")
-        
-        return {"prediction": label[0]}
-        
-    except HTTPException:
-        raise
-    except Exception as e:
-        logger.error(f"Unexpected error in predict: {str(e)}")
-        logger.error(traceback.format_exc())
-        raise HTTPException(status_code=500, detail="Internal server error")
-
-@app.post("/reload-models")
-def reload_models():
-    global model, vectorizer, label_encoder, models_loaded
-    
-    try:
-        model = load_model_safe("bangla_model.pkl")
-        vectorizer = load_model_safe("bangla_vectorizer.pkl")
-        label_encoder = load_model_safe("bangla_label_encoder.pkl")
-        models_loaded = True
-        return {"message": "Models reloaded successfully"}
-    except Exception as e:
-        models_loaded = False
-        raise HTTPException(status_code=500, detail=f"Failed to reload models: {str(e)}")
+def predict(text: str):
+    vect = vectorizer.transform([text])
+    pred = model.predict(vect)
+    label = label_encoder.inverse_transform(pred)
+    return {"prediction": label[0]}