Add Bangla model API

app.py

@@ -1,24 +1,145 @@
-from fastapi import FastAPI
+from fastapi import FastAPI, HTTPException
 from pydantic import BaseModel
 import joblib
+import os
+import pickle
+import logging
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
 app = FastAPI()
 
 class PredictRequest(BaseModel):
     text: str
 
-# Load models
-model = joblib.load("bangla_model.pkl")
-vectorizer = joblib.load("bangla_vectorizer.pkl")
-label_encoder = joblib.load("bangla_label_encoder.pkl")
+# 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 joblib first
+    try:
+        return joblib.load(filename)
+    except Exception as e1:
+        logger.warning(f"Joblib failed for {filename}: {e1}")
+        
+        # Try pickle as fallback
+        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  # Raise original joblib error
+
+@app.on_event("startup")
+async def startup_event():
+    global model, vectorizer, label_encoder, models_loaded
+    
+    try:
+        logger.info("Starting model loading...")
+        
+        # Load each model individually with error handling
+        logger.info("Loading bangla_model.pkl...")
+        model = load_model_safe("bangla_model.pkl")
+        logger.info(f"Model type: {type(model)}")
+        
+        logger.info("Loading bangla_vectorizer.pkl...")
+        vectorizer = load_model_safe("bangla_vectorizer.pkl")
+        logger.info(f"Vectorizer type: {type(vectorizer)}")
+        
+        logger.info("Loading bangla_label_encoder.pkl...")
+        label_encoder = load_model_safe("bangla_label_encoder.pkl")
+        logger.info(f"Label encoder type: {type(label_encoder)}")
+        
+        # Test pipeline with dummy data
+        logger.info("Testing pipeline...")
+        test_vect = vectorizer.transform(["test"])
+        test_pred = model.predict(test_vect)
+        test_label = label_encoder.inverse_transform(test_pred)
+        logger.info(f"Pipeline test successful: {test_label[0]}")
+        
+        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
+        # Don't raise here - let the app start and handle errors in endpoints
 
 @app.get("/")
 def root():
-    return {"message": "Bangla model API is running!"}
+    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():
+    """Detailed status endpoint"""
+    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("/predict")
 def predict(request: PredictRequest):
-    vect = vectorizer.transform([request.text])
-    pred = model.predict(vect)
-    label = label_encoder.inverse_transform(pred)
-    return {"prediction": label[0]}
+    if not models_loaded:
+        raise HTTPException(
+            status_code=503, 
+            detail="Models not loaded. Check /status endpoint for details."
+        )
+    
+    if not request.text or not request.text.strip():
+        raise HTTPException(status_code=400, detail="Text cannot be empty")
+    
+    try:
+        logger.info(f"Processing text: {request.text[:50]}...")
+        
+        # Transform text
+        vect = vectorizer.transform([request.text])
+        logger.info(f"Vectorization successful, shape: {vect.shape}")
+        
+        # Make prediction
+        pred = model.predict(vect)
+        logger.info(f"Prediction successful: {pred}")
+        
+        # Transform label
+        label = label_encoder.inverse_transform(pred)
+        logger.info(f"Label transformation successful: {label[0]}")
+        
+        return {"prediction": label[0]}
+        
+    except Exception as e:
+        logger.error(f"Prediction error: {str(e)}")
+        raise HTTPException(
+            status_code=500, 
+            detail=f"Prediction failed: {str(e)}"
+        )
+
+# Add a manual model reload endpoint for debugging
+@app.post("/reload-models")
+def reload_models():
+    """Manually reload models - useful for debugging"""
+    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)}")