new push

app.py

@@ -7,14 +7,20 @@ import joblib
 import os
 from pathlib import Path
 from io import StringIO
-from typing import Dict, Any
+from typing import Dict, Any, Optional
 import json
+import logging
+
+# Configuration des logs
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
 # Import des fonctions de train_strategy_models.py
 from train_strategy_models import (
     preprocess_data,
     train_models,
-    save_models
+    save_models,
+    predict_best_strategy
 )
 
 # Créer l'application FastAPI
@@ -34,25 +40,42 @@ BASE_DIR = Path(__file__).resolve().parent
 MODELS_DIR = BASE_DIR / "models"
 MODELS_DIR.mkdir(exist_ok=True)
 
-print(f"Dossier de base : {BASE_DIR}")
-print(f"Dossier des modèles : {MODELS_DIR}")
+logger.info(f"Dossier de base : {BASE_DIR}")
+logger.info(f"Dossier des modèles : {MODELS_DIR}")
 
+# Mise à jour de la classe MarketData pour correspondre aux features
 class MarketData(BaseModel):
+    # Features continus
     RSI: float
     ADX: float
     Volatility_20: float
     MACD: float
+    # Signaux des stratégies
     Ichimoku_ADX_Volatility_Signal: int
     BB_Stoch_ATR_Signal: int
     Chikou_MACD_Pente_Signal: int
     ADX_Stoch_Volatility_MA_Signal: int
 
+    class Config:
+        schema_extra = {
+            "example": {
+                "RSI": 50.0,
+                "ADX": 25.0,
+                "Volatility_20": 0.001,
+                "MACD": 0.0,
+                "Ichimoku_ADX_Volatility_Signal": 0,
+                "BB_Stoch_ATR_Signal": 0,
+                "Chikou_MACD_Pente_Signal": 0,
+                "ADX_Stoch_Volatility_MA_Signal": 0
+            }
+        }
+
 class TrainingResponse(BaseModel):
     status: str
     message: str
     details: Dict[str, Any]
 
-def are_models_available():
+def are_models_available() -> bool:
     """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)
@@ -61,14 +84,16 @@ def load_models():
     """Charge les modèles existants"""
     try:
         if not are_models_available():
+            logger.warning("Modèles non disponibles")
             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")
+        logger.info("Modèles chargés avec succès")
         return model_profit, model_drawdown, model_params
     except Exception as e:
-        print(f"Erreur lors du chargement des modèles : {str(e)}")
+        logger.error(f"Erreur lors du chargement des modèles : {str(e)}")
         return None, None, None
 
 @app.get("/")
@@ -77,17 +102,17 @@ async def read_root():
         "message": "Strategy Selector API",
         "version": "1.0",
         "status": "running",
+        "models_available": are_models_available(),
         "endpoints": {
             "predict": "/predict (POST)",
+            "train": "/train (POST)",
             "health": "/health (GET)"
         }
     }
 
 @app.get("/health")
 async def health_check():
-    """
-    Endpoint pour vérifier l'état de l'API et des modèles
-    """
+    """Endpoint pour vérifier l'état de l'API et des modèles"""
     models_available = are_models_available()
     return {
         "status": "healthy",
@@ -102,10 +127,10 @@ async def health_check():
 
 @app.post("/train")
 async def train_from_csv(file: UploadFile = File(...)) -> TrainingResponse:
-    """
-    Endpoint pour entraîner les modèles à partir des données CSV
-    """
+    """Endpoint pour entraîner les modèles à partir des données CSV"""
     try:
+        logger.info(f"Réception du fichier : {file.filename}")
+        
         # Lire et valider le contenu du fichier
         content = await file.read()
         content_str = content.decode('utf-8')
@@ -115,26 +140,27 @@ async def train_from_csv(file: UploadFile = File(...)) -> TrainingResponse:
         
         # 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}")
+        missing_columns = [col for col in required_columns if col not in df.columns]
+        if missing_columns:
+            raise ValueError(f"Colonnes manquantes : {missing_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")
+        logger.info(f"Données reçues : {len(df)} lignes")
         
         # Prétraiter les données
         df_processed = preprocess_data(df)
-        print("Prétraitement terminé")
+        logger.info("Prétraitement terminé")
         
         # Entraîner les modèles
         model_profit, model_drawdown, features, strategies, split_info = train_models(df_processed)
-        print("Entraînement terminé")
+        logger.info("Entraînement terminé")
         
         # Sauvegarder les modèles
         save_models(model_profit, model_drawdown, features, strategies, split_info)
-        print("Modèles sauvegardés")
+        logger.info("Modèles sauvegardés")
         
         return TrainingResponse(
             status="success",
@@ -152,6 +178,7 @@ async def train_from_csv(file: UploadFile = File(...)) -> TrainingResponse:
         )
         
     except Exception as e:
+        logger.error(f"Erreur lors de l'entraînement : {str(e)}")
         raise HTTPException(
             status_code=500,
             detail=f"Erreur lors de l'entraînement : {str(e)}"
@@ -159,64 +186,47 @@ async def train_from_csv(file: UploadFile = File(...)) -> TrainingResponse:
 
 @app.post("/predict")
 async def predict(data: MarketData):
-    """
-    Endpoint pour faire des prédictions avec les modèles entraînés
-    """
+    """Endpoint pour faire des prédictions avec les modèles entraînés"""
     try:
+        logger.info("Réception d'une requête de prédiction")
+        
         # Vérifier si les modèles sont disponibles
         if not are_models_available():
+            logger.warning("Modèles non disponibles")
             return {
                 "status": "error",
-                "message": "Modèles non disponibles",
+                "message": "Modèles non disponibles - utilisation des valeurs par défaut",
                 "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()
-        
-        # Préparer les features dans le bon ordre
-        features = [
-            data.Ichimoku_ADX_Volatility_Signal,
-            data.BB_Stoch_ATR_Signal,
-            data.Chikou_MACD_Pente_Signal,
-            data.ADX_Stoch_Volatility_MA_Signal,
-            data.RSI,
-            data.ADX,
-            data.Volatility_20,
-            data.MACD
-        ]
-        
-        X = np.array(features).reshape(1, -1)
-        
-        # Faire les prédictions
-        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"]
-        
-        # Récupérer les signaux correspondants
-        signals = [
-            data.Ichimoku_ADX_Volatility_Signal,
-            data.BB_Stoch_ATR_Signal,
-            data.Chikou_MACD_Pente_Signal,
-            data.ADX_Stoch_Volatility_MA_Signal
-        ]
-        
+        # Créer un DataFrame avec une seule ligne
+        df = pd.DataFrame([{
+            'RSI': data.RSI,
+            'ADX': data.ADX,
+            'Volatility_20': data.Volatility_20,
+            'MACD': data.MACD,
+            'Ichimoku_ADX_Volatility_Signal': data.Ichimoku_ADX_Volatility_Signal,
+            'BB_Stoch_ATR_Signal': data.BB_Stoch_ATR_Signal,
+            'Chikou_MACD_Pente_Signal': data.Chikou_MACD_Pente_Signal,
+            'ADX_Stoch_Volatility_MA_Signal': data.ADX_Stoch_Volatility_MA_Signal
+        }])
+        
+        # Utiliser la fonction de prédiction
+        result = predict_best_strategy(df)
+        if result is None:
+            raise Exception("Erreur lors de la prédiction")
+        
+        logger.info(f"Prédiction réussie : {result}")
         return {
             "status": "success",
-            "best_profit_strategy": strategies[profit_strategy_idx],
-            "best_profit_signal": signals[profit_strategy_idx],
-            "best_drawdown_strategy": strategies[drawdown_strategy_idx],
-            "best_drawdown_signal": signals[drawdown_strategy_idx]
+            **result
         }
         
     except Exception as e:
-        print(f"Erreur lors de la prédiction : {str(e)}")
-        # Retourner une réponse par défaut en cas d'erreur
+        logger.error(f"Erreur lors de la prédiction : {str(e)}")
         return {
             "status": "error",
             "message": str(e),