new push

app.py

@@ -52,14 +52,23 @@ class TrainingResponse(BaseModel):
     message: str
     details: Dict[str, Any]
 
+def are_models_available():
+    """Vérifie si tous les modèles nécessaires sont disponibles"""
+    required_files = ["model_profit.joblib", "model_drawdown.joblib", "model_params.joblib"]
+    return all((MODELS_DIR / file).exists() for file in required_files)
+
 def load_models():
     """Charge les modèles existants"""
     try:
+        if not are_models_available():
+            return None, None, None
+            
         model_profit = joblib.load(MODELS_DIR / "model_profit.joblib")
         model_drawdown = joblib.load(MODELS_DIR / "model_drawdown.joblib")
         model_params = joblib.load(MODELS_DIR / "model_params.joblib")
         return model_profit, model_drawdown, model_params
-    except:
+    except Exception as e:
+        print(f"Erreur lors du chargement des modèles : {str(e)}")
         return None, None, None
 
 @app.get("/")
@@ -79,11 +88,10 @@ async def health_check():
     """
     Endpoint pour vérifier l'état de l'API et des modèles
     """
-    model_profit, model_drawdown, model_params = load_models()
-    
+    models_available = are_models_available()
     return {
         "status": "healthy",
-        "models_loaded": all([model_profit, model_drawdown, model_params]),
+        "models_available": models_available,
         "models_path": str(MODELS_DIR),
         "available_endpoints": [
             "/train (POST) - Entraîner les modèles",
@@ -98,12 +106,22 @@ async def train_from_csv(file: UploadFile = File(...)) -> TrainingResponse:
     Endpoint pour entraîner les modèles à partir des données CSV
     """
     try:
-        # Lire le contenu du fichier
+        # Lire et valider le contenu du fichier
         content = await file.read()
         content_str = content.decode('utf-8')
         
         # Convertir en DataFrame
-        df = pd.read_csv(StringIO(content_str), parse_dates=['Date'], index_col='Date')
+        df = pd.read_csv(StringIO(content_str))
+        
+        # Vérifier les colonnes requises
+        required_columns = ['Date', 'Open', 'High', 'Low', 'Close']
+        if not all(col in df.columns for col in required_columns):
+            raise ValueError(f"Colonnes manquantes. Requis: {required_columns}")
+        
+        # Configurer l'index temporel
+        df['Date'] = pd.to_datetime(df['Date'])
+        df.set_index('Date', inplace=True)
+        
         print(f"Données reçues : {len(df)} lignes")
         
         # Prétraiter les données
@@ -145,18 +163,22 @@ async def predict(data: MarketData):
     Endpoint pour faire des prédictions avec les modèles entraînés
     """
     try:
+        # Vérifier si les modèles sont disponibles
+        if not are_models_available():
+            return {
+                "status": "error",
+                "message": "Modèles non disponibles",
+                "best_profit_strategy": "Ichimoku_ADX_Volatility_Signal",
+                "best_profit_signal": 0,
+                "best_drawdown_strategy": "BB_Stoch_ATR_Signal",
+                "best_drawdown_signal": 0
+            }
+        
         # Charger les modèles
         model_profit, model_drawdown, model_params = load_models()
         
-        if not all([model_profit, model_drawdown, model_params]):
-            raise HTTPException(
-                status_code=400,
-                detail="Modèles non disponibles. Veuillez d'abord entraîner les modèles."
-            )
-        
         # Préparer les features dans le bon ordre
-        features = model_params['features']
-        X = np.array([[
+        features = [
             data.Ichimoku_ADX_Volatility_Signal,
             data.BB_Stoch_ATR_Signal,
             data.Chikou_MACD_Pente_Signal,
@@ -165,14 +187,16 @@ async def predict(data: MarketData):
             data.ADX,
             data.Volatility_20,
             data.MACD
-        ]])
+        ]
+        
+        X = np.array(features).reshape(1, -1)
         
         # Faire les prédictions
-        profit_strategy_idx = model_profit.predict(X)[0]
-        drawdown_strategy_idx = model_drawdown.predict(X)[0]
+        profit_strategy_idx = int(model_profit.predict(X)[0])
+        drawdown_strategy_idx = int(model_drawdown.predict(X)[0])
         
         # Obtenir les noms des stratégies
-        strategies = model_params['strategies']
+        strategies = model_params["strategies"]
         
         # Récupérer les signaux correspondants
         signals = [
@@ -183,6 +207,7 @@ async def predict(data: MarketData):
         ]
         
         return {
+            "status": "success",
             "best_profit_strategy": strategies[profit_strategy_idx],
             "best_profit_signal": signals[profit_strategy_idx],
             "best_drawdown_strategy": strategies[drawdown_strategy_idx],
@@ -190,10 +215,16 @@ async def predict(data: MarketData):
         }
         
     except Exception as e:
-        raise HTTPException(
-            status_code=500,
-            detail=f"Erreur lors de la prédiction : {str(e)}"
-        )
+        print(f"Erreur lors de la prédiction : {str(e)}")
+        # Retourner une réponse par défaut en cas d'erreur
+        return {
+            "status": "error",
+            "message": str(e),
+            "best_profit_strategy": "Ichimoku_ADX_Volatility_Signal",
+            "best_profit_signal": 0,
+            "best_drawdown_strategy": "BB_Stoch_ATR_Signal",
+            "best_drawdown_signal": 0
+        }
 
 if __name__ == "__main__":
     import uvicorn