Update app.py

app.py

@@ -1,230 +1,241 @@
+from fastapi import FastAPI, HTTPException, Request, Depends
+from fastapi.responses import JSONResponse
+from fastapi.middleware.cors import CORSMiddleware
+import pandas as pd
+import joblib
+import numpy as np
 import os
-import sys
-import traceback
-from pathlib import Path
-import pickle
-from datetime import datetime
+import time
+from sklearn.ensemble import RandomForestRegressor  # Important for model deserialization
+from pydantic import BaseModel, ValidationError, Field, field_validator, model_validator
+from typing import Any, Dict, List, Optional
 
-# Funcție de logging foarte verbos pentru debugging
-def debug_log(message, level="INFO"):
-    """
-    Funcție de logging care afișează informații detaliate despre starea aplicației.
-    Aceasta ne ajută să vedem exact unde se oprește procesul de inițializare.
-    """
-    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-    print(f"[{timestamp}] [{level}] {message}", flush=True)
-    
-    # Forțăm flush-ul pentru ca mesajele să apară imediat în loguri
-    sys.stdout.flush()
+# Create FastAPI application
+app = FastAPI(
+    title="Soil UCS Prediction API",
+    description="API for predicting the unconfined compressive strength (UCS) of cement-stabilized soils",
+    version="1.0.0"
+)
 
-# Începem logging-ul imediat la încărcarea modulului
-debug_log("🚀 PORNIREA APLICAȚIEI UCS - Început încărcare modul app.py")
+# Add CORS middleware to allow requests only from your interface server
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=[
+        "http://www.bi4e-at.tuiasi.ro/ucs-prediction/",
+        "https://www.bi4e-at.tuiasi.ro/ucs-prediction/"
+    ],
+    allow_credentials=True,
+    allow_methods=["GET", "POST"],  # Restrict to only necessary methods
+    allow_headers=["*"],
+)
 
+# Global variables
+MODEL_PATH = 'rf_model_optim.joblib'  # Path to the model
+DEFAULT_FEATURE_ORDER = ['cement_perecent', 'curing_period', 'compaction_rate']  # Default feature order
+
+# Load the model
 try:
-    # Importurile necesare cu logging pentru fiecare pas major
-    debug_log("📚 Încărcare biblioteci Python...")
-    from fastapi import FastAPI, HTTPException, Request, Depends, Query
-    from fastapi.responses import JSONResponse, HTMLResponse
-    from fastapi.middleware.cors import CORSMiddleware
-    debug_log("✅ FastAPI și dependențele încărcate cu succes")
-    
-    import pandas as pd
-    import joblib
-    import numpy as np
-    debug_log("✅ Biblioteci științifice (pandas, numpy, joblib) încărcate")
-    
-    from pydantic import BaseModel, ValidationError, Field, field_validator, model_validator
-    debug_log("✅ Pydantic încărcat pentru validarea datelor")
+    start_time = time.time()
+    model = joblib.load(MODEL_PATH)
     
-    debug_log("📊 Verificare directoare și fișiere disponibile...")
-    
-    # Verificăm ce fișiere sunt disponibile în directorul de lucru
-    current_dir = Path("/code")
-    debug_log(f"📁 Directorul de lucru: {current_dir}")
-    debug_log(f"📁 Conținutul directorului /code: {list(current_dir.iterdir())}")
-    
-    # Verificăm specific directorul cu modelele
-    models_dir = current_dir / "models_for_deployment"
-    debug_log(f"📁 Calea către modele: {models_dir}")
-    debug_log(f"📁 Directorul modele există: {models_dir.exists()}")
-    
-    if models_dir.exists():
-        debug_log(f"📁 Conținutul directorului modele: {list(models_dir.iterdir())}")
+    # Determine feature order from model or use default
+    if hasattr(model, 'feature_names_in_'):
+        FEATURE_ORDER = model.feature_names_in_
     else:
-        debug_log("❌ PROBLEMĂ: Directorul models_for_deployment nu există!")
-        
-    # Verificăm și modelele vechi pentru compatibilitate
-    old_model_files = ["rf_model.joblib", "rf_model_optim.joblib"]
-    for filename in old_model_files:
-        file_path = current_dir / filename
-        debug_log(f"📄 {filename} există: {file_path.exists()}")
-
+        FEATURE_ORDER = np.array(DEFAULT_FEATURE_ORDER)
+    
+    load_time = time.time() - start_time
+    print(f"Model loaded successfully in {load_time:.2f} seconds! Feature Order: {FEATURE_ORDER}")
 except Exception as e:
-    debug_log(f"❌ EROARE la importuri inițiale: {str(e)}", "ERROR")
-    debug_log(f"❌ Traceback complet: {traceback.format_exc()}", "ERROR")
-    # Nu facem exit aici - lăsăm aplicația să încerce să continue
+    import traceback
+    print(f"Error loading model: {str(e)}")
+    print(traceback.format_exc())
+    model = None
+    FEATURE_ORDER = np.array(DEFAULT_FEATURE_ORDER)
+
+# Input data model definition
+class SoilInput(BaseModel):
+    cement_perecent: float = Field(
+        ..., 
+        description="Cement percentage in the mixture (0-15%)"
+    )
+    curing_period: float = Field(
+        ...,
+        description="Curing period in days (1-90 days)"
+    )
+    compaction_rate: float = Field(
+        ...,
+        description="Compaction rate in mm/min (0.5-2.0 mm/min)"
+    )
+
+    @model_validator(mode="after")
+    def check_cement_and_curing(self):
+        if self.cement_perecent == 0:
+            self.curing_period = 0
+        else:
+            if not (1 <= self.curing_period <= 90):
+                raise ValueError("Curing period must be between 1 and 90 days")
+        return self
+
+    @field_validator('cement_perecent')
+    @classmethod
+    def validate_cement(cls, v: float) -> float:
+        if not 0 <= v <= 15:
+            raise ValueError("Cement percentage must be between 0% and 15%")
+        return v
+
+    @field_validator('compaction_rate')
+    @classmethod
+    def validate_compaction(cls, v: float) -> float:
+        if not 0.5 <= v <= 2:
+            raise ValueError("Compaction rate must be between 0.5 and 2 mm/min")
+        return v
     
-# Variabile globale pentru sistemul de modele
-sistem_incertitudine = None
-system_loaded = False
+    class Config:
+        schema_extra = {
+            "example": {
+                "cement_perecent": 5,
+                "curing_period": 28,
+                "compaction_rate": 1.0
+            }
+        }
 
-def load_uncertainty_system_with_detailed_logging():
-    """
-    Funcție de încărcare a sistemului de incertitudine cu logging foarte detaliat.
-    Aceasta ne va arăta exact unde se oprește procesul dacă apar probleme.
+# Prediction response model
+class PredictionResponse(BaseModel):
+    success: bool
+    prediction: float
+    units: str
+    input_parameters: Dict[str, float]
+    prediction_time_ms: Optional[float] = None
+
+# Function to check if model is loaded
+async def get_model():
+    if model is None:
+        raise HTTPException(
+            status_code=503,
+            detail="Model was not loaded correctly. Please try again later."
+        )
+    return model
+
+# Prediction endpoint
+@app.post("/predict", response_model=PredictionResponse, summary="UCS Prediction")
+async def predict(soil_data: SoilInput, model=Depends(get_model)):
     """
-    global sistem_incertitudine, system_loaded
+    Predicts the UCS (unconfined compressive strength) of soil.
     
-    debug_log("🔍 ÎNCEPEREA ÎNCĂRCĂRII SISTEMULUI DE INCERTITUDINE")
+    - **cement_perecent**: Cement percentage in the mixture (0-15%)
+    - **curing_period**: Curing period in days (1-90 days)
+    - **compaction_rate**: Compaction rate in mm/min (0.5-2 mm/min)
     
+    Returns the UCS strength in kPa.
+    """
     try:
-        # Strategia de încărcare cu mai multe opțiuni de fallback
-        models_dir = Path("/code/models_for_deployment")
-        possible_files = [
-            "sistem_incertitudine_final_sistem_complet.pkl",
-            "sistem_final_ncv_sistem_complet.pkl",  # Numele posibil diferit
-        ]
+        start_time = time.time()
         
-        sistem_loaded_successfully = False
+        # Build DataFrame for prediction
+        input_data = soil_data.dict()
+        input_df = pd.DataFrame([input_data])
         
-        for filename in possible_files:
-            file_path = models_dir / filename
-            debug_log(f"🔍 Verific fișierul: {file_path}")
-            
-            if file_path.exists():
-                debug_log(f"✅ Fișierul găsit: {filename}")
-                debug_log(f"📏 Dimensiunea fișierului: {file_path.stat().st_size / (1024*1024):.2f} MB")
-                
-                try:
-                    debug_log(f"📖 Încep încărcarea fișierului: {filename}")
-                    
-                    with open(file_path, 'rb') as f:
-                        sistem_incertitudine = pickle.load(f)
-                    
-                    debug_log(f"✅ Fișierul {filename} încărcat cu succes!")
-                    
-                    # Verificăm că sistemul are componentele necesare
-                    required_attrs = ['model_principal', 'model_incertitudine', 'predict_cu_incertitudine']
-                    missing_attrs = [attr for attr in required_attrs if not hasattr(sistem_incertitudine, attr)]
-                    
-                    if missing_attrs:
-                        debug_log(f"⚠️ Sistemul nu are atributele: {missing_attrs}", "WARNING")
-                    else:
-                        debug_log("✅ Sistemul are toate atributele necesare")
-                        sistem_loaded_successfully = True
-                        break
-                        
-                except Exception as load_error:
-                    debug_log(f"❌ Eroare la încărcarea {filename}: {str(load_error)}", "ERROR")
-                    debug_log(f"❌ Traceback: {traceback.format_exc()}", "ERROR")
-                    continue
+        # Ensure correct feature order
+        prediction_df = pd.DataFrame()
+        for feature in FEATURE_ORDER:
+            if feature in input_df.columns:
+                prediction_df[feature] = input_df[feature]
             else:
-                debug_log(f"❌ Fișierul nu există: {filename}")
+                raise ValueError(f"Feature '{feature}' is missing from input data")
         
-        if not sistem_loaded_successfully:
-            debug_log("🔄 Încerc încărcarea modelelor individuale ca fallback...")
-            return load_individual_models_fallback()
+        # Make prediction
+        prediction = model.predict(prediction_df)
         
-        system_loaded = True
-        debug_log("🎉 SISTEM DE INCERTITUDINE ÎNCĂRCAT CU SUCCES!")
-        return True
+        # Calculate prediction time
+        prediction_time_ms = (time.time() - start_time) * 1000
         
+        return {
+            "success": True,
+            "prediction": float(prediction[0]),
+            "units": "kPa",
+            "input_parameters": input_data,
+            "prediction_time_ms": prediction_time_ms
+        }
     except Exception as e:
-        debug_log(f"❌ EROARE GENERALĂ la încărcarea sistemului: {str(e)}", "ERROR")
-        debug_log(f"❌ Traceback complet: {traceback.format_exc()}", "ERROR")
-        return False
+        raise HTTPException(status_code=400, detail=str(e))
 
-def load_individual_models_fallback():
+# Status endpoint
+@app.get("/status", summary="API Status")
+async def status():
     """
-    Funcție de fallback care încearcă să încarce modelele vechi dacă sistemul nou nu funcționează.
+    Returns the API status and model availability.
     """
-    debug_log("🔄 ÎNCĂRCARE FALLBACK - modele individuale")
-    
-    try:
-        # Încercăm să încărcăm modelele vechi pentru compatibilitate
-        model_files = ["/code/rf_model_optim.joblib", "/code/rf_model.joblib"]
-        
-        for model_file in model_files:
-            debug_log(f"🔍 Verific modelul: {model_file}")
-            if Path(model_file).exists():
-                debug_log(f"✅ Modelul {model_file} există")
-                try:
-                    model = joblib.load(model_file)
-                    debug_log(f"✅ Modelul {model_file} încărcat cu succes")
-                    # Pentru moment, doar confirmăm că modelul se încarcă
-                    # Puteți implementa logica de compatibilitate aici
-                except Exception as e:
-                    debug_log(f"❌ Eroare la încărcarea {model_file}: {str(e)}", "ERROR")
-            else:
-                debug_log(f"❌ Modelul {model_file} nu există")
-        
-        debug_log("⚠️ Sistem funcționând în modul de compatibilitate limitată", "WARNING")
-        return False
-        
-    except Exception as e:
-        debug_log(f"❌ EROARE în funcția de fallback: {str(e)}", "ERROR")
-        return False
-
-# Încărcăm sistemul imediat după definirea funcțiilor
-debug_log("🎯 Pornesc încărcarea sistemului de modele...")
-model_loading_success = load_uncertainty_system_with_detailed_logging()
-debug_log(f"📊 Rezultatul încărcării modelelor: {model_loading_success}")
-
-# Creăm aplicația FastAPI cu logging
-debug_log("🌐 Creez aplicația FastAPI...")
-
-try:
-    app = FastAPI(
-        title="UCS Prediction API with Uncertainty Quantification - DEBUG VERSION",
-        description="Versiune de debugging pentru diagnoticarea problemelor de pornire",
-        version="2.0-debug"
-    )
-    debug_log("✅ Aplicația FastAPI creată cu succes")
-    
-    # Adăugăm middleware CORS cu logging
-    debug_log("🔧 Configurez CORS middleware...")
-    app.add_middleware(
-        CORSMiddleware,
-        allow_origins=["*"],  # Pentru debugging, permittem toate originile
-        allow_credentials=True,
-        allow_methods=["GET", "POST", "OPTIONS"],
-        allow_headers=["*"],
-    )
-    debug_log("✅ CORS middleware configurat")
-    
-except Exception as e:
-    debug_log(f"❌ EROARE la crearea aplicației FastAPI: {str(e)}", "ERROR")
-    debug_log(f"❌ Traceback: {traceback.format_exc()}", "ERROR")
+    return {
+        "status": "API is running",
+        "model_loaded": model is not None,
+        "model_type": "Random Forest Regressor" if model is not None else None,
+        "feature_order": FEATURE_ORDER.tolist() if model is not None else [],
+        "server_time": time.time()
+    }
 
-# Endpoint simplu de debugging pentru testarea stării sistemului
-@app.get("/debug-status")
-async def debug_status():
+# Model info endpoint
+@app.get("/model-info", summary="Model Information")
+async def model_info(model=Depends(get_model)):
     """
-    Endpoint special pentru debugging care returnează informații complete despre starea sistemului.
+    Returns detailed information about the model being used.
     """
-    debug_log("🔍 Cerere pentru debug-status")
-    
     try:
+        # Extract model parameters
+        model_params = model.get_params()
+        
         return {
-            "status": "API is running",
-            "timestamp": datetime.now().isoformat(),
-            "system_loaded": system_loaded,
-            "models_directory_exists": Path("/code/models_for_deployment").exists(),
-            "files_in_models_dir": list(Path("/code/models_for_deployment").iterdir()) if Path("/code/models_for_deployment").exists() else [],
-            "python_version": sys.version,
-            "current_directory": str(Path.cwd()),
-            "environment_variables": dict(os.environ),
+            "model_type": type(model).__name__,
+            "features": FEATURE_ORDER.tolist(),
+            "target": "UCS (kPa)",
+            "valid_ranges": {
+                "cement_perecent": {"min": 0, "max": 15, "units": "%"},
+                "curing_period": {"min": 0, "max": 90, "units": "days"},
+                "compaction_rate": {"min": 0.5, "max": 2, "units": "mm/min"}
+            },
+            "model_parameters": {
+                "n_estimators": model_params.get("n_estimators", None),
+                "max_depth": model_params.get("max_depth", None),
+                "min_samples_split": model_params.get("min_samples_split", None),
+                "min_samples_leaf": model_params.get("min_samples_leaf", None)
+            }
         }
     except Exception as e:
-        debug_log(f"❌ EROARE în debug-status: {str(e)}", "ERROR")
-        return {"error": str(e), "traceback": traceback.format_exc()}
+        raise HTTPException(status_code=500, detail=f"Error retrieving model information: {str(e)}")
 
-# Endpoint simplu pentru verificarea că aplicația răspunde
-@app.get("/")
+# Documentation endpoint
+@app.get("/", summary="API Documentation")
 async def root():
-    debug_log("🏠 Cerere pentru endpoint root")
-    return {"message": "UCS API Debug Version - System Running", "system_loaded": system_loaded}
+    """
+    Returns information about the API.
+    """
+    return {
+        "message": "Welcome to the UCS prediction API for cement-stabilized soils",
+        "endpoints": {
+            "predict": "/predict - Make UCS predictions",
+            "status": "/status - Check API status",
+            "model-info": "/model-info - Get model information"
+        },
+        "docs": "/docs - Swagger documentation",
+        "redoc": "/redoc - ReDoc documentation"
+    }
 
-# La sfârșit, confirmăm că modulul s-a încărcat complet
-debug_log("🎉 MODULUL app.py S-A ÎNCĂRCAT COMPLET!")
-debug_log(f"📊 Starea finală: system_loaded = {system_loaded}")
+# ValidationError exception handler
+@app.exception_handler(ValidationError)
+async def validation_exception_handler(request: Request, exc: ValidationError):
+    errors = []
+    for error in exc.errors():
+        message = error.get('msg', '')
+        if message.startswith("Value error, "):
+            message = message[12:]
+        
+        errors.append({
+            "loc": error.get('loc', []),
+            "msg": message,
+            "type": error.get('type', '')
+        })
+    
+    return JSONResponse(
+        status_code=422,
+        content={"detail": errors}
+    )