Version propre de DeepVest

.ipynb_checkpoints/README-checkpoint.md

@@ -0,0 +1,14 @@
+---
+title: ProfilingAI
+emoji: 📉
+colorFrom: red
+colorTo: green
+sdk: streamlit
+sdk_version: 1.43.2
+app_file: app.py
+pinned: false
+license: mit
+short_description: 'Determine the investment profile '
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

README.md

@@ -0,0 +1,77 @@
+# DeepVest - Assistant d'Investissement Intelligent
+
+DeepVest est une IA personnalisée qui analyse en temps réel votre situation personnelle, financière et professionnelle pour proposer des stratégies d'investissement sur mesure qui s'adaptent dynamiquement aux événements de votre vie.
+
+## 🚀 Fonctionnalités
+
+- **Analyse multidimensionnelle de la situation personnelle**
+  - Analyse du profil personnel, familial et professionnel
+  - Évaluation des revenus, charges, dettes et patrimoine
+  - Prise en compte des préférences éthiques et de style de vie
+
+- **Plan d'investissement personnalisé en temps réel**
+  - Génération de plans d'investissement dynamiques et adaptatifs
+  - Recommandations sur la répartition des actifs (actions, obligations, immobilier, etc.)
+  - Ajustement automatique aux événements de vie (promotion, naissance, déménagement)
+
+- **Analyse des marchés et ajustement automatique**
+  - Surveillance continue des marchés financiers
+  - Adaptation aux conditions macroéconomiques
+  - Optimisation du portefeuille pour le rendement et la gestion des risques
+
+- **Simulateur d'objectifs de vie**
+  - Simulation d'événements futurs (achat immobilier, études, retraite anticipée)
+  - Ajustement des plans d'investissement pour atteindre ces objectifs
+
+- **Conseils sur les actifs traditionnels et alternatifs**
+  - Stratégies pour les actions, obligations et immobilier
+  - Intégration d'actifs alternatifs (crypto-monnaies, art, etc.)
+
+## 📊 Interface utilisateur
+
+DeepVest propose une interface intuitive et personnalisée permettant:
+- La création et la gestion de profils d'investisseur
+- Le suivi des performances de portefeuille
+- La simulation d'objectifs financiers
+- La visualisation des conditions de marché en temps réel
+
+## 🛠️ Installation
+
+```bash
+pip install -r requirements.txt
+```
+
+## 🚀 Démarrage
+
+```bash
+streamlit run app.py
+```
+
+## 🧠 Technologies utilisées
+
+- **Backend**: Python, scikit-learn, TensorFlow/PyTorch, pandas
+- **Frontend**: Streamlit, React pour les composants d'interface avancés
+- **Analyse de données**: Numpy, Pandas, yfinance
+- **IA/ML**: Modèles personnalisés pour l'analyse de profil et de marché
+
+## 📝 Exemples d'utilisation
+
+1. **Créer un profil d'investisseur**
+   - Remplir le formulaire avec vos informations personnelles et financières
+   - Obtenir une analyse détaillée de votre profil de risque et vos objectifs
+
+2. **Analyser un portefeuille existant**
+   - Entrer les actifs de votre portefeuille actuel
+   - Recevoir des recommandations d'optimisation
+
+3. **Simuler un objectif financier**
+   - Définir un objectif (retraite, achat immobilier, etc.)
+   - Explorer différents scénarios pour atteindre cet objectif
+
+## 📄 Licence
+
+[Licence MIT](LICENSE)
+
+## 👥 Contribution
+
+Les contributions sont les bienvenues! N'hésitez pas à ouvrir une issue ou soumettre une pull request.

app.py

@@ -0,0 +1,556 @@
+import streamlit as st
+import os
+import sys
+import asyncio
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+from datetime import datetime, timedelta
+from pathlib import Path
+
+# Ajouter le répertoire src au path pour l'importation des modules
+current_dir = Path(__file__).parent.absolute()
+sys.path.append(str(current_dir))
+
+# Import des modules DeepVest
+try:
+    from src.core.profiling import DeepVestConfig, LLMProfileAnalyzer, DeepVestProfiler
+except ImportError:
+    st.error("Impossible d'importer les modules DeepVest. Vérifiez que le dossier src est correctement structuré.")
+    
+    # Version simplifiée pour la démo si imports échoués
+    class DeepVestConfig:
+        def __init__(self, **kwargs):
+            for key, value in kwargs.items():
+                setattr(self, key, value)
+                
+    class LLMProfileAnalyzer:
+        def __init__(self, config):
+            self.config = config
+            
+        async def analyze_profile(self, data):
+            return {
+                "risk_score": data.get("risk_tolerance", 3)/5,
+                "investment_horizon": data.get("investment_horizon", 5),
+                "primary_goals": data.get("investment_goals", []),
+                "recommendations": [
+                    "Diversifier votre portefeuille",
+                    "Maintenir une épargne de sécurité",
+                    "Investir régulièrement"
+                ],
+                "explanation": "Analyse simulée pour la démonstration."
+            }
+            
+    class DeepVestProfiler:
+        def __init__(self, config):
+            self.config = config
+            self.analyzer = LLMProfileAnalyzer(config)
+            
+        async def create_profile(self, data):
+            analysis = await self.analyzer.analyze_profile(data)
+            profile = type('Profile', (), {
+                "id": "demo-profile",
+                "risk_tolerance": data.get("risk_tolerance", 3),
+                "investment_horizon": data.get("investment_horizon", 5),
+                "risk_score": analysis["risk_score"],
+                "investment_goals": data.get("investment_goals", []),
+                "llm_analysis_results": type('LLMResults', (), analysis)
+            })
+            return profile
+            
+        async def generate_investment_strategy(self, profile):
+            risk_score = getattr(profile, "risk_score", 0.5)
+            
+            # Allocation basée sur le score de risque
+            stocks = risk_score
+            bonds = (1 - risk_score) * 0.8
+            cash = (1 - risk_score) * 0.2
+            
+            allocation = {
+                'Actions': stocks,
+                'Obligations': bonds,
+                'Liquidités': cash
+            }
+            
+            return {
+                "risk_profile": {
+                    "score": risk_score,
+                    "category": "Dynamique" if risk_score > 0.6 else "Modéré" if risk_score > 0.4 else "Conservateur"
+                },
+                "asset_allocation": allocation,
+                "recommendations": [
+                    "Diversifier votre portefeuille selon votre profil de risque",
+                    "Maintenir une épargne de sécurité",
+                    "Investir régulièrement"
+                ]
+            }
+
+# Configurer la page Streamlit
+st.set_page_config(
+    page_title="DeepVest - IA d'Investissement Personnalisé",
+    page_icon="💼",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Titre et présentation
+st.title("DeepVest - Assistant d'Investissement Intelligent")
+st.markdown("""
+Cette plateforme analyse en temps réel votre situation personnelle, financière et professionnelle 
+pour vous proposer une stratégie d'investissement sur mesure qui s'adapte dynamiquement aux événements de votre vie.
+""")
+
+# Initialisation de la session state si elle n'existe pas déjà
+if 'profile' not in st.session_state:
+    st.session_state.profile = None
+if 'analyzer' not in st.session_state:
+    config = DeepVestConfig(
+        debug_mode=True,
+        log_prompts=True,
+        db_path="profiles_db"
+    )
+    st.session_state.analyzer = LLMProfileAnalyzer(config)
+    st.session_state.profiler = DeepVestProfiler(config)
+
+# Navigation par onglets
+tabs = st.tabs(["Profil Investisseur", "Analyse de Portefeuille", "Simulation d'Objectifs", "Marché en Temps Réel"])
+
+with tabs[0]:
+    st.header("Votre Profil Investisseur")
+    
+    # Formulaire de profil
+    with st.form("profile_form"):
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            st.subheader("Informations personnelles")
+            age = st.number_input("Âge", min_value=18, max_value=100, value=30)
+            annual_income = st.number_input("Revenu annuel (€)", min_value=0, value=50000)
+            monthly_savings = st.number_input("Épargne mensuelle (€)", min_value=0, value=500)
+            family_status = st.selectbox("Situation familiale", ["Célibataire", "Marié(e)", "Divorcé(e)", "Veuf/Veuve"])
+            dependents = st.number_input("Personnes à charge", min_value=0, max_value=10, value=0)
+            
+        with col2:
+            st.subheader("Profil d'investissement")
+            risk_tolerance = st.slider("Tolérance au risque", min_value=1, max_value=5, value=3, 
+                                       help="1: Très prudent, 5: Très dynamique")
+            investment_horizon = st.slider("Horizon d'investissement (années)", min_value=1, max_value=30, value=10)
+            financial_knowledge = st.slider("Connaissances financières", min_value=1, max_value=5, value=3,
+                                           help="1: Débutant, 5: Expert")
+            investment_goals = st.multiselect("Objectifs d'investissement", 
+                                             ["Retraite", "Achat immobilier", "Études des enfants", 
+                                              "Épargne générale", "Revenus passifs", "Croissance patrimoine"])
+            esg_preferences = st.checkbox("Préférences ESG (investissement responsable)")
+            
+        submitted = st.form_submit_button("Créer mon profil")
+    
+    if submitted:
+        with st.spinner("Analyse de votre profil en cours..."):
+            # Préparer les données du profil
+            profile_data = {
+                "age": age,
+                "annual_income": annual_income,
+                "monthly_savings": monthly_savings,
+                "marital_status": family_status,
+                "number_of_dependents": dependents,
+                "risk_tolerance": risk_tolerance,
+                "investment_horizon": investment_horizon,
+                "financial_knowledge": financial_knowledge,
+                "investment_goals": investment_goals,
+                "esg_preferences": esg_preferences,
+                "total_assets": 0,  # À compléter plus tard
+                "total_debt": 0,    # À compléter plus tard
+            }
+            
+            # Créer le profil
+            async def create_profile():
+                return await st.session_state.profiler.create_profile(profile_data)
+            
+            # Exécuter la fonction asynchrone
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            try:
+                st.session_state.profile = loop.run_until_complete(create_profile())
+                st.success("Profil créé avec succès!")
+            except Exception as e:
+                st.error(f"Erreur lors de la création du profil: {str(e)}")
+            finally:
+                loop.close()
+    
+    # Affichage du profil si disponible
+    if st.session_state.profile:
+        profile = st.session_state.profile
+        
+        st.subheader("Analyse de votre profil")
+        
+        col1, col2, col3 = st.columns(3)
+        with col1:
+            st.metric("Score de risque", f"{profile.risk_score:.2f}/1.00")
+        with col2:
+            st.metric("Horizon recommandé", f"{profile.investment_horizon} ans")
+        with col3:
+            st.metric("Capacité d'investissement", f"{monthly_savings} €/mois")
+        
+        # Affichage des recommandations si disponibles
+        if hasattr(profile, 'llm_analysis_results') and hasattr(profile.llm_analysis_results, 'recommendations'):
+            st.subheader("Recommandations personnalisées")
+            for i, rec in enumerate(profile.llm_analysis_results.recommendations[:5], 1):
+                st.write(f"{i}. {rec}")
+        
+        # Génération de la stratégie d'investissement
+        if st.button("Générer ma stratégie d'investissement"):
+            with st.spinner("Génération de la stratégie en cours..."):
+                async def generate_strategy():
+                    return await st.session_state.profiler.generate_investment_strategy(profile)
+                
+                loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(loop)
+                try:
+                    strategy = loop.run_until_complete(generate_strategy())
+                    
+                    # Affichage de la stratégie
+                    st.subheader("Stratégie d'investissement recommandée")
+                    
+                    # Affichage de l'allocation d'actifs
+                    st.write("**Allocation d'actifs recommandée:**")
+                    
+                    # Préparation des données pour le graphique
+                    labels = list(strategy['asset_allocation'].keys())
+                    sizes = [round(v * 100, 1) for v in strategy['asset_allocation'].values()]
+                    
+                    # Création du graphique
+                    fig, ax = plt.subplots(figsize=(8, 6))
+                    wedges, texts, autotexts = ax.pie(sizes, autopct='%1.1f%%', 
+                                                    textprops={'fontsize': 9, 'weight': 'bold'})
+                    ax.axis('equal')
+                    ax.legend(wedges, labels, loc="center left", bbox_to_anchor=(1, 0, 0.5, 1))
+                    st.pyplot(fig)
+                    
+                    # Affichage des recommandations
+                    st.write("**Recommandations clés:**")
+                    for i, rec in enumerate(strategy.get('recommendations', []), 1):
+                        st.write(f"{i}. {rec}")
+                except Exception as e:
+                    st.error(f"Erreur lors de la génération de la stratégie: {str(e)}")
+                finally:
+                    loop.close()
+
+with tabs[1]:
+    st.header("Analyse de Portefeuille")
+    
+    # Simulation d'un portefeuille existant
+    st.subheader("Votre portefeuille actuel")
+    
+    # Exemple de portefeuille pour démonstration
+    with st.expander("Ajouter des actifs à votre portefeuille"):
+        with st.form("portfolio_form"):
+            asset_type = st.selectbox("Type d'actif", ["Actions", "Obligations", "ETF", "Fonds", "Immobilier", "Autres"])
+            asset_name = st.text_input("Nom/Ticker")
+            asset_value = st.number_input("Valeur (€)", min_value=0.0, value=1000.0)
+            add_asset = st.form_submit_button("Ajouter")
+    
+    # Affichage d'un portefeuille exemple
+    portfolio_data = {
+        "Actions": {"AAPL": 5000, "MSFT": 3000, "GOOGL": 4000},
+        "ETF": {"VWCE": 10000, "AGGH": 5000},
+        "Liquidités": {"EUR": 2000}
+    }
+    
+    st.write("Portefeuille actuel:")
+    
+    # Création d'un DataFrame pour l'affichage
+    portfolio_df = []
+    for category, assets in portfolio_data.items():
+        for asset, value in assets.items():
+            portfolio_df.append({"Catégorie": category, "Actif": asset, "Valeur (€)": value})
+    
+    portfolio_df = pd.DataFrame(portfolio_df)
+    st.dataframe(portfolio_df)
+    
+    # Calcul des statistiques du portefeuille
+    total_value = portfolio_df["Valeur (€)"].sum()
+    st.metric("Valeur totale du portefeuille", f"{total_value:,.2f} €")
+    
+    # Graphique de répartition
+    st.subheader("Répartition du portefeuille")
+    
+    # Par catégorie
+    category_allocation = portfolio_df.groupby("Catégorie")["Valeur (€)"].sum()
+    category_allocation_pct = category_allocation / total_value * 100
+    
+    fig, ax = plt.subplots(figsize=(8, 6))
+    wedges, texts, autotexts = ax.pie(category_allocation_pct, autopct='%1.1f%%',
+                                      textprops={'fontsize': 9, 'weight': 'bold'})
+    ax.axis('equal')
+    ax.legend(wedges, category_allocation.index, loc="center left", bbox_to_anchor=(1, 0, 0.5, 1))
+    st.pyplot(fig)
+    
+    # Analyse de performance simulée
+    st.subheader("Performance historique simulée")
+    
+    # Données simulées pour la démonstration
+    dates = pd.date_range(start=datetime.now() - timedelta(days=365), end=datetime.now(), freq='D')
+    performance = 100 * (1 + np.cumsum(np.random.normal(0.0003, 0.01, size=len(dates))))
+    benchmark = 100 * (1 + np.cumsum(np.random.normal(0.0002, 0.008, size=len(dates))))
+    
+    performance_df = pd.DataFrame({
+        'Date': dates,
+        'Portefeuille': performance,
+        'Benchmark': benchmark
+    })
+    
+    st.line_chart(performance_df.set_index('Date'))
+    
+    # Recommandations d'optimisation
+    st.subheader("Recommandations d'optimisation")
+    
+    if st.session_state.profile:
+        st.write("Basé sur votre profil, nous recommandons les ajustements suivants:")
+        
+        st.markdown("""
+        1. **Rééquilibrage recommandé**: Réduire l'exposition aux actions technologiques
+        2. **Diversification géographique**: Augmenter l'exposition aux marchés émergents
+        3. **Allocation tactique**: Augmenter la part des obligations face aux incertitudes actuelles
+        """)
+    else:
+        st.info("Créez d'abord votre profil d'investisseur pour obtenir des recommandations personnalisées.")
+
+with tabs[2]:
+    st.header("Simulation d'Objectifs de Vie")
+    
+    st.subheader("Définissez vos objectifs financiers")
+    
+    # Sélection d'objectif
+    goal_type = st.selectbox("Type d'objectif", [
+        "Retraite", 
+        "Achat immobilier", 
+        "Études des enfants", 
+        "Création d'entreprise",
+        "Voyage/Sabbatique",
+        "Achat important"
+    ])
+    
+    # Configuration de l'objectif
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        amount = st.number_input("Montant cible (€)", min_value=0, value=100000)
+        years = st.slider("Horizon (années)", min_value=1, max_value=40, value=10)
+        
+    with col2:
+        monthly_contribution = st.number_input("Contribution mensuelle (€)", min_value=0, value=500)
+        initial_capital = st.number_input("Capital initial (€)", min_value=0, value=10000)
+    
+    # Calcul de simulation
+    if st.button("Simuler l'atteinte de l'objectif"):
+        if st.session_state.profile:
+            risk_profile = st.session_state.profile.risk_score
+        else:
+            risk_profile = 0.5  # Valeur par défaut
+        
+        # Estimation du taux de rendement en fonction du profil de risque
+        expected_return = 0.02 + risk_profile * 0.08  # Entre 2% et 10%
+        
+        # Simulation
+        periods = years * 12
+        future_value_formula = initial_capital * (1 + expected_return/12) ** periods
+        contribution_future_value = monthly_contribution * ((1 + expected_return/12) ** periods - 1) / (expected_return/12)
+        total_future_value = future_value_formula + contribution_future_value
+        
+        # Affichage des résultats
+        success_rate = min(100, total_future_value / amount * 100)
+        
+        col1, col2, col3 = st.columns(3)
+        
+        with col1:
+            st.metric("Montant projeté", f"{total_future_value:,.2f} €")
+        with col2:
+            st.metric("Objectif", f"{amount:,.2f} €")
+        with col3:
+            st.metric("Taux de réussite", f"{success_rate:.1f}%")
+        
+        # Graphique de progression
+        st.subheader("Projection de votre épargne dans le temps")
+        
+        # Données pour le graphique
+        months = range(0, periods + 1)
+        cumulative_values = []
+        
+        for t in months:
+            value = initial_capital * (1 + expected_return/12) ** t
+            contrib = monthly_contribution * ((1 + expected_return/12) ** t - 1) / (expected_return/12) if expected_return > 0 else monthly_contribution * t
+            cumulative_values.append(value + contrib)
+        
+        # Création d'un DataFrame pour le graphique
+        projection_df = pd.DataFrame({
+            'Mois': months,
+            'Valeur Projetée': cumulative_values,
+            'Objectif': [amount] * len(months)
+        })
+        
+        # Graphique
+        st.line_chart(projection_df.set_index('Mois'))
+        
+        # Recommandations
+        st.subheader("Recommandations pour atteindre votre objectif")
+        
+        if total_future_value < amount:
+            shortfall = amount - total_future_value
+            increased_contribution = monthly_contribution * amount / total_future_value
+            
+            st.warning(f"Avec les paramètres actuels, vous n'atteindrez pas complètement votre objectif. Il manquera environ {shortfall:,.2f} €.")
+            st.markdown(f"""
+            Pour atteindre votre objectif, vous pourriez:
+            1. **Augmenter votre contribution mensuelle** à environ {increased_contribution:.2f} €
+            2. **Allonger votre horizon d'investissement** de quelques années
+            3. **Ajuster votre profil de risque** pour viser un rendement plus élevé
+            """)
+        else:
+            surplus = total_future_value - amount
+            reduced_contribution = monthly_contribution * amount / total_future_value
+            
+            st.success(f"Félicitations ! Vous êtes sur la bonne voie pour atteindre votre objectif, avec un surplus potentiel de {surplus:,.2f} €.")
+            st.markdown(f"""
+            Options à considérer:
+            1. **Réduire votre contribution mensuelle** à environ {reduced_contribution:.2f} € tout en atteignant votre objectif
+            2. **Augmenter votre objectif** pour mettre à profit votre capacité d'épargne
+            3. **Réduire votre profil de risque** pour une approche plus conservatrice
+            """)
+
+with tabs[3]:
+    st.header("Marché en Temps Réel")
+    
+    # Tableau de bord du marché
+    st.subheader("Tableau de bord du marché")
+    
+    # Indices principaux (données simulées)
+    col1, col2, col3, col4 = st.columns(4)
+    
+    with col1:
+        st.metric("S&P 500", "4,782.21", "+0.42%")
+    with col2:
+        st.metric("CAC 40", "7,596.91", "-0.15%")
+    with col3:
+        st.metric("DAX", "16,752.23", "+0.21%")
+    with col4:
+        st.metric("Nikkei 225", "33,408.39", "-0.54%")
+    
+    # Conditions de marché
+    st.subheader("Conditions de marché actuelles")
+    
+    # Simulations de données pour démonstration
+    market_sentiment = 0.65  # 0 à 1
+    volatility_level = 0.4   # 0 à 1
+    market_regime = "Bull Market"  # Bull/Bear/Neutre
+    
+    col1, col2, col3 = st.columns(3)
+    
+    with col1:
+        st.write("**Sentiment de marché**")
+        sentiment_color = "green" if market_sentiment > 0.5 else "red"
+        st.markdown(f"<h3 style='text-align: center; color: {sentiment_color};'>{market_sentiment:.0%}</h3>", unsafe_allow_html=True)
+        
+    with col2:
+        st.write("**Niveau de volatilité**")
+        volatility_color = "red" if volatility_level > 0.5 else "green"
+        st.markdown(f"<h3 style='text-align: center; color: {volatility_color};'>{volatility_level:.0%}</h3>", unsafe_allow_html=True)
+        
+    with col3:
+        st.write("**Régime de marché**")
+        regime_color = "green" if market_regime == "Bull Market" else "red" if market_regime == "Bear Market" else "orange"
+        st.markdown(f"<h3 style='text-align: center; color: {regime_color};'>{market_regime}</h3>", unsafe_allow_html=True)
+    
+    # Analyse des actifs
+    st.subheader("Analyse des actifs en temps réel")
+    
+    # Sélection d'actif
+    asset_to_analyze = st.selectbox("Sélectionnez un actif à analyser", ["AAPL", "MSFT", "GOOGL", "AMZN", "TSLA", "VWCE", "AGGH"])
+    
+    if asset_to_analyze:
+        # Données simulées pour démonstration
+        asset_data = {
+            "price": 178.92,
+            "change": 0.87,
+            "change_percent": 0.49,
+            "volume": 58234567,
+            "pe_ratio": 28.5,
+            "dividend_yield": 0.51,
+            "market_cap": "2.82T",
+            "52w_high": 199.62,
+            "52w_low": 124.17
+        }
+        
+        # Affichage des données
+        col1, col2, col3 = st.columns(3)
+        
+        with col1:
+            st.metric("Prix", f"${asset_data['price']}", f"{asset_data['change_percent']}%")
+            st.metric("Volume", f"{asset_data['volume']:,}")
+            
+        with col2:
+            st.metric("P/E Ratio", f"{asset_data['pe_ratio']}")
+            st.metric("Rendement du dividende", f"{asset_data['dividend_yield']}%")
+            
+        with col3:
+            st.metric("Capitalisation", asset_data['market_cap'])
+            st.metric("52 semaines", f"${asset_data['52w_low']} - ${asset_data['52w_high']}")
+        
+        # Graphique de prix (données simulées)
+        st.subheader(f"Évolution du prix de {asset_to_analyze}")
+        
+        # Données simulées pour le graphique
+        dates = pd.date_range(start=datetime.now() - timedelta(days=90), end=datetime.now(), freq='D')
+        prices = asset_data['price'] * (1 + np.cumsum(np.random.normal(0, 0.015, size=len(dates))))
+        volumes = np.random.randint(30000000, 90000000, size=len(dates))
+        
+        asset_df = pd.DataFrame({
+            'Date': dates,
+            'Prix': prices,
+            'Volume': volumes
+        })
+        
+        # Graphique de prix
+        st.line_chart(asset_df.set_index('Date')['Prix'])
+        
+        # Recommandations
+        st.subheader
+
+        if st.session_state.profile:
+            # Recommandations personnalisées basées sur le profil
+            if st.session_state.profile.risk_score > 0.7:
+                recommendation = "Achat" if asset_data['change_percent'] > 0 else "Conserver"
+                reasoning = "Votre profil de risque élevé vous permet de profiter des opportunités de croissance de cet actif."
+            elif st.session_state.profile.risk_score < 0.3:
+                recommendation = "Conserver" if asset_data['change_percent'] > 0 else "Vente"
+                reasoning = "Votre profil de risque conservateur suggère une approche prudente avec cet actif."
+            else:
+                recommendation = "Conserver"
+                reasoning = "Cet actif correspond à votre profil de risque modéré et peut contribuer à la diversification de votre portefeuille."
+        else:
+            # Recommandation générique
+            recommendation = "Conserver"
+            reasoning = "Créez votre profil pour obtenir des recommandations personnalisées."
+        
+        st.write(f"**Recommandation**: {recommendation}")
+        st.write(f"**Justification**: {reasoning}")
+
+# Sidebar pour les filtres et les options
+with st.sidebar:
+    st.header("DeepVest")
+    st.image("https://img.icons8.com/color/96/000000/financial-growth.png", width=100)
+    
+    st.subheader("Options")
+    
+    # Filtres de marché
+    st.write("**Filtres de marché**")
+    market_filter = st.multiselect("Marchés", ["Actions", "Obligations", "Matières premières", "Crypto-monnaies", "Devises"])
+    region_filter = st.multiselect("Régions", ["Amérique du Nord", "Europe", "Asie-Pacifique", "Marchés émergents"])
+    
+    # Paramètres avancés
+    st.write("**Paramètres avancés**")
+    show_advanced = st.checkbox("Afficher les métriques avancées")
+    
+    # À propos
+    st.write("---")
+    st.write("*DeepVest - ©2025 - version 1.0*")
+    st.write("[Documentation](https://www.example.com) | [Support](mailto:support@deepvest.ai)")

requirements.txt

@@ -0,0 +1,51 @@
+# Core dependencies
+numpy>=1.21.0
+pandas>=1.3.0
+scipy>=1.7.0
+tqdm>=4.62.2
+python-dotenv>=0.19.0
+
+# Streamlit UI
+streamlit>=1.8.0
+
+# Data visualization
+matplotlib>=3.4.3
+seaborn>=0.11.2
+plotly>=5.6.0
+
+# Machine Learning & Deep Learning
+scikit-learn>=0.24.2
+xgboost>=1.5.0
+torch>=1.9.0
+transformers>=4.0.0
+sentencepiece
+protobuf
+
+# Financial data & analysis
+yfinance>=0.1.63
+finnhub-python>=2.4.12
+statsmodels>=0.12.2
+arch>=5.0.0
+cvxopt>=1.2.7
+
+# Reinforcement Learning
+gymnasium>=0.29.0
+
+# Web & Data processing
+aiohttp>=3.8.0
+websockets>=9.1
+asyncio>=3.4.3
+beautifulsoup4>=4.9.3
+newspaper3k>=0.2.8
+tweepy>=4.5.0
+
+# Development & testing
+pytest>=7.0.0
+pytest-asyncio>=0.18.0
+pytest-cov>=3.0.0
+jupyter>=1.0.0
+notebook>=6.4.0
+ipython>=7.26.0
+ipywidgets>=7.6.5
+PyYAML>=5.4.1
+questionary>=1.10.0

setup.py

@@ -0,0 +1,35 @@
+from setuptools import setup, find_packages
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+setup(
+    name="deepvest",
+    version="1.0.0",
+    author="Auteur",
+    author_email="email@example.com",
+    description="Assistant d'investissement personnalisé avec IA",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/yourusername/deepvest",
+    packages=find_packages(),
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    python_requires=">=3.8",
+    install_requires=[
+        "numpy>=1.21.0",
+        "pandas>=1.3.0",
+        "scipy>=1.7.0",
+        "matplotlib>=3.4.3",
+        "scikit-learn>=0.24.2",
+        "torch>=1.9.0",
+        "streamlit>=1.8.0",
+        "yfinance>=0.1.63",
+        "transformers>=4.0.0",
+        "aiohttp>=3.8.0",
+        "plotly>=5.6.0",
+    ],
+)

src/__init__.py

@@ -0,0 +1,90 @@
+# Version definition
+__version__ = '1.0.0'
+
+# Core imports - Using relative imports
+from .core.market_analyzer import (
+    MarketAnalyzer,
+    MarketAnalyzerImpl,
+    RiskAssessment
+)
+from .core.market_states import (
+    MarketConditions,
+    MarketRegime
+)
+from .core.portfolio_optimizer import (
+    PortfolioOptimizerImpl,
+    OptimizationConstraints
+)
+
+# Strategy imports
+from .strategies.alternative_assets import (
+    AlternativeAsset,
+    PrivateEquityInvestment,
+    RealEstateInvestment,
+    HedgeFundInvestment,
+    CryptoInvestment,
+    AlternativeAssetsAnalyzer,
+    AlternativeAssetsPortfolio
+)
+from .strategies.dynamic_allocator import (
+    MarketState,
+    DynamicAssetAllocationEnv,
+    DynamicAssetAllocator,
+    DynamicPortfolioManager,
+    DQNNetwork
+)
+from .strategies.alternative_assets_utils import create_alternative_assets_portfolio
+
+# Analysis imports
+from .analysis.backtest_engine import (
+    BacktestEngine,
+    BacktestConfig,
+    BacktestResult,
+    ValidationFramework
+)
+
+# Monitoring imports
+from .monitoring.realtime_monitor import (
+    RealTimeMonitor,
+    WebSocketDataHandler,
+    PortfolioAlert,
+    RebalanceSignal
+)
+
+__all__ = [
+    # Core components
+    'MarketAnalyzer',
+    'MarketAnalyzerImpl',
+    'MarketConditions',
+    'MarketRegime',
+    'RiskAssessment',
+    'PortfolioOptimizerImpl',
+    'OptimizationConstraints',
+    
+    # Strategy components
+    'AlternativeAsset',
+    'PrivateEquityInvestment',
+    'RealEstateInvestment',
+    'HedgeFundInvestment',
+    'CryptoInvestment',
+    'AlternativeAssetsAnalyzer',
+    'AlternativeAssetsPortfolio',
+    'create_alternative_assets_portfolio',
+    'MarketState',
+    'DynamicAssetAllocationEnv',
+    'DynamicAssetAllocator',
+    'DynamicPortfolioManager',
+    'DQNNetwork',
+    
+    # Analysis components
+    'BacktestEngine',
+    'BacktestConfig',
+    'BacktestResult',
+    'ValidationFramework',
+    
+    # Monitoring components
+    'RealTimeMonitor',
+    'WebSocketDataHandler',
+    'PortfolioAlert',
+    'RebalanceSignal'
+]

src/analysis/__init__.py

@@ -0,0 +1,29 @@
+# src/analysis/__init__.py
+
+from .backtest_engine import (
+    BacktestEngine,
+    BacktestConfig,
+    BacktestResult,
+    ValidationFramework
+)
+
+from .ml_analyzer import (    # Ajoutez ces imports
+    MLEnhancedAnalyzer,
+    MarketRegimeClassifier,
+    SentimentAnalyzer,
+    MarketImpactPredictor,
+    AlternativeDataAnalyzer
+)
+
+__all__ = [
+    'BacktestEngine',
+    'BacktestConfig',
+    'BacktestResult',
+    'ValidationFramework',
+    # Ajoutez les nouvelles classes
+    'MLEnhancedAnalyzer',
+    'MarketRegimeClassifier',
+    'SentimentAnalyzer',
+    'MarketImpactPredictor',
+    'AlternativeDataAnalyzer'
+]

src/analysis/backtest_engine.py

@@ -0,0 +1,2267 @@
+import numpy as np
+import pandas as pd
+from typing import List, Dict, Tuple, Optional, Any
+from dataclasses import dataclass
+from datetime import datetime, timedelta
+import statsmodels.api as sm
+from scipy import stats
+from sklearn.model_selection import TimeSeriesSplit
+from sklearn.mixture import GaussianMixture
+import matplotlib.pyplot as plt
+from concurrent.futures import ProcessPoolExecutor
+import warnings
+warnings.filterwarnings('ignore')
+
+# Imports from other modules
+from src.core import (
+    PortfolioOptimizerImpl, 
+    OptimizationConstraints, 
+    MarketAnalyzerImpl
+)
+from src.analysis.ml_analyzer import MLEnhancedAnalyzer
+from src.core.types import MarketAnalyzerProtocol
+from ..strategies.alternative_assets import AlternativeAssetsPortfolio
+from ..core.risk_metrics import EnhancedRiskMetrics
+from ..core.profiling import PersonalProfile
+from ..core.event_types import MarketUpdate, PortfolioAlert
+from ..core.types import MarketAnalyzerProtocol as MarketAnalyzer
+
+@dataclass
+class BacktestResult:
+    """Store backtest results"""
+    returns: pd.Series
+    positions: pd.DataFrame
+    trades: pd.DataFrame
+    metrics: Dict[str, float]
+    risk_metrics: Dict[str, float]
+    transaction_costs: pd.Series
+    turnover: pd.Series
+    drawdowns: pd.Series
+    attribution: Dict[str, pd.Series]
+    stress_test_results: Dict[str, float]
+    
+    def to_dict(self) -> Dict:
+        """Convert results to dictionary format"""
+        return {
+            'returns': self.returns.to_dict(),
+            'positions': self.positions.to_dict(),
+            'trades': self.trades.to_dict(),
+            'metrics': self.metrics,
+            'risk_metrics': self.risk_metrics,
+            'transaction_costs': self.transaction_costs.to_dict(),
+            'turnover': self.turnover.to_dict(),
+            'drawdowns': self.drawdowns.to_dict(),
+            'attribution': {k: v.to_dict() for k, v in self.attribution.items()},
+            'stress_test_results': self.stress_test_results
+        }
+
+@dataclass
+class BacktestConfig:
+    """Configuration for backtest"""
+    start_date: datetime
+    end_date: datetime
+    initial_capital: float
+    rebalance_frequency: str = "monthly"
+    transaction_cost_model: str = "percentage"
+    transaction_cost_params: Dict[str, float] = None
+    include_alternative_assets: bool = True
+    risk_free_rate: float = 0.02
+    benchmark_index: str = "SPY"
+    stress_periods: Dict[str, Tuple[datetime, datetime]] = None
+    
+    def __post_init__(self):
+        """Validate configuration after initialization"""
+        if self.transaction_cost_params is None:
+            self.transaction_cost_params = {'cost_rate': 0.001}
+            
+        if self.stress_periods is None:
+            self.stress_periods = {
+                'covid_crash': (
+                    datetime(2020, 2, 19),
+                    datetime(2020, 3, 23)
+                ),
+                'financial_crisis': (
+                    datetime(2008, 9, 1),
+                    datetime(2009, 3, 1)
+                )
+            }
+
+class BacktestEngine:
+    """Main backtesting engine with enhanced risk metrics and performance analysis"""
+    
+    def __init__(self, portfolio_optimizer, market_analyzer, backtest_engine, **kwargs):
+        self.backtest_engine = backtest_engine
+    
+        self.risk_metrics = EnhancedRiskMetrics(returns=None, prices=None)
+        if not isinstance(portfolio_optimizer, PortfolioOptimizerImpl):
+            raise TypeError("portfolio_optimizer must be instance of PortfolioOptimizerImpl")
+        if market_analyzer is None:
+            ml_analyzer = MLEnhancedAnalyzer()
+            self.market_analyzer = MarketAnalyzerImpl(ml_analyzer=ml_analyzer)
+        else:
+            self.market_analyzer = market_analyzer
+        self.alternative_assets_portfolio = alternative_assets_portfolio
+        self.risk_free_rate = risk_free_rate
+            
+         # État interne du backtest
+        self.current_positions = None
+        self.transaction_costs = None
+        self.current_portfolio_value = None
+        self.rebalance_dates = []
+            
+        # Cache pour les calculs
+        self._cache = {}
+
+    def _initialize_market_data(self, data: pd.DataFrame):
+        """Initialize market data properly"""
+        try:
+            # Vérifier les données
+            if data is None or data.empty:
+                raise ValueError("No market data provided")
+                
+            # Normaliser l'index temporel
+            data.index = pd.to_datetime(data.index).tz_localize(None)
+            
+            # Créer une copie pour éviter les modifications indésirables
+            self.market_data = data.copy()
+            
+            # Calculer les rendements
+            self.returns = self.market_data.pct_change().fillna(0)
+            
+            # S'assurer que les données sont chronologiquement ordonnées
+            self.market_data = self.market_data.sort_index()
+            self.returns = self.returns.sort_index()
+            
+            print("Market data initialized successfully")
+            return True
+            
+        except Exception as e:
+            print(f"Error initializing market data: {e}")
+            return False
+    
+
+    async def run_backtest(self,
+                    config: BacktestConfig,
+                    data: pd.DataFrame,
+                    constraints: OptimizationConstraints,
+                    alternative_data: Optional[pd.DataFrame] = None) -> BacktestResult:
+
+        # Normaliser les timezones
+        data.index = pd.to_datetime(data.index).tz_localize(None)
+        config.start_date = pd.to_datetime(config.start_date).tz_localize(None)
+        config.end_date = pd.to_datetime(config.end_date).tz_localize(None)
+        """Execute backtest with given configuration"""
+        try:
+            # Validation and initialization of market data
+            self._validate_data(data, config)
+            self._initialize_market_data(data)
+            market_conditions = await self.market_analyzer.analyze_market_conditions(data)
+            
+            # Initialize backtest state
+            self._initialize_backtest(config, data)
+            
+            # Execute simulation - Passer tous les arguments nécessaires
+            results = self._run_simulation(
+                config=config,
+                constraints=constraints,
+                alternative_data=alternative_data,
+                data=self.market_data  # Ajout de data ici
+            )
+            
+            # Calculate metrics
+            metrics = self._calculate_performance_metrics(results)
+            risk_metrics = self._calculate_risk_metrics(results)
+            attribution = self._perform_attribution_analysis(results)
+            
+            # Run stress tests
+            stress_results = self._run_stress_tests(results, config.stress_periods)
+            
+            return BacktestResult(
+                returns=results['returns'],
+                positions=results['positions'],
+                trades=results['trades'],
+                metrics=metrics,
+                risk_metrics=risk_metrics,
+                transaction_costs=results['transaction_costs'],
+                turnover=results['turnover'],
+                drawdowns=self._calculate_drawdowns(results['returns']),
+                attribution=attribution,
+                stress_test_results=stress_results
+            )
+            
+        except Exception as e:
+            print(f"Error during backtest execution: {e}")
+            raise
+    
+    async def _run_simulation(self, config: BacktestConfig, data: pd.DataFrame, constraints: OptimizationConstraints, alternative_data: Optional[pd.DataFrame] = None) -> Dict[str, pd.DataFrame]:
+        """Run the main simulation loop"""
+        try:
+            results = {
+                'positions': pd.DataFrame(index=data.index, columns=data.columns, dtype=float),
+                'trades': pd.DataFrame(index=data.index, columns=data.columns, dtype=float),
+                'returns': pd.Series(index=data.index, dtype=float),
+                'transaction_costs': pd.Series(index=data.index, dtype=float),
+                'turnover': pd.Series(index=data.index, dtype=float),
+                'portfolio_values': pd.Series(index=data.index, dtype=float)
+            }
+            
+            portfolio_value = config.initial_capital
+            previous_weights = np.zeros(len(data.columns))
+            
+            for date in data.index:
+                if self._should_rebalance(date, config.rebalance_frequency):
+                    # Get current market data slice
+                    current_data = data.loc[:date]
+                    
+                    try:
+                        # Analyze market conditions - MODIFICATION ICI
+                        market_conditions = await self.market_analyzer.analyze_market_conditions(current_data)
+                    except Exception as e:
+                        print(f"Market analysis error: {str(e)}")
+                        market_conditions = None
+    
+                    # Optimize portfolio
+                    try:
+                        new_weights = self.portfolio_optimizer.optimize_portfolio(constraints=constraints)
+                    except Exception as e:
+                        print(f"Optimization error: {str(e)}")
+                        new_weights = previous_weights
+                    
+                    # Calculate trades and costs
+                    trades = self._calculate_trades(previous_weights, new_weights, portfolio_value)
+                    costs = self._calculate_transaction_costs(trades, data.loc[date], config.transaction_cost_model, config.transaction_cost_params)
+                    
+                    portfolio_value *= (1 - costs)
+                    previous_weights = new_weights
+                    
+                    results['trades'].loc[date] = trades
+                    results['transaction_costs'].loc[date] = costs
+                    results['turnover'].loc[date] = np.sum(np.abs(trades)) / (2 * portfolio_value)
+                
+                # Calculate daily returns
+                daily_return = self._calculate_daily_returns(date, data, previous_weights)
+                portfolio_value *= (1 + daily_return)
+                
+                results['returns'].loc[date] = daily_return
+                results['positions'].loc[date] = previous_weights
+                results['portfolio_values'].loc[date] = portfolio_value
+            
+            return results
+            
+        except Exception as e:
+            print(f"Error in simulation: {str(e)}")
+            raise
+    
+    def _validate_data(self, data: pd.DataFrame, config: BacktestConfig) -> None:
+        """Validate input data for backtesting"""
+        try:
+            # Vérifier si les données sont vides
+            if data is None or data.empty:
+                raise ValueError("Data cannot be empty")
+                
+            # Vérifier et corriger l'ordre de l'index si nécessaire
+            if not data.index.is_monotonic_increasing:
+                print("Warning: Data index not monotonic, sorting data...")
+                data.sort_index(inplace=True)
+                
+            # Convertir les dates en datetime
+            data.index = pd.to_datetime(data.index)
+            config_start = pd.to_datetime(config.start_date)
+            config_end = pd.to_datetime(config.end_date)
+            
+            # Vérifier la couverture temporelle
+            if data.index[0] > config_start or data.index[-1] < config_end:
+                raise ValueError(
+                    f"Data range {data.index[0]} to {data.index[-1]} "
+                    f"does not cover backtest period {config_start} to {config_end}"
+                )
+            
+            # Vérifier les valeurs manquantes
+            if data.isnull().any().any():
+                missing_cols = data.columns[data.isnull().any()].tolist()
+                raise ValueError(f"Missing values found in columns: {missing_cols}")
+                
+        except Exception as e:
+            print(f"Error validating data: {str(e)}")
+            raise
+        
+    def _initialize_backtest(self, config: BacktestConfig, data: pd.DataFrame) -> None:
+        """Initialize backtest state"""
+        self.current_positions = pd.Series(0, index=data.columns)
+        self.transaction_costs = pd.Series(0, index=data.index)
+        self.current_portfolio_value = config.initial_capital
+        self._cache = {}  # Reset cache
+        
+        # Generate rebalancing dates
+        self.rebalance_dates = self._generate_rebalance_dates(
+            data.index, config.rebalance_frequency
+        )
+    
+    
+    def _clean_results(self, results: Dict[str, pd.DataFrame]) -> Dict[str, pd.DataFrame]:
+        """Nettoie les résultats de la simulation"""
+        try:
+            # Remplacer les inf et -inf par NaN
+            for key, value in results.items():
+                if isinstance(value, pd.DataFrame) or isinstance(value, pd.Series):
+                    results[key] = value.replace([np.inf, -np.inf], np.nan)
+                    
+            # Forward fill pour les positions
+            results['positions'] = results['positions'].fillna(method='ffill')
+            
+            # Remplacer les NaN restants par 0
+            for key, value in results.items():
+                if isinstance(value, pd.DataFrame) or isinstance(value, pd.Series):
+                    results[key] = value.fillna(0)
+                    
+            return results
+            
+        except Exception as e:
+            print(f"Error cleaning results: {e}")
+            return results
+    
+    def _get_sector_mapping(self, columns: pd.Index) -> Dict[str, List[str]]:
+        """Get sector mapping for assets"""
+        try:
+            return {'default': columns.tolist()}
+        except Exception as e:
+            print(f"Error in sector mapping: {str(e)}")
+            return {}
+
+    def _calculate_value_exposure(self, positions: pd.DataFrame) -> pd.Series:
+        """Calculate value factor exposure"""
+        try:
+            return positions.rolling(window=252).mean()
+        except Exception as e:
+            print(f"Error calculating value exposure: {str(e)}")
+            return pd.Series(index=positions.index)
+
+    def _calculate_growth_exposure(self, positions: pd.DataFrame) -> pd.Series:
+        """Calculate growth factor exposure"""
+        try:
+            return positions.pct_change().rolling(window=252).mean()
+        except Exception as e:
+            print(f"Error calculating growth exposure: {str(e)}")
+            return pd.Series(index=positions.index)
+
+    def _calculate_momentum_exposure(self, positions: pd.DataFrame) -> pd.Series:
+        """Calculate momentum factor exposure"""
+        try:
+            returns = positions.pct_change()
+            return returns.rolling(window=252).mean()
+        except Exception as e:
+            print(f"Error calculating momentum exposure: {str(e)}")
+            return pd.Series(index=positions.index)
+
+    def _calculate_quality_exposure(self, positions: pd.DataFrame) -> pd.Series:
+        """Calculate quality factor exposure"""
+        try:
+            returns = positions.pct_change()
+            return 1 / returns.rolling(window=63).std()
+        except Exception as e:
+            print(f"Error calculating quality exposure: {str(e)}")
+            return pd.Series(index=positions.index)
+
+    def _calculate_size_exposure(self, positions: pd.DataFrame) -> pd.Series:
+        """Calculate size factor exposure"""
+        try:
+            return positions.abs().sum(axis=1)
+        except Exception as e:
+            print(f"Error calculating size exposure: {str(e)}")
+            return pd.Series(index=positions.index)
+        
+    def _calculate_daily_returns(self, date: datetime, market_returns: pd.DataFrame, positions: np.ndarray) -> float:
+        """Calculate daily returns properly handling numpy arrays"""
+        try:
+            # Convert numpy array to pandas Series with proper index
+            positions_series = pd.Series(positions, index=market_returns.columns)
+            
+            # Get returns for the specific date
+            if isinstance(market_returns, pd.DataFrame):
+                daily_returns = market_returns.loc[date]
+            else:
+                return 0.0
+                
+            # Calculate weighted returns
+            return (positions_series * daily_returns).sum()
+            
+        except Exception as e:
+            print(f"Error calculating daily returns for {date}: {e}")
+            return 0.0
+
+    def _decompose_performance(self, returns: pd.Series, positions: pd.DataFrame) -> Dict[str, pd.Series]:
+        """Decompose portfolio performance"""
+        try:
+            decomposition = {
+                'market_effect': returns * positions.mean(),
+                'selection_effect': returns * (positions - positions.mean()),
+                'interaction_effect': returns * positions.diff()
+            }
+            return decomposition
+        except Exception as e:
+            print(f"Error decomposing performance: {str(e)}")
+            return {}    
+            
+    def _calculate_trades(self,
+                         new_weights: np.ndarray,
+                         portfolio_value: float,
+                         prices: pd.Series) -> np.ndarray:
+        """Calculate required trades to achieve new weights with advanced handling"""
+        current_values = self.current_positions * portfolio_value
+        target_values = new_weights * portfolio_value
+        
+        # Calculer les trades en nombre d'unités
+        trades = (target_values - current_values) / prices
+        
+        # Arrondir au nombre entier d'unités le plus proche
+        trades = np.round(trades, decimals=0)
+        
+        # Recalculer les poids après arrondissement
+        actual_values = trades * prices
+        actual_weights = actual_values / portfolio_value
+        
+        # Stocker les poids réels pour utilisation future
+        self._cache['actual_weights'] = actual_weights
+        
+        return trades
+
+    def _calculate_performance_metrics(self, results: Dict[str, pd.DataFrame]) -> Dict[str, float]:
+        """Calculate comprehensive performance metrics"""
+        try:
+            # Extraire et nettoyer les returns
+            returns = results['returns'].replace([np.inf, -np.inf], np.nan).dropna()
+            
+            if len(returns) == 0:
+                raise ValueError("No valid returns data")
+    
+            # Calculer les métriques de base
+            total_return = (1 + returns).prod() - 1
+            
+            metrics = {
+                'total_return': total_return,
+                'cagr': self._calculate_cagr(returns),
+                'volatility': returns.std() * np.sqrt(252),
+                'sharpe_ratio': self._calculate_sharpe_ratio(returns),
+                'sortino_ratio': self._calculate_sortino_ratio(returns),
+                'max_drawdown': self._calculate_max_drawdown(returns),
+                'win_rate': len(returns[returns > 0]) / len(returns),
+            }
+            
+            # Ajouter des métriques avancées seulement si elles peuvent être calculées
+            try:
+                metrics.update({
+                    'calmar_ratio': abs(metrics['cagr'] / metrics['max_drawdown']) if metrics['max_drawdown'] != 0 else np.inf,
+                    'profit_factor': abs(returns[returns > 0].sum() / returns[returns < 0].sum()) if returns[returns < 0].sum() != 0 else np.inf,
+                    'avg_win': returns[returns > 0].mean() if len(returns[returns > 0]) > 0 else 0,
+                    'avg_loss': returns[returns < 0].mean() if len(returns[returns < 0]) > 0 else 0
+                })
+            except Exception as e:
+                print(f"Warning: Could not calculate some advanced metrics: {e}")
+            
+            # Nettoyer les résultats finaux
+            metrics = {k: v for k, v in metrics.items() if not np.isnan(v) and not np.isinf(v)}
+            
+            return metrics
+            
+        except Exception as e:
+            print(f"Error calculating performance metrics: {e}")
+            return {}
+
+
+    def _calculate_cagr(self, returns: pd.Series) -> float:
+        """Calculate Compound Annual Growth Rate"""
+        if returns is None or len(returns) == 0:
+            return 0.0
+            
+        total_return = (1 + returns).prod()
+        n_years = len(returns) / 252  # 252 jours de trading par an
+        
+        if n_years > 0 and total_return > 0:
+            return (total_return ** (1/n_years)) - 1
+        else:
+            return 0.0
+
+    def _calculate_sortino_ratio(self, returns: pd.Series) -> float:
+        """Calculate Sortino ratio"""
+        try:
+            excess_returns = returns - self.risk_free_rate/252
+            negative_returns = excess_returns[excess_returns < 0]
+            downside_std = negative_returns.std() * np.sqrt(252)
+            
+            if downside_std == 0:
+                return 0.0
+            
+            return excess_returns.mean() * 252 / downside_std
+        except Exception as e:
+            print(f"Error calculating Sortino ratio: {e}")
+            return 0.0
+
+
+    def _calculate_var(self, returns: pd.Series, confidence: float = 0.95) -> float:
+        """Calculate Value at Risk"""
+        try:
+            return np.percentile(returns, (1 - confidence) * 100)
+        except Exception as e:
+            print(f"Error calculating VaR: {e}")
+            return 0.0
+        
+    def _get_benchmark_returns(self, results: Dict[str, pd.DataFrame]) -> pd.Series:
+        """Get benchmark returns series"""
+        returns = results['returns'] # returns est une Series, pas un DataFrame
+        # Retourner une Series vide si pas de benchmark
+        return pd.Series(dtype=float)   
+
+    def _get_factor_returns(self) -> pd.DataFrame:
+        """Récupère les facteurs de risque pour l'attribution de performance"""
+        try:
+            # Période d'analyse
+            dates = self.returns.index
+        
+            # Facteurs de base
+            factors = pd.DataFrame(index=dates)
+        
+            # Market Factor (Excess Return)
+            factors['MKT'] = self.returns.mean(axis=1) - self.risk_free_rate/252
+        
+           # Size Factor (SMB)
+            if hasattr(self, 'market_data') and 'market_cap' in self.market_data:
+                factors['SMB'] = self._calculate_size_factor()
+            else:
+                factors['SMB'] = pd.Series(0, index=dates)
+            
+            # Value Factor (HML)
+            if hasattr(self, 'market_data') and 'book_to_market' in self.market_data:
+                factors['HML'] = self._calculate_value_factor()
+            else:
+                factors['HML'] = pd.Series(0, index=dates)
+            
+            # Momentum Factor (MOM)
+            factors['MOM'] = self._calculate_momentum_factor()
+        
+            # Volatility Factor (VOL)
+            factors['VOL'] = self._calculate_volatility_factor()
+        
+            return factors
+        
+        except Exception as e:
+            print(f"Erreur dans le calcul des facteurs : {e}")
+            # Retourner un DataFrame minimal en cas d'erreur
+            return pd.DataFrame({'MKT': self.returns.mean(axis=1)})
+        
+    def _calculate_risk_metrics(self, results: Dict[str, pd.DataFrame]) -> Dict[str, float]:
+        """Calculate comprehensive risk metrics"""
+        try:
+            returns = results['returns'].replace([np.inf, -np.inf], np.nan).dropna()
+            
+            if len(returns) == 0:
+                raise ValueError("No valid returns data")
+    
+            risk_metrics = {}
+            
+            # 1. Métriques Value at Risk
+            try:
+                risk_metrics.update({
+                    'var_historical_95': self.risk_metrics.calculate_historical_var(returns, 0.95),
+                    'var_gaussian_95': self.risk_metrics.calculate_gaussian_var(returns, 0.95),
+                    'cvar_95': self.risk_metrics.calculate_cvar(returns, 0.95)
+                })
+            except Exception as e:
+                print(f"Error calculating VaR metrics: {e}")
+                risk_metrics.update({
+                    'var_historical_95': 0.0,
+                    'var_gaussian_95': 0.0,
+                    'cvar_95': 0.0
+                })
+    
+            # 2. Métriques de Volatilité
+            try:
+                risk_metrics.update({
+                    'volatility_annual': returns.std() * np.sqrt(252),
+                    'downside_deviation': self.risk_metrics.calculate_downside_deviation(returns),
+                    'upside_volatility': self.risk_metrics.calculate_upside_volatility(returns),
+                    'volatility_skew': self.risk_metrics.calculate_volatility_skew(returns)
+                })
+            except Exception as e:
+                print(f"Error calculating volatility metrics: {e}")
+                risk_metrics.update({
+                    'volatility_annual': 0.0,
+                    'downside_deviation': 0.0,
+                    'upside_volatility': 0.0,
+                    'volatility_skew': 0.0
+                })
+    
+            # 3. Métriques de Distribution
+            try:
+                risk_metrics.update({
+                    'skewness': returns.skew(),
+                    'kurtosis': returns.kurtosis(),
+                    'tail_ratio': self.risk_metrics.calculate_tail_ratio(returns),
+                    'jar_bera_stat': self.risk_metrics.calculate_jarque_bera(returns)
+                })
+            except Exception as e:
+                print(f"Error calculating distribution metrics: {e}")
+                risk_metrics.update({
+                    'skewness': 0.0,
+                    'kurtosis': 0.0,
+                    'tail_ratio': 1.0,
+                    'jar_bera_stat': 0.0
+                })
+    
+            # 4. Métriques de Marché
+            try:
+                risk_metrics.update({
+                    'beta': self.risk_metrics.calculate_beta(returns),
+                    'alpha': self.risk_metrics.calculate_alpha(returns),
+                    'tracking_error': self.risk_metrics.calculate_tracking_error(returns),
+                    'r_squared': self.risk_metrics.calculate_r_squared(returns)
+                })
+            except Exception as e:
+                print(f"Error calculating market metrics: {e}")
+                risk_metrics.update({
+                    'beta': 1.0,
+                    'alpha': 0.0,
+                    'tracking_error': 0.0,
+                    'r_squared': 0.0
+                })
+    
+            # 5. Métriques Avancées
+            try:
+                risk_metrics.update({
+                    'ulcer_index': self.risk_metrics.calculate_ulcer_index(returns),
+                    'pain_index': self.risk_metrics.calculate_pain_index(returns),
+                    'pain_ratio': self.risk_metrics.calculate_pain_ratio(returns),
+                    'burke_ratio': self.risk_metrics.calculate_burke_ratio(returns)
+                })
+            except Exception as e:
+                print(f"Error calculating advanced metrics: {e}")
+                risk_metrics.update({
+                    'ulcer_index': 0.0,
+                    'pain_index': 0.0,
+                    'pain_ratio': 0.0,
+                    'burke_ratio': 0.0
+                })
+    
+            # 6. Analyse des Régimes
+            try:
+                regime_metrics = self._calculate_regime_metrics(returns)
+                risk_metrics.update(regime_metrics)
+            except Exception as e:
+                print(f"Error calculating regime metrics: {e}")
+                risk_metrics.update({
+                    'regime_0': {'frequency': 0.0, 'avg_return': 0.0},
+                    'regime_1': {'frequency': 0.0, 'avg_return': 0.0},
+                    'regime_2': {'frequency': 0.0, 'avg_return': 0.0}
+                })
+    
+            # Nettoyer les résultats finaux
+            risk_metrics = {
+                k: v for k, v in risk_metrics.items() 
+                if not (isinstance(v, float) and (np.isnan(v) or np.isinf(v)))
+            }
+    
+            return risk_metrics
+            
+        except Exception as e:
+            print(f"Error calculating risk metrics: {e}")
+            return {}
+            
+    def _calculate_rolling_metrics(self, returns: pd.Series, window: int = 252) -> Dict[str, pd.Series]:
+        """Calculate rolling performance metrics"""
+        try:
+            rolling_metrics = {
+                'rolling_sharpe': self.risk_metrics.calculate_rolling_sharpe(window),
+                'rolling_sortino': self.risk_metrics.calculate_rolling_sortino(window),
+                'rolling_volatility': self.risk_metrics.calculate_rolling_volatility(window),
+                'rolling_beta': self.risk_metrics.calculate_rolling_beta(window),
+                'rolling_var': self.risk_metrics.calculate_rolling_var(window)
+            }
+            return rolling_metrics
+        except Exception as e:
+            print(f"Error calculating rolling metrics: {str(e)}")
+            raise
+
+    def _calculate_regime_metrics(self, returns: pd.Series) -> Dict[str, Dict[str, float]]:
+        """Calculate metrics under different market regimes"""
+        try:
+            # Identifier les régimes de marché
+            regimes = self._identify_market_regimes(returns)
+            regime_metrics = {}
+            
+            # Calculer les métriques pour chaque régime
+            for regime in np.unique(regimes):
+                regime_returns = returns[regimes == regime]
+                regime_metrics[f'regime_{regime}'] = {
+                    'frequency': len(regime_returns) / len(returns),
+                    'avg_return': regime_returns.mean(),
+                    'volatility': regime_returns.std() * np.sqrt(252),
+                    'sharpe': self.risk_metrics.calculate_regime_sharpe(regime_returns),
+                    'max_drawdown': self.risk_metrics.calculate_regime_drawdown(regime_returns),
+                    'win_rate': len(regime_returns[regime_returns > 0]) / len(regime_returns)
+                }
+                
+            return regime_metrics
+            
+        except Exception as e:
+            print(f"Error calculating regime metrics: {str(e)}")
+            raise
+
+
+    def _calculate_recovery_time(self, returns: pd.Series) -> int:
+        """Calcule le temps de récupération après un drawdown"""
+        if returns is None or len(returns) == 0:
+            return 0
+            
+        cumulative = (1 + returns).cumprod()
+        running_max = cumulative.expanding().max()
+        drawdowns = cumulative / running_max - 1
+        
+        recovery_periods = 0
+        in_drawdown = False
+        
+        for i, dd in enumerate(drawdowns):
+            if not in_drawdown and dd < 0:
+                in_drawdown = True
+                start_idx = i
+            elif in_drawdown and dd >= 0:
+                in_drawdown = False
+                recovery_periods = i - start_idx
+                
+        return recovery_periods
+            
+    def _identify_market_regimes(self, returns: pd.Series, n_regimes: int = 3) -> np.ndarray:
+        try:
+            # Préparer les features pour le GMM
+            features = self._prepare_regime_features(returns)
+            features = np.nan_to_num(features).reshape(-1, 1)  # Reshape en 2D
+            
+            gmm = GaussianMixture(n_components=n_regimes, random_state=42)
+            regimes = gmm.fit_predict(features)
+            
+            return regimes
+        except Exception as e:
+            print(f"Error identifying market regimes: {e}")
+            return np.zeros(len(returns))
+            
+    def _prepare_regime_features(self, returns: pd.Series) -> np.ndarray:
+        """Prepare features for regime detection"""
+        try:
+            window = 21  # fenêtre de 1 mois
+            
+            # Calculer les features
+            mean = returns.rolling(window=window).mean().fillna(0)
+            std = returns.rolling(window=window).std().fillna(0)
+            skew = returns.rolling(window=window).skew().fillna(0)
+            kurt = returns.rolling(window=window).kurt().fillna(0)
+            
+            # Combiner les features en matrice 2D
+            features = np.column_stack([
+                mean.values,
+                std.values,
+                skew.values,
+                kurt.values
+            ])
+            
+            return features
+            
+        except Exception as e:
+            print(f"Error preparing regime features: {e}")
+            return np.zeros((len(returns), 4))
+            
+    def _perform_attribution_analysis(self, results: Dict[str, pd.DataFrame]) -> Dict[str, pd.Series]:
+        """Perform detailed performance attribution analysis"""
+        try:
+            returns = results['returns']
+            positions = results['positions']
+            
+            attribution = {
+                # Attribution par facteurs
+                'factor_attribution': self._calculate_factor_attribution(returns, positions),
+                
+                # Attribution par secteur
+                'sector_attribution': self._calculate_sector_attribution(returns, positions),
+                
+                # Attribution par style
+                'style_attribution': self._calculate_style_attribution(returns, positions),
+                
+                # Attribution du risque
+                'risk_attribution': self._calculate_risk_attribution(returns, positions),
+                
+                # Décomposition de la performance
+                'performance_decomposition': self._decompose_performance(returns, positions)
+            }
+            
+            return attribution
+            
+        except Exception as e:
+            print(f"Error performing attribution analysis: {str(e)}")
+            raise
+            
+    def _calculate_factor_attribution(self, returns: pd.Series, positions: pd.DataFrame) -> pd.Series:
+        """
+        Calcule l'attribution de performance basée sur les facteurs
+        
+        Args:
+            returns: Rendements du portefeuille
+            positions: Positions du portefeuille
+        """
+        try:
+            # Charger les rendements des facteurs
+            factors = pd.DataFrame(index=returns.index)
+        
+            # Market Factor
+            factors['MKT'] = returns.fillna(0).mean() - self.risk_free_rate/252
+        
+            # Size Factor (SMB)
+            factors['SMB'] = positions.fillna(0).rolling(window=21).mean().std()
+        
+            # Value Factor (HML)
+            factors['HML'] = pd.Series(0, index=returns.index)  # placeholder
+        
+            # Momentum Factor (MOM)
+            factors['MOM'] = returns.fillna(0).rolling(window=252).mean()
+        
+            # Volatility Factor (VOL)
+            factors['VOL'] = returns.fillna(0).rolling(window=63).std()
+        
+            # Nettoyer les valeurs aberrantes
+            factors = factors.replace([np.inf, -np.inf], np.nan)
+            factors = factors.fillna(0)
+            returns = returns.fillna(0)
+        
+            # Régresser les rendements sur les facteurs
+            try:
+                model = sm.OLS(returns, factors).fit()
+                factor_contribution = pd.Series(
+                    model.params * factors.mean(),
+                    index=factors.columns
+                )
+            except:
+                factor_contribution = pd.Series(0, index=factors.columns)
+                
+            return factor_contribution
+            
+        except Exception as e:
+            print(f"Error calculating factor attribution: {str(e)}")
+            return pd.Series()
+            
+    def _calculate_sector_attribution(self, returns: pd.Series, positions: pd.DataFrame) -> pd.Series:
+        """Calculate sector-based performance attribution"""
+        try:
+            # Charger les mappings sectoriels
+            sector_mapping = self._get_sector_mapping(positions.columns)
+            sector_returns = {}
+            
+            # Calculer les contributions par secteur
+            for sector, assets in sector_mapping.items():
+                sector_positions = positions[assets].sum(axis=1)
+                sector_ret = (returns * sector_positions).sum()
+                sector_returns[sector] = {
+                    'total_return': sector_ret,
+                    'average_weight': sector_positions.mean(),
+                    'contribution': sector_ret * sector_positions.mean()
+                }
+            
+            return pd.DataFrame(sector_returns).T
+            
+        except Exception as e:
+            print(f"Error calculating sector attribution: {str(e)}")
+            raise
+
+    def _calculate_style_attribution(self, returns: pd.Series, positions: pd.DataFrame) -> pd.Series:
+        """Calculate investment style attribution (value, growth, momentum, etc.)"""
+        try:
+            # Définir les facteurs de style
+            style_factors = {
+                'value': self._calculate_value_exposure(positions),
+                'growth': self._calculate_growth_exposure(positions),
+                'momentum': self._calculate_momentum_exposure(positions),
+                'quality': self._calculate_quality_exposure(positions),
+                'size': self._calculate_size_exposure(positions)
+            }
+            
+            # Calculer l'attribution pour chaque style
+            style_attribution = {}
+            for style, exposure in style_factors.items():
+                style_return = (returns * exposure).sum()
+                style_attribution[style] = style_return
+                
+            return pd.Series(style_attribution)
+            
+        except Exception as e:
+            print(f"Error calculating style attribution: {str(e)}")
+            raise
+
+    def _calculate_risk_attribution(self, returns: pd.Series, positions: pd.DataFrame) -> pd.Series:
+        """Calculate risk-based performance attribution"""
+        try:
+            # Calculer la contribution au risque de chaque position
+            vol = returns.std() * np.sqrt(252)
+            pos_vol = positions.std() * np.sqrt(252)
+            risk_contribution = pos_vol * positions.corr() * vol
+        
+            return pd.Series(risk_contribution.sum(), index=positions.columns)
+        
+        except Exception as e:
+            print(f"Error calculating risk attribution: {str(e)}")
+            return pd.Series()
+    
+    def _calculate_transaction_costs(self,
+                               trades: np.ndarray,
+                               prices: pd.Series,
+                               cost_model: str,
+                               cost_params: Dict[str, float]) -> float:
+        """Calculate transaction costs based on specified model"""
+        if cost_model == "percentage":
+            return np.sum(np.abs(trades * prices)) * cost_params['cost_rate']
+        elif cost_model == "fixed":
+            return np.sum(np.abs(trades > 0)) * cost_params['fixed_cost']
+        else:
+            raise ValueError(f"Unknown transaction cost model: {cost_model}")
+
+
+    def _calculate_sharpe_ratio(self, returns: pd.Series) -> float:
+        """Calculate Sharpe ratio"""
+        try:
+            excess_returns = returns - self.risk_free_rate/252  # Conversion en taux journalier
+            if excess_returns.std() == 0:
+                return 0.0
+            return np.sqrt(252) * excess_returns.mean() / excess_returns.std()
+        except Exception as e:
+            print(f"Error calculating Sharpe ratio: {e}")
+            return 0.0
+        
+    def _calculate_liquidity_score(self, results: BacktestResult, profile: PersonalProfile) -> Dict[str, float]:
+        """
+        Calcule le score de liquidité du portefeuille par rapport au profil investisseur
+    
+        Args:
+            results: Résultats du backtest
+            profile: Profil de l'investisseur
+        
+        Returns:
+            Dict contenant les métriques de liquidité
+        """
+        try:
+            # Calculer la liquidité moyenne quotidienne
+            daily_volume = results.positions * self.current_portfolio_value
+        
+            # Calculer le ratio de liquidité (combien de jours pour liquider)
+            liquidation_days = daily_volume / (results.positions * 0.1)  # Assume 10% max volume quotidien
+        
+            # Calculer le coût de liquidité estimé
+            liquidity_cost = daily_volume * 0.0025  # Estimation du spread bid-ask
+        
+            # Évaluer l'adéquation avec les besoins de liquidité du profil
+            required_liquidity = profile.annual_income / 12  # Besoins mensuels
+        
+            liquidity_score = {
+                'average_days_to_liquidate': liquidation_days.mean().mean(),
+                'liquidity_cost_percent': (liquidity_cost.sum() / self.current_portfolio_value),
+                'liquidity_coverage_ratio': daily_volume.mean().sum() / required_liquidity,
+                'emergency_buffer_ratio': results.positions['cash'].iloc[-1] if 'cash' in results.positions else 0,
+                'overall_liquidity_score': self._calculate_overall_liquidity_score(
+                    liquidation_days.mean().mean(),
+                    required_liquidity,
+                    profile.risk_tolerance
+                )
+            }
+        
+            return liquidity_score
+        
+        except Exception as e:
+            print(f"Erreur dans le calcul du score de liquidité : {e}")
+            return {
+                'average_days_to_liquidate': 0,
+                'liquidity_cost_percent': 0,
+                'liquidity_coverage_ratio': 0,
+                'emergency_buffer_ratio': 0,
+                'overall_liquidity_score': 0
+            }
+        
+    def _calculate_overall_liquidity_score(self, 
+                                         days_to_liquidate: float,
+                                         required_liquidity: float,
+                                         risk_tolerance: int) -> float:
+        """ 
+        Calcule le score global de liquidité
+    
+        Args:
+            days_to_liquidate: Nombre moyen de jours pour liquider
+            required_liquidity: Liquidité requise
+            risk_tolerance: Tolérance au risque du profil (1-5)
+        
+        Returns:
+            Score entre 0 et 1
+        """
+        # Ajuster les seuils selon la tolérance au risque
+        max_acceptable_days = {
+            1: 2,   # Très conservateur
+            2: 5,   # Conservateur
+            3: 10,  # Modéré
+            4: 15,  # Dynamique
+            5: 20   # Agressif
+        }[risk_tolerance]
+    
+        # Calculer le score normalisé
+        days_score = max(0, 1 - (days_to_liquidate / max_acceptable_days))
+    
+        # Ajouter d'autres facteurs si nécessaire
+        # ...
+    
+        return days_score
+
+    def _run_stress_tests(self, results: Dict[str, pd.DataFrame], stress_periods: Dict[str, Tuple[datetime, datetime]]) -> Dict[str, float]:
+        """Run stress tests with proper timezone handling"""
+        try:
+            returns = results['returns']
+            
+            # Normaliser l'index temporel
+            if returns.index.tz is not None:
+                returns.index = returns.index.tz_localize(None)
+            
+            stress_results = {}
+            
+            for period_name, (start, end) in stress_periods.items():
+                try:
+                    # Convertir et normaliser les dates de la période
+                    start = pd.to_datetime(start).tz_localize(None)
+                    end = pd.to_datetime(end).tz_localize(None)
+                    
+                    if start > returns.index[-1] or end < returns.index[0]:
+                        print(f"No data for stress period {period_name}")
+                        continue
+                        
+                    start = max(start, returns.index[0])
+                    end = min(end, returns.index[-1])
+                    
+                    period_returns = returns[start:end]
+                    
+                    if len(period_returns) > 0:
+                        stress_results[period_name] = {
+                            'total_return': (1 + period_returns).prod() - 1,
+                            'max_drawdown': self._calculate_max_drawdown(period_returns),
+                            'volatility': period_returns.std() * np.sqrt(252),
+                            'worst_day': period_returns.min(),
+                            'recovery_time': self._calculate_recovery_time(period_returns)
+                        }
+                        
+                except Exception as e:
+                    print(f"Error in stress period {period_name}: {e}")
+                    
+            return stress_results
+            
+        except Exception as e:
+            print(f"Error in stress tests: {e}")
+            return {}
+
+    def _run_historical_stress_tests(self, returns: pd.Series, stress_periods: Dict[str, Tuple[datetime, datetime]]) -> Dict[str, float]:
+        """Run historical stress tests"""
+        historical_results = {}
+        
+        # Vérifier d'abord si nous avons des données
+        if returns is None or len(returns) == 0:
+            print("Warning: No return data available for stress tests")
+            return historical_results
+    
+        # Obtenir la plage de dates disponible
+        data_start = returns.index.min()
+        data_end = returns.index.max()
+        
+        for period_name, (start, end) in stress_periods.items():
+            try:
+                # Convertir les dates
+                start = pd.to_datetime(start)
+                end = pd.to_datetime(end)
+                
+                # Vérifier si la période est dans notre plage de données
+                if start > data_end or end < data_start:
+                    print(f"Warning: Stress period {period_name} ({start} to {end}) outside available data range ({data_start} to {data_end})")
+                    continue
+                
+                # Ajuster la période si nécessaire
+                adjusted_start = max(start, data_start)
+                adjusted_end = min(end, data_end)
+                
+                # Gérer les fuseaux horaires de manière plus robuste
+                if returns.index.tz is not None:
+                    adjusted_start = adjusted_start.tz_localize(returns.index.tz)
+                    adjusted_end = adjusted_end.tz_localize(returns.index.tz)
+                
+                period_returns = returns.loc[adjusted_start:adjusted_end]
+                
+                # Vérifier si nous avons assez de données
+                if len(period_returns) < 5:  # minimum arbitraire de 5 points de données
+                    print(f"Warning: Insufficient data for stress period {period_name}")
+                    continue
+                
+                historical_results[period_name] = {
+                    'total_return': (1 + period_returns).prod() - 1,
+                    'max_drawdown': self.risk_metrics.calculate_max_drawdown(period_returns),
+                    'volatility': period_returns.std() * np.sqrt(252),
+                    'var_95': np.percentile(period_returns, 5),
+                    'worst_day': period_returns.min(),
+                    'recovery_days': self._calculate_recovery_time(period_returns)
+                }
+                
+                # Vérifier la validité des résultats
+                for key, value in historical_results[period_name].items():
+                    if np.isnan(value) or np.isinf(value):
+                        historical_results[period_name][key] = 0
+                        print(f"Warning: Invalid {key} value for period {period_name}")
+                
+            except Exception as e:
+                print(f"Error in stress period {period_name}: {str(e)}")
+                historical_results[period_name] = {
+                    'total_return': 0,
+                    'max_drawdown': 0,
+                    'volatility': 0,
+                    'var_95': 0,
+                    'worst_day': 0,
+                    'recovery_days': 0
+                }
+        
+        if not historical_results:
+            print("Warning: No valid stress test results generated")
+        
+        return historical_results
+
+    def _run_correlation_stress_tests(self, positions: pd.DataFrame) -> Dict[str, float]:
+        """
+        Run correlation stress tests on portfolio positions
+    
+        Args:
+            positions: Portfolio positions over time
+        
+        Returns:
+            Dictionary of correlation stress test results
+        """
+        try:
+            # Calculer la matrice de corrélation de base
+            base_corr = positions.corr()
+        
+            # Différents scénarios de stress sur les corrélations
+            stress_scenarios = {
+                'high_correlation': {
+                    'adjustment': 0.3,  # Augmentation des corrélations de 30%
+                    'floor': 0.3,      # Corrélation minimum
+                    'cap': 0.95        # Corrélation maximum
+                },
+                'correlation_breakdown': {
+                    'adjustment': -0.5,  # Diminution des corrélations de 50%
+                    'floor': -0.8,       # Corrélation minimum
+                    'cap': 0.2           # Corrélation maximum
+                }
+            }
+        
+            results = {}
+        
+            for scenario, params in stress_scenarios.items():
+                # Ajuster la matrice de corrélation
+                stressed_corr = base_corr + params['adjustment']
+                stressed_corr = np.clip(stressed_corr, params['floor'], params['cap'])
+                np.fill_diagonal(stressed_corr, 1.0)
+            
+                # Calculer le risque du portefeuille avec les nouvelles corrélations
+                weights = positions.iloc[-1]  # Utiliser les derniers poids
+                portfolio_risk = np.sqrt(
+                    weights @ stressed_corr @ weights * 
+                    (self.returns.std() * np.sqrt(252))**2
+                )
+            
+                results[scenario] = {
+                    'portfolio_risk': portfolio_risk,
+                    'diversification_score': 1 - (portfolio_risk / (weights * self.returns.std() * np.sqrt(252)).sum()),
+                    'max_correlation': stressed_corr.max(),
+                    'min_correlation': stressed_corr.min()
+                }
+            
+            return results
+        
+        except Exception as e:
+            print(f"Error in correlation stress tests: {str(e)}")
+            return {
+                'high_correlation': {
+                    'portfolio_risk': 0.0,
+                    'diversification_score': 0.0,
+                    'max_correlation': 0.0,
+                    'min_correlation': 0.0
+                }
+            }
+
+    def _run_hypothetical_stress_tests(self, returns: pd.Series) -> Dict[str, float]:
+        """Run hypothetical stress scenarios"""
+        scenarios = {
+            'market_crash': {'shock': -0.20, 'duration': 22},  # -20% sur un mois
+            'volatility_spike': {'vol_multiplier': 3, 'duration': 10},
+            'correlation_breakdown': {'correlation_shock': 0.8, 'duration': 15},
+            'liquidity_crisis': {'bid_ask_multiplier': 5, 'duration': 30}
+        }
+        
+        results = {}
+        for scenario_name, params in scenarios.items():
+            scenario_returns = self._simulate_scenario(returns, params)
+            results[scenario_name] = {
+                'max_loss': scenario_returns.min(),
+                'var_95': np.percentile(scenario_returns, 5),
+                'expected_shortfall': scenario_returns[scenario_returns < np.percentile(scenario_returns, 5)].mean(),
+                'recovery_time': self._estimate_recovery_time(scenario_returns)
+            }
+            
+        return results
+
+
+    def _run_monte_carlo_stress_tests(self, returns: pd.Series, n_simulations: int = 1000) -> Dict[str, float]:
+        """Run Monte Carlo stress tests"""
+        try:
+            # Ajuster un modèle GMM pour capturer les fat tails
+            gmm = GaussianMixture(n_components=2, random_state=42)
+            gmm.fit(returns.values.reshape(-1, 1))
+            
+            # Générer des scénarios
+            simulated_returns = []
+            for _ in range(n_simulations):
+                scenario = gmm.sample(n_samples=len(returns))[0].flatten()
+                simulated_returns.append(scenario)
+                
+            simulated_returns = np.array(simulated_returns)
+            
+            # Calculer les statistiques
+            results = {
+                'var_99': np.percentile(simulated_returns, 1),
+                'es_99': np.mean(simulated_returns[simulated_returns < np.percentile(simulated_returns, 1)]),
+                'max_drawdown_99': np.percentile([self._calculate_max_drawdown(sim) for sim in simulated_returns], 99),
+                'worst_case_loss': simulated_returns.min()
+            }
+            
+            return results
+            
+        except Exception as e:
+            print(f"Error running Monte Carlo stress tests: {str(e)}")
+            raise
+
+
+    def _validate_returns(self, returns: pd.Series) -> pd.Series:
+        """Validate and clean return data"""
+        if returns is None or len(returns) == 0:
+            return pd.Series()
+            
+        # Convertir en Series si nécessaire
+        if isinstance(returns, np.ndarray):
+            returns = pd.Series(returns)
+            
+        # Nettoyer les valeurs invalides
+        returns = returns.replace([np.inf, -np.inf], np.nan).dropna()
+        
+        return returns
+
+    def generate_report(self, results: BacktestResult, save_path: Optional[str] = None) -> Dict[str, Any]:
+        """Generate comprehensive backtest report"""
+        try:
+            report = {
+                'summary': self._generate_summary_metrics(results),
+                'detailed_analysis': self._generate_detailed_analysis(results),
+                'risk_analysis': self._generate_risk_analysis(results),
+                'attribution': self._generate_attribution_analysis(results),
+                'stress_tests': self._generate_stress_test_analysis(results)
+            }
+            
+            # Générer les visualisations
+            figures = self._generate_report_figures(results)
+            
+            if save_path:
+                self._save_report(report, figures, save_path)
+                
+            return report
+            
+        except Exception as e:
+            print(f"Error generating report: {str(e)}")
+            raise
+
+    def _generate_profile_performance_analysis(self, results: BacktestResult, profile: PersonalProfile) -> Dict[str, Any]:
+        """Generate profile-specific performance analysis"""
+        return self._calculate_profile_specific_metrics(results, profile)
+
+    def _generate_profile_risk_analysis(self, results: BacktestResult, profile: PersonalProfile) -> Dict[str, float]:
+        """Generate profile-specific risk analysis"""
+        return {
+            'risk_tolerance_alignment': self._calculate_risk_alignment(results.returns, profile),
+            'risk_adjusted_returns': results.metrics.get('sharpe_ratio', 0)
+        }
+
+    def _generate_goal_tracking_analysis(self, results: BacktestResult, profile: PersonalProfile) -> Dict[str, float]:
+        """Generate goal tracking analysis"""
+        try:
+            goal_tracking = {}
+            current_value = results.positions.sum().sum()
+            initial_value = self.initial_capital
+    
+            for goal in profile.investment_goals:
+                if isinstance(goal, str):
+                    # Si le goal est juste une chaîne de caractères
+                    progress = (current_value / initial_value) - 1
+                    goal_tracking[goal] = progress
+                elif isinstance(goal, dict):
+                    # Si le goal est un dictionnaire avec des détails
+                    target = goal.get('target_value', initial_value * 1.5)
+                    progress = (current_value / target)
+                    goal_tracking[goal['name']] = progress
+    
+            return goal_tracking
+    
+        except Exception as e:
+            print(f"Error in goal tracking analysis: {e}")
+            return {}
+
+    def _generate_recommendations(self, results: BacktestResult, profile: PersonalProfile) -> List[str]:
+        """
+        Génère des recommandations basées sur les résultats du backtest et le profil investisseur
+        
+        Args:
+            results: Résultats du backtest
+            profile: Profil de l'investisseur
+            
+        Returns:
+            Liste des recommandations
+        """
+        recommendations = []
+        
+        # 1. Vérification de l'alignement du risque
+        realized_vol = results.returns.std() * np.sqrt(252)
+        target_vol = {
+            1: 0.05, 2: 0.08, 3: 0.12, 4: 0.18, 5: 0.25
+        }[profile.risk_tolerance]
+        
+        if realized_vol > target_vol * 1.2:
+            recommendations.append("Le portefeuille présente un risque supérieur à votre profil. Considérez une réduction de l'exposition aux actifs risqués.")
+        elif realized_vol < target_vol * 0.8:
+            recommendations.append("Le portefeuille est plus conservateur que votre profil. Une augmentation mesurée du risque pourrait améliorer les rendements.")
+    
+        # 2. Vérification du drawdown
+        max_dd = results.risk_metrics.get('max_drawdown', 0)
+        max_acceptable_dd = -0.05 * profile.risk_tolerance
+        
+        if abs(max_dd) > abs(max_acceptable_dd):
+            recommendations.append("Les pertes maximales dépassent le seuil recommandé. Envisagez des stratégies de protection supplémentaires.")
+    
+        # 3. Vérification de la diversification
+        current_weights = results.positions.iloc[-1]
+        if current_weights.max() > 0.3:
+            recommendations.append("La concentration du portefeuille est élevée. Une meilleure diversification est recommandée.")
+    
+        # 4. Vérification de la performance vs objectifs
+        total_return = results.metrics.get('total_return', 0)
+        required_return = 0.07 + 0.02 * profile.risk_tolerance
+        
+        if total_return < required_return:
+            recommendations.append("La performance est inférieure aux objectifs. Une révision de la stratégie d'investissement pourrait être nécessaire.")
+    
+        # 5. Vérification de la liquidité
+        if hasattr(profile, 'liquidity_needs') and profile.liquidity_needs > 0:
+            liquidity_score = self._calculate_liquidity_score(results, profile)
+            if liquidity_score['overall_liquidity_score'] < 0.7:
+                recommendations.append("Le niveau de liquidité pourrait être insuffisant pour vos besoins. Considérez des actifs plus liquides.")
+    
+        # 6. Recommandations basées sur l'horizon d'investissement
+        if profile.investment_horizon > 10:
+            recommendations.append("Votre horizon long terme permet d'envisager une exposition plus importante aux actifs de croissance.")
+        elif profile.investment_horizon < 5:
+            recommendations.append("Compte tenu de votre horizon court terme, privilégiez la préservation du capital.")
+    
+        return recommendations
+
+    def _get_target_allocation(self, profile: PersonalProfile) -> Dict[str, float]:
+        """Get target asset allocation based on profile"""
+        try:
+            # Allocation de base selon le profil de risque
+            risk_level = profile.risk_tolerance
+            if risk_level == 1:  # Très conservateur
+                return {
+                    'bonds': 0.70,
+                    'stocks': 0.20,
+                    'cash': 0.10
+                }
+            elif risk_level == 2:  # Conservateur
+                return {
+                    'bonds': 0.60,
+                    'stocks': 0.30,
+                    'cash': 0.10
+                }
+            elif risk_level == 3:  # Modéré
+                return {
+                    'bonds': 0.40,
+                    'stocks': 0.50,
+                    'cash': 0.10
+                }
+            elif risk_level == 4:  # Dynamique
+                return {
+                    'bonds': 0.20,
+                    'stocks': 0.70,
+                    'cash': 0.10
+                }
+            else:  # Agressif
+                return {
+                    'bonds': 0.10,
+                    'stocks': 0.80,
+                    'cash': 0.10
+                }
+        except Exception as e:
+            print(f"Error getting target allocation: {e}")
+            return {'stocks': 1.0}  # Allocation par défaut
+
+    def _calculate_allocation_drift(self, results: BacktestResult, profile: PersonalProfile) -> Dict[str, float]:
+        """Calculate drift from target allocation"""
+        try:
+            target = self._get_target_allocation(profile)
+            current = results.positions.iloc[-1].to_dict()
+        
+            return {
+                asset: current.get(asset, 0) - target.get(asset, 0)
+                for asset in set(list(target.keys()) + list(current.keys()))
+            }
+        except Exception as e:
+            print(f"Error calculating allocation drift: {e}")
+            return {}
+
+    def _get_rebalancing_frequency(self, profile: PersonalProfile) -> str:
+        """Get appropriate rebalancing frequency"""
+        try:
+            if profile.risk_tolerance <= 2:
+                return "quarterly"
+            elif profile.risk_tolerance <= 4:
+                return "monthly"
+            else:
+                return "weekly"
+        except Exception as e:
+            print(f"Error getting rebalancing frequency: {e}")
+            return "monthly"
+
+    def _get_rebalancing_triggers(self, profile: PersonalProfile) -> Dict[str, float]:
+        """Get rebalancing trigger thresholds"""
+        try:
+            base_threshold = 0.05  # 5% de base
+            risk_adjustment = (profile.risk_tolerance - 3) * 0.01  # Ajustement selon le risque
+         
+            return {
+                'asset_drift': base_threshold + risk_adjustment,
+                'volatility_change': 0.20,
+                'correlation_change': 0.30
+            }
+        except Exception as e:
+            print(f"Error getting rebalancing triggers: {e}")
+            return {'asset_drift': 0.05}
+
+    def _calculate_stop_loss_levels(self, profile: PersonalProfile) -> Dict[str, float]:
+        """Calculate stop loss levels"""
+        try:
+            base_stop = 0.15  # 15% de base
+            risk_adjustment = (profile.risk_tolerance - 3) * 0.05
+        
+            return {
+                'portfolio': base_stop + risk_adjustment,
+                'individual_positions': (base_stop + risk_adjustment) * 1.5
+            }
+        except Exception as e:
+            print(f"Error calculating stop loss levels: {e}")
+            return {'portfolio': 0.15}
+
+    def _get_hedging_strategy(self, profile: PersonalProfile) -> Dict[str, Any]:
+        """Define hedging strategy"""
+        try:
+            if profile.risk_tolerance <= 2:
+                return {
+                    'use_hedging': True,
+                    'hedge_ratio': 0.3,
+                    'instruments': ['options', 'inverse_etfs']
+                }
+            elif profile.risk_tolerance <= 4:
+                return {
+                    'use_hedging': True,
+                    'hedge_ratio': 0.2,
+                    'instruments': ['options']
+                }
+            else:
+                return {
+                    'use_hedging': False,
+                    'hedge_ratio': 0.0,
+                    'instruments': []
+                }
+        except Exception as e:
+            print(f"Error getting hedging strategy: {e}")
+            return {'use_hedging': False}
+
+    def _get_factor_returns(self) -> pd.DataFrame:
+        """Récupère les rendements des facteurs pour l'analyse d'attribution"""
+        try:
+            # Créer une base de facteurs simple si pas de données externes
+            dates = self.returns.index
+            n_periods = len(dates)
+            
+            factors = pd.DataFrame(index=dates)
+            factors['Market'] = self.returns.mean(axis=1)
+            factors['Size'] = np.random.normal(0, 0.01, n_periods)  # Simulation simple
+            factors['Value'] = np.random.normal(0, 0.01, n_periods)
+            factors['Momentum'] = np.random.normal(0, 0.01, n_periods)
+            
+            return factors
+            
+        except Exception as e:
+            print(f"Erreur dans le calcul des rendements de facteurs : {e}")
+            return pd.DataFrame(index=self.returns.index)
+
+    def _get_risk_management_rules(self, profile: PersonalProfile) -> Dict[str, Any]:
+        """Obtient les règles de gestion des risques basées sur le profil"""
+        try:
+            return {
+                'stop_loss': self._calculate_stop_loss_levels(profile),
+                'hedging_strategy': self._get_hedging_strategy(profile),
+                'rebalancing_triggers': self._get_rebalancing_triggers(profile),
+                'risk_limits': {
+                    'max_drawdown': -0.05 * profile.risk_tolerance,
+                    'max_volatility': 0.05 * profile.risk_tolerance,
+                    'max_var': -0.02 * profile.risk_tolerance,
+                    'max_position_size': min(0.2 + 0.05 * profile.risk_tolerance, 0.4)
+                },
+                'diversification_rules': {
+                    'min_assets': max(5, 10 - profile.risk_tolerance),
+                    'max_sector_exposure': min(0.3 + 0.05 * profile.risk_tolerance, 0.5),
+                    'min_asset_classes': max(2, 4 - profile.risk_tolerance)
+                }
+            }
+        except Exception as e:
+            print(f"Error getting risk management rules: {e}")
+            # Retourner des règles par défaut en cas d'erreur
+            return {
+                'stop_loss': {'portfolio': 0.15, 'individual_positions': 0.25},
+                'risk_limits': {
+                    'max_drawdown': -0.15,
+                    'max_volatility': 0.20,
+                    'max_var': -0.10,
+                    'max_position_size': 0.30
+                }
+            }
+
+    def _calculate_diversification_metrics(self, results: BacktestResult) -> Dict[str, float]:
+        """Calculate diversification metrics"""
+        try:
+            positions = results.positions.iloc[-1]
+            returns = results.returns
+        
+            return {
+                'herfindahl_index': np.sum(positions ** 2),
+                'effective_n': 1 / np.sum(positions ** 2),
+                'correlation_score': 1 - abs(returns.corr().mean().mean())
+            }
+        except Exception as e:
+            print(f"Error calculating diversification metrics: {e}")
+            return {}
+
+    def _generate_summary_metrics(self, results: BacktestResult) -> Dict[str, Any]:
+        """Generate summary metrics for the report"""
+        return {
+            'performance_summary': {
+                'total_return': f"{results.metrics['total_return']:.2%}",
+                'annualized_return': f"{results.metrics['cagr']:.2%}",
+                'sharpe_ratio': f"{results.metrics['sharpe_ratio']:.2f}",
+                'max_drawdown': f"{results.metrics['max_drawdown']:.2%}",
+                'volatility': f"{results.metrics['volatility']:.2%}"
+            },
+            'risk_summary': {
+                'var_95': f"{results.risk_metrics['var_historical_95']:.2%}",
+                'beta': f"{results.risk_metrics['beta']:.2f}",
+                'correlation': f"{results.risk_metrics['r_squared']:.2f}",
+                'tracking_error': f"{results.risk_metrics['tracking_error']:.2%}"
+            },
+            'trading_summary': {
+                'turnover': f"{results.turnover.mean():.2%}",
+                'transaction_costs': f"{results.transaction_costs.sum():.2%}",
+                'win_rate': f"{results.metrics['win_rate']:.2%}"
+            }
+        }
+
+    def _simulate_scenario(self, returns: pd.Series, scenario_params: Dict) -> pd.Series:
+        """Simulate scenario based on given parameters"""
+        try:
+            simulated_returns = returns.copy()
+            
+            if 'shock' in scenario_params:
+                shock_value = scenario_params['shock']
+                duration = scenario_params.get('duration', 22)  # Default 1 month
+                simulated_returns.iloc[-duration:] *= (1 + shock_value)
+                
+            elif 'vol_multiplier' in scenario_params:
+                vol_mult = scenario_params['vol_multiplier']
+                simulated_returns *= vol_mult
+                
+            return simulated_returns
+            
+        except Exception as e:
+            print(f"Error in scenario simulation: {e}")
+            return returns
+
+    def _generate_report_figures(self, results: BacktestResult) -> Dict[str, plt.Figure]:
+        """Generate visualization figures for the report"""
+        figures = {}
+        
+        # Performance cumulative
+        fig_perf = plt.figure(figsize=(12, 6))
+        cum_returns = (1 + results.returns).cumprod()
+        plt.plot(cum_returns.index, cum_returns.values)
+        plt.title('Cumulative Performance')
+        figures['performance'] = fig_perf
+        
+        # Drawdowns
+        fig_dd = plt.figure(figsize=(12, 6))
+        plt.plot(results.drawdowns.index, results.drawdowns.values)
+        plt.title('Drawdown Analysis')
+        figures['drawdowns'] = fig_dd
+        
+        # Allocation au fil du temps
+        fig_alloc = plt.figure(figsize=(12, 6))
+        results.positions.plot(kind='area', stacked=True)
+        plt.title('Portfolio Allocation Over Time')
+        figures['allocation'] = fig_alloc
+        
+        # Risk Metrics Rolling
+        fig_risk = plt.figure(figsize=(12, 6))
+        risk_metrics = pd.DataFrame({
+            'Rolling Volatility': results.risk_metrics['rolling_volatility'],
+            'Rolling VaR': results.risk_metrics['rolling_var'],
+            'Rolling Beta': results.risk_metrics['rolling_beta']
+        })
+        risk_metrics.plot()
+        plt.title('Rolling Risk Metrics')
+        figures['risk'] = fig_risk
+        
+        return figures
+
+    def _save_report(self, report: Dict[str, Any], figures: Dict[str, plt.Figure], save_path: str):
+        """Save report and figures to files"""
+        try:
+            # Créer le dossier si nécessaire
+            os.makedirs(save_path, exist_ok=True)
+            
+            # Sauvegarder le rapport en JSON
+            with open(os.path.join(save_path, 'report.json'), 'w') as f:
+                json.dump(report, f, indent=4)
+                
+            # Sauvegarder les figures
+            for name, fig in figures.items():
+                fig.savefig(os.path.join(save_path, f'{name}.png'))
+                
+        except Exception as e:
+            print(f"Error saving report: {str(e)}")
+            raise
+
+    def run_profile_based_backtest(self,
+                                 profile: PersonalProfile,
+                                 data: pd.DataFrame,
+                                 alternative_data: Optional[pd.DataFrame] = None) -> BacktestResult:
+        """
+        Run backtest adapted to investor profile
+        """
+        try:
+            # Créer la configuration basée sur le profil
+            config = self._create_profile_based_config(profile)
+        
+            # Créer les contraintes basées sur le profil
+            constraints = self._create_profile_based_constraints(profile, len(data.columns))
+        
+            # Exécuter le backtest
+            results = self.run_backtest(config, data, constraints, alternative_data)
+        
+            # Ajouter les métriques spécifiques au profil
+            results.metrics.update(self._calculate_profile_specific_metrics(results, profile))
+        
+            return results
+        
+        except Exception as e:
+            print(f"Error in profile-based backtest: {str(e)}")
+            raise
+        
+    def _create_profile_based_config(self, profile: PersonalProfile) -> BacktestConfig:
+        """Create backtest configuration based on investor profile"""
+        rebalance_freq = {
+            1: "quarterly",  # Très faible risque
+            2: "monthly",    # Faible risque
+            3: "monthly",    # Risque moyen
+            4: "weekly",     # Risque élevé
+            5: "weekly"      # Très haut risque
+        }
+    
+        return BacktestConfig(
+            start_date=datetime.now() - timedelta(days=365*2),
+            end_date=datetime.now(),
+            initial_capital=profile.total_assets - profile.total_debt,
+            rebalance_frequency=rebalance_freq[profile.risk_tolerance],
+            transaction_cost_model="percentage",
+            transaction_cost_params={'cost_rate': 0.001},
+            include_alternative_assets=profile.risk_tolerance > 2
+        )
+
+    def _create_profile_based_constraints(self, 
+                                        profile: PersonalProfile, 
+                                        n_assets: int) -> OptimizationConstraints:
+        """Create optimization constraints based on investor profile"""
+        # Contraintes de base selon le niveau de risque
+        risk_based_constraints = {
+            1: {'max_weight': 0.15, 'min_bond_alloc': 0.60},
+            2: {'max_weight': 0.20, 'min_bond_alloc': 0.40},
+            3: {'max_weight': 0.25, 'min_bond_alloc': 0.20},
+            4: {'max_weight': 0.30, 'min_bond_alloc': 0.10},
+            5: {'max_weight': 0.35, 'min_bond_alloc': 0.00}
+        }
+    
+        constraints = risk_based_constraints[profile.risk_tolerance]
+    
+        return OptimizationConstraints(
+            min_weights=np.zeros(n_assets),
+            max_weights=np.ones(n_assets) * constraints['max_weight'],
+            asset_classes={
+                'bonds': list(range(n_assets // 3)),
+                'stocks': list(range(n_assets // 3, n_assets))
+            },
+            min_class_weights={'bonds': constraints['min_bond_alloc']},
+            max_class_weights={'stocks': 1 - constraints['min_bond_alloc']},
+            max_turnover=0.2 if profile.risk_tolerance <= 3 else 0.3
+        )
+
+    def _calculate_profile_specific_metrics(self, 
+                                         results: BacktestResult, 
+                                         profile: PersonalProfile) -> Dict[str, float]:
+        """Calculate additional metrics specific to investor profile"""
+        returns = results.returns
+    
+        # Métriques spécifiques au profil
+        profile_metrics = {
+            'risk_tolerance_alignment': self._calculate_risk_alignment(returns, profile),
+            'income_generation': self._calculate_income_metrics(returns, profile),
+            'goal_achievement': self._calculate_goal_progress(results, profile),
+            'liquidity_adequacy': self._calculate_liquidity_score(results, profile)
+        }
+    
+        return profile_metrics
+
+    def _calculate_risk_alignment(self, returns: pd.Series, profile: PersonalProfile) -> float:
+        """Calcule l'alignement entre le risque réel et le profil de risque"""
+        realized_vol = returns.std() * np.sqrt(252)
+        target_vol = {
+            1: 0.05,  # Très faible risque
+            2: 0.08,  # Faible risque
+            3: 0.12,  # Risque moyen
+            4: 0.18,  # Risque élevé
+            5: 0.25   # Très haut risque
+        }[profile.risk_tolerance]
+        
+        return 1 - min(abs(realized_vol - target_vol) / target_vol, 1)
+
+    def _calculate_income_metrics(self, returns: pd.Series, profile: PersonalProfile) -> Dict[str, float]:
+        """Calcule les métriques liées au revenu du portefeuille"""
+        if not hasattr(self, 'current_portfolio_value'):
+            self.current_portfolio_value = profile.total_assets - profile.total_debt
+            
+        annual_return = (1 + returns).prod() ** (252/len(returns)) - 1
+        
+        return {
+            'income_to_need_ratio': (self.current_portfolio_value * annual_return) / profile.annual_income,
+            'sustainable_withdrawal_rate': min(annual_return * 0.7, 0.04),
+            'income_stability': self._calculate_income_stability(returns)
+        }
+
+    def _calculate_goal_progress(self, results: BacktestResult, profile: PersonalProfile) -> Dict[str, float]:
+        """Évalue la progression vers les objectifs d'investissement"""
+        try:
+            current_value = results.positions.iloc[-1].sum()
+            initial_value = results.positions.iloc[0].sum()
+        
+            if initial_value == 0:
+                initial_value = self.current_portfolio_value  # Utiliser la valeur initiale du portfolio
+        
+            progress = {}
+            for goal in profile.investment_goals:
+                goal_progress = {
+                    'current_value': current_value,
+                    'progress_ratio': (current_value / initial_value - 1) if initial_value != 0 else 0,
+                    'time_to_goal': self._estimate_time_to_goal(
+                        current_value,
+                        target_value=initial_value * 1.5,  # exemple
+                        returns=results.returns
+                    )
+                }
+                progress[goal] = goal_progress
+            
+            return progress
+        
+        except Exception as e:
+            print(f"Error calculating goal progress: {str(e)}")
+            return {}
+
+    def _calculate_income_stability(self, returns: pd.Series) -> float:
+        """Calcule la stabilité des revenus générés"""
+        monthly_returns = returns.resample('M').sum()
+        return 1 - monthly_returns.std() / abs(monthly_returns.mean())
+
+    def _calculate_drawdowns(self, returns: pd.Series) -> pd.Series:
+        """Calculate drawdown series"""
+        if isinstance(returns, np.ndarray):
+            returns = pd.Series(returns)
+        cumulative_returns = (1 + returns).cumprod()
+        running_max = cumulative_returns.expanding().max()
+        drawdowns = cumulative_returns/running_max - 1
+        return drawdowns
+    
+    def _calculate_max_drawdown(self, returns: pd.Series) -> float:
+        """Calculate maximum drawdown"""
+        if isinstance(returns, np.ndarray):
+            returns = pd.Series(returns)
+        drawdowns = self._calculate_drawdowns(returns)
+        return drawdowns.min()
+
+    def _estimate_time_to_goal(self, current_value: float, target_value: float, returns: pd.Series) -> float:
+        """Estime le temps nécessaire pour atteindre un objectif"""
+        annual_return = (1 + returns).prod() ** (252/len(returns)) - 1
+        if annual_return <= 0:
+            return float('inf')
+        return np.log(target_value / current_value) / np.log(1 + annual_return)
+
+    def generate_profile_based_report(self,
+                                    results: BacktestResult,
+                                    profile: PersonalProfile) -> Dict[str, Any]:
+        """Generate comprehensive report including profile-specific analysis"""
+        try:
+            # Calculer les éléments du rapport
+            goal_tracking = {}
+            for goal in profile.investment_goals:
+                goal_name = goal if isinstance(goal, str) else goal.get('name')
+                progress = self._calculate_goal_progress(results)
+                goal_tracking[goal_name] = progress
+            
+            report = {
+                'profile_summary': {
+                    'risk_profile': f"Niveau {profile.risk_tolerance}/5",
+                    'horizon': f"{profile.investment_horizon} ans",
+                    'knowledge': f"Niveau {profile.financial_knowledge}/5",
+                    'stability': f"Niveau {profile.income_stability}/5"
+                },
+                'investment_strategy': {
+                    'current_allocation': results.positions.iloc[-1].to_dict(),
+                    'rebalancing_frequency': self._get_rebalancing_frequency(profile),
+                    'risk_management': self._get_risk_management_rules(profile)
+                },
+                'goal_tracking': goal_tracking,
+                'risk_analysis': {
+                    'realized_volatility': results.risk_metrics.get('volatility', 0),
+                    'max_drawdown': results.risk_metrics.get('max_drawdown', 0),
+                    'var_95': results.risk_metrics.get('var_95', 0)
+                },
+                'recommendations': self._generate_recommendations(results, profile)
+            }
+            
+            return report
+                
+        except Exception as e:
+            print(f"Error generating profile-based report: {str(e)}")
+            raise
+    
+    def _calculate_goal_progress(self, results: BacktestResult) -> float:
+        """Calcule la progression vers les objectifs"""
+        if not hasattr(results, 'returns'):
+            return 0.0
+            
+        cumulative_return = (1 + results.returns).prod() - 1
+        return cumulative_return
+    
+    def _calculate_goal_progress(self, results: BacktestResult) -> float:
+        """Calcule la progression vers les objectifs"""
+        if not hasattr(results, 'returns'):
+            return 0.0
+            
+        cumulative_return = (1 + results.returns).prod() - 1
+        return cumulative_return
+
+    def _generate_profile_summary(self, profile: PersonalProfile) -> pd.DataFrame:
+        """Generate summary of investor profile"""
+        # Créer des séries distinctes pour chaque section
+        risk_profile = pd.Series({
+            'Niveau de tolérance': profile.risk_tolerance,
+            'Horizon d\'investissement': profile.investment_horizon,
+            'Connaissance financière': profile.financial_knowledge
+        })
+    
+        financial_situation = pd.Series({
+            'Revenu annuel': profile.annual_income,
+            'Actifs totaux': profile.total_assets,
+            'Dette totale': profile.total_debt,
+            'Valeur nette': profile.total_assets - profile.total_debt
+        })
+    
+        # Créer un DataFrame avec les différentes sections
+        summary_df = pd.DataFrame({
+            'Profil de Risque': risk_profile,
+            'Situation Financière': financial_situation
+        })
+    
+        # Ajouter les objectifs d'investissement de manière formatée
+        if hasattr(profile, 'investment_goals'):
+            summary_df['Objectifs'] = pd.Series(profile.investment_goals)
+    
+        # Ajouter les contraintes si elles existent
+        if hasattr(profile, 'constraints'):
+            summary_df['Contraintes'] = pd.Series(profile.constraints)
+    
+        return summary_df
+
+    def _generate_strategy_summary(self, results: BacktestResult, profile: PersonalProfile) -> Dict[str, Any]:
+        """Generate summary of investment strategy"""
+        return {
+            'asset_allocation': {
+                'target_allocation': self._get_target_allocation(profile),
+                'current_allocation': results.positions.iloc[-1].to_dict(),
+                'allocation_drift': self._calculate_allocation_drift(results, profile)
+            },
+            'rebalancing_strategy': {
+                'frequency': self._get_rebalancing_frequency(profile),
+                'triggers': self._get_rebalancing_triggers(profile),
+                'last_rebalance': self.rebalance_dates[-1].strftime('%Y-%m-%d')
+            },
+            'risk_management': {
+                'stop_loss_levels': self._calculate_stop_loss_levels(profile),
+                'hedging_strategy': self._get_hedging_strategy(profile),
+                'diversification_metrics': self._calculate_diversification_metrics(results)
+            }
+        }
+
+    def _generate_profile_figures(self, results: BacktestResult, profile: PersonalProfile) -> Dict[str, plt.Figure]:
+        """Generate profile-specific visualizations"""
+        figures = {}
+        
+        # Goal Progress Tracking
+        fig_goals = plt.figure(figsize=(12, 6))
+        self._plot_goal_progress(results, profile, fig_goals)
+        figures['goal_progress'] = fig_goals
+        
+        # Risk Profile Alignment
+        fig_risk = plt.figure(figsize=(12, 6))
+        self._plot_risk_alignment(results, profile, fig_risk)
+        figures['risk_alignment'] = fig_risk
+        
+        # Income Generation
+        fig_income = plt.figure(figsize=(12, 6))
+        self._plot_income_analysis(results, profile, fig_income)
+        figures['income_analysis'] = fig_income
+        
+        # Portfolio Evolution vs Objectives
+        fig_evolution = plt.figure(figsize=(12, 6))
+        self._plot_portfolio_evolution(results, profile, fig_evolution)
+        figures['portfolio_evolution'] = fig_evolution
+        
+        return figures
+
+    def _plot_goal_progress(self, results: BacktestResult, profile: PersonalProfile, fig: plt.Figure):
+        """Plot progress towards investment goals"""
+        ax = fig.add_subplot(111)
+        
+        goal_progress = self._calculate_goal_progress(results, profile)
+        goals = list(goal_progress.keys())
+        progress_values = [progress['progress_ratio'] for progress in goal_progress.values()]
+        
+        ax.barh(goals, progress_values)
+        ax.axvline(x=0, color='k', linestyle='-', alpha=0.3)
+        ax.set_title('Progress Towards Investment Goals')
+        ax.set_xlabel('Progress Ratio')
+        
+        # Ajouter les annotations de temps restant
+        for i, goal in enumerate(goals):
+            time_to_goal = goal_progress[goal]['time_to_goal']
+            if time_to_goal != float('inf'):
+                ax.text(progress_values[i], i, f'{time_to_goal:.1f} years left', 
+                       va='center')
+
+    def _plot_risk_alignment(self, results: BacktestResult, profile: PersonalProfile, fig: plt.Figure):
+        """Plot risk alignment analysis"""
+        realized_vol = results.returns.std() * np.sqrt(252)
+        target_vol = {
+            1: 0.05, 2: 0.08, 3: 0.12, 4: 0.18, 5: 0.25
+        }[profile.risk_tolerance]
+        
+        ax = fig.add_subplot(111)
+        
+        # Plotting realized vs target volatility
+        dates = results.returns.index
+        rolling_vol = results.returns.rolling(window=63).std() * np.sqrt(252)
+        
+        ax.plot(dates, rolling_vol, label='Realized Volatility')
+        ax.axhline(y=target_vol, color='r', linestyle='--', label='Target Volatility')
+        
+        ax.set_title('Risk Profile Alignment Over Time')
+        ax.set_xlabel('Date')
+        ax.set_ylabel('Annualized Volatility')
+        ax.legend()
+
+    def _plot_income_analysis(self, results: BacktestResult, profile: PersonalProfile, fig: plt.Figure):
+        """Plot income generation analysis"""
+        ax = fig.add_subplot(111)
+        
+        # Calculate monthly income
+        monthly_income = results.returns * self.current_portfolio_value
+        monthly_income = monthly_income.resample('M').sum()
+        
+        # Plot income generation
+        ax.plot(monthly_income.index, monthly_income.values, label='Portfolio Income')
+        ax.axhline(y=profile.annual_income/12, color='r', linestyle='--', 
+                  label='Monthly Income Target')
+        
+        ax.set_title('Monthly Income Generation vs Target')
+        ax.set_xlabel('Date')
+        ax.set_ylabel('Monthly Income')
+        ax.legend()
+
+    def _plot_portfolio_evolution(self, results: BacktestResult, profile: PersonalProfile, fig: plt.Figure):
+        """Plot portfolio evolution against objectives"""
+        ax = fig.add_subplot(111)
+        
+        portfolio_values = (1 + results.returns).cumprod() * self.current_portfolio_value
+        
+        # Plot actual portfolio value
+        ax.plot(portfolio_values.index, portfolio_values.values, label='Portfolio Value')
+        
+        # Plot goal targets
+        for goal in profile.investment_goals:
+            if isinstance(goal, dict) and 'target_value' in goal:
+                ax.axhline(y=goal['target_value'], linestyle='--', 
+                          label=f"Goal: {goal['name']}")
+        
+        ax.set_title('Portfolio Evolution vs Goals')
+        ax.set_xlabel('Date')
+        ax.set_ylabel('Portfolio Value')
+        ax.legend()
+
+    def display_results(report: Dict, results: BacktestResult, profile: PersonalProfile):
+        plt.figure(figsize=(15, 10))
+        
+        # Performance du portefeuille
+        plt.subplot(221)
+        if hasattr(results, 'returns') and isinstance(results.returns, pd.Series):
+            cumulative_returns = (1 + results.returns).cumprod()
+            plt.plot(cumulative_returns.index, cumulative_returns.values)
+            plt.title('Performance Cumulative')
+            plt.grid(True)
+        
+        # Allocation des actifs
+        plt.subplot(222)
+        if hasattr(results, 'positions') and isinstance(results.positions, pd.DataFrame):
+            if not results.positions.empty:
+                results.positions.plot(kind='area', stacked=True, ax=plt.gca())
+                plt.title('Allocation des Actifs')
+                plt.grid(True)
+        
+        # Progression des objectifs
+        plt.subplot(223)
+        if 'goal_tracking' in report:
+            goal_progress = report['goal_tracking']
+            if isinstance(goal_progress, dict):
+                # Extraire les valeurs de progression
+                goals = []
+                values = []
+                for goal, data in goal_progress.items():
+                    if isinstance(data, dict) and 'progress_ratio' in data:
+                        goals.append(goal)
+                        values.append(data['progress_ratio'])
+                    elif isinstance(data, (int, float)):
+                        goals.append(goal)
+                        values.append(data)
+                
+                if goals and values:
+                    # Créer le graphique à barres
+                    y_pos = np.arange(len(goals))
+                    plt.bar(y_pos, values)
+                    plt.xticks(y_pos, goals, rotation=45, ha='right')
+                    plt.title('Progression vers les Objectifs')
+                    plt.grid(True)
+        
+        # Métriques
+        plt.subplot(224)
+        if hasattr(results, 'metrics'):
+            key_metrics = ['sharpe_ratio', 'sortino_ratio', 'max_drawdown']
+            metrics_values = [results.metrics.get(m, 0) for m in key_metrics]
+            plt.bar(range(len(key_metrics)), metrics_values)
+            plt.xticks(range(len(key_metrics)), key_metrics, rotation=45)
+            plt.title('Métriques Clés')
+            plt.grid(True)
+        
+        plt.tight_layout()
+        
+        # Affichage des statistiques
+        print("\n=== Profil Investisseur ===")
+        if isinstance(report.get('profile_summary'), pd.DataFrame):
+            print(report['profile_summary'])
+        
+        print("\n=== Statistiques Clés ===")
+        if hasattr(results, 'metric  s'):
+            for metric, value in results.metrics.items():
+                if isinstance(value, (int, float)) and not isinstance(value, bool):
+                    try:
+                        print(f"{metric}: {value:.2%}")
+                    except (ValueError, TypeError):
+                        print(f"{metric}: {value}")
+    
+        plt.show()
+
+    def _plot_portfolio_performance(results: BacktestResult):
+        """Crée les graphiques de performance"""
+        plt.figure(figsize=(12, 6))
+    
+        # Performance cumulative
+        cumulative_returns = (1 + results.returns).cumprod()
+        plt.plot(cumulative_returns.index, cumulative_returns.values)
+        plt.title('Performance Cumulative')
+        plt.xlabel('Date')
+        plt.ylabel('Valeur du Portefeuille')
+        plt.grid(True)
+        plt.show()
+
+        # Drawdowns
+        plt.figure(figsize=(12, 6))
+        plt.plot(results.drawdowns.index, results.drawdowns.values)
+        plt.title('Drawdowns')
+        plt.xlabel('Date')
+        plt.ylabel('Drawdown')
+        plt.grid(True)
+        plt.show()
+
+    def _plot_risk_metrics(results: BacktestResult):
+        """Crée les graphiques des métriques de risque"""
+        # Rolling volatility
+        if 'rolling_volatility' in results.risk_metrics:
+            plt.figure(figsize=(12, 6))
+            plt.plot(results.returns.index, results.risk_metrics['rolling_volatility'])
+            plt.title('Volatilité Glissante')
+            plt.xlabel('Date')
+            plt.ylabel('Volatilité')
+            plt.grid(True)
+            plt.show()
+
+        # Allocation des actifs
+        plt.figure(figsize=(12, 6))
+        results.positions.plot(kind='area', stacked=True)
+        plt.title('Allocation des Actifs')
+        plt.xlabel('Date')
+        plt.ylabel('Poids (%)')
+        plt.grid(True)
+        plt.show()
+
+
+    def _should_rebalance(self, date: datetime, config: Optional[str] = None) -> bool:
+        """Determine if portfolio should be rebalanced at given date
+        
+        Args:
+            date: Current date to check for rebalancing
+            config: Optional rebalancing frequency config
+            
+        Returns:
+            bool: True if rebalancing is needed, False otherwise
+        """
+        if self.rebalance_dates is None:
+            return False
+            
+        # Si une configuration est fournie, utilisez-la
+        if config is not None:
+            frequency = config
+        else:
+            frequency = "monthly"  # Fréquence par défaut
+            
+        # Vérifier si la date est une date de rebalancement selon la fréquence
+        if frequency == "daily":
+            return True
+        elif frequency == "weekly":
+            return date.weekday() == 0  # Lundi
+        elif frequency == "monthly":
+            return date.day == 1
+        elif frequency == "quarterly":
+            return date.day == 1 and date.month in [1, 4, 7, 10]
+            
+        return date in self.rebalance_dates
+
+    @staticmethod
+    def _estimate_recovery_time(returns: pd.Series) -> int:
+        """Estimate time to recover from drawdown"""
+        cum_returns = (1 + returns).cumprod()
+        running_max = cum_returns.expanding().max()
+        drawdowns = cum_returns/running_max - 1
+        
+        recovery_periods = []
+        in_drawdown = False
+        start_idx = 0
+        
+        for i, dd in enumerate(drawdowns):
+            if not in_drawdown and dd < 0:
+                in_drawdown = True
+                start_idx = i
+            elif in_drawdown and dd >= 0:
+                in_drawdown = False
+                recovery_periods.append(i - start_idx)
+                
+        return np.mean(recovery_periods) if recovery_periods else 0
+
+    @staticmethod
+    def _generate_rebalance_dates(dates: pd.DatetimeIndex, frequency: str) -> List[datetime]:
+        """Generate rebalancing dates based on frequency"""
+        if frequency == "daily":
+            return list(dates)
+        elif frequency == "weekly":
+            return list(dates[dates.weekday == 0])
+        elif frequency == "monthly":
+            return list(dates[dates.day == 1])
+        elif frequency == "quarterly":
+            return list(dates[(dates.month % 3 == 1) & (dates.day == 1)])
+        else:
+            raise ValueError(f"Unsupported rebalancing frequency: {frequency}")
+
+class ValidationFramework:
+    """Framework for comprehensive strategy validation"""
+    
+    def __init__(self, backtest_engine: BacktestEngine):
+        self.backtest_engine = backtest_engine
+        
+    def validate_strategy(self,
+                         config: BacktestConfig,
+                         data: pd.DataFrame,
+                         constraints: OptimizationConstraints) -> Dict[str, Any]:
+        """
+        Perform comprehensive strategy validation.
+        """
+        validation_results = {}
+        
+        # 1. In-sample backtesting
+        insample_results = self.backtest_engine.run_backtest(
+            config, data, constraints
+        )
+        validation_results['insample_results'] = insample_results
+        
+        # 2. Walk-forward analysis
+        walkforward_results = self.backtest_engine.run_walk_forward_analysis(
+            config, data, constraints
+        )
+        validation_results['walkforward_results'] = walkforward_results
+        
+        # 3. Monte Carlo simulation
+        monte_carlo_results = self.backtest_engine.run_monte_carlo_simulation(
+            config, data, constraints
+        )
+        validation_results['monte_carlo_results'] = monte_carlo_results
+        
+        return validation_results
+
+
+__all__ = [
+    'BacktestEngine',
+    'BacktestConfig',
+    'BacktestResult',
+    'ValidationFramework'
+]
+
+
+
+
+    
+
+    

src/analysis/enhanced_backtest.py

@@ -0,0 +1,228 @@
+# src/analysis/enhanced_backtest.py
+
+import pandas as pd
+import numpy as np
+from typing import Dict, List, Optional
+from datetime import datetime, timedelta
+from dataclasses import dataclass
+
+from src.models.signals import StrategySignal
+
+@dataclass
+class EnhancedBacktestResult:
+    """Résultats détaillés du backtest"""
+    returns: pd.Series
+    positions: pd.DataFrame
+    trades: pd.DataFrame
+    signals: pd.DataFrame
+    performance_metrics: Dict[str, float]
+    risk_metrics: Dict[str, float]
+    alternative_contribution: Dict[str, float]
+    signal_quality: Dict[str, float]
+
+class EnhancedBacktestEngine:
+    """Moteur de backtest avancé pour la stratégie améliorée"""
+    
+    def __init__(self, 
+                 enhanced_strategy,
+                 risk_manager,
+                 data_fetcher,
+                 initial_capital: float = 1_000_000):
+        self.strategy = enhanced_strategy
+        self.risk_manager = risk_manager
+        self.data_fetcher = data_fetcher
+        self.initial_capital = initial_capital
+        
+    async def run_enhanced_backtest(self,
+                                  symbols: List[str],
+                                  start_date: datetime,
+                                  end_date: datetime,
+                                  use_alternative_data: bool = True) -> EnhancedBacktestResult:
+        """Exécute un backtest complet avec données alternatives"""
+        try:
+            # Récupération des données
+            market_data = await self.data_fetcher.fetch_market_data(symbols, start_date, end_date)
+            
+            # Initialisation des structures de résultats
+            results = self._initialize_results(market_data.index, symbols)
+            portfolio_value = self.initial_capital
+            current_positions = {symbol: 0 for symbol in symbols}
+            
+            # Boucle principale du backtest
+            for date in market_data.index:
+                try:
+                    # 1. Récupération des données alternatives pour cette date
+                    if use_alternative_data:
+                        alternative_data = await self._get_historical_alternative_data(
+                            symbols, date
+                        )
+                    else:
+                        alternative_data = {}
+                    
+                    # 2. Génération des signaux
+                    signals = await self.strategy.generate_trade_signals(
+                        portfolio=current_positions,
+                        market_data=market_data.loc[:date],
+                        alternative_data=alternative_data
+                    )
+                    
+                    # 3. Exécution des trades
+                    trades = self._execute_signals(
+                        signals,
+                        current_positions,
+                        portfolio_value,
+                        market_data.loc[date]
+                    )
+                    
+                    # 4. Mise à jour du portefeuille
+                    portfolio_value, current_positions = self._update_portfolio(
+                        portfolio_value,
+                        current_positions,
+                        trades,
+                        market_data.loc[date]
+                    )
+                    
+                    # 5. Enregistrement des résultats
+                    self._record_results(
+                        results,
+                        date,
+                        portfolio_value,
+                        current_positions,
+                        trades,
+                        signals
+                    )
+                    
+                except Exception as e:
+                    print(f"Erreur pendant le backtest à la date {date}: {e}")
+                    continue
+            
+            # Calcul des métriques finales
+            return self._calculate_final_metrics(results, market_data)
+            
+        except Exception as e:
+            print(f"Erreur dans le backtest: {e}")
+            raise
+
+    def _initialize_results(self, dates: pd.DatetimeIndex, symbols: List[str]) -> Dict:
+        """Initialise les structures de données pour les résultats"""
+        return {
+            'portfolio_value': pd.Series(index=dates, dtype=float),
+            'positions': pd.DataFrame(index=dates, columns=symbols, dtype=float),
+            'trades': pd.DataFrame(columns=['symbol', 'type', 'size', 'price', 'cost']),
+            'signals': pd.DataFrame(columns=['symbol', 'direction', 'confidence', 'size']),
+            'alternative_signals': pd.DataFrame(columns=['symbol', 'signal_type', 'value'])
+        }
+
+    async def _get_historical_alternative_data(self,
+                                             symbols: List[str],
+                                             date: datetime) -> Dict:
+        """Récupère les données alternatives historiques"""
+        try:
+            # Satellite data
+            satellite_data = await self.data_fetcher.fetch_historical_satellite_data(
+                symbols, date
+            )
+            
+            # Social media data
+            social_data = await self.data_fetcher.fetch_historical_social_data(
+                symbols, date
+            )
+            
+            # Web traffic data
+            traffic_data = await self.data_fetcher.fetch_historical_traffic_data(
+                symbols, date
+            )
+            
+            return {
+                'satellite': satellite_data,
+                'social_media': social_data,
+                'web_traffic': traffic_data
+            }
+            
+        except Exception as e:
+            print(f"Erreur récupération données alternatives: {e}")
+            return {}
+
+    def _execute_signals(self,
+                        signals: List[StrategySignal],
+                        current_positions: Dict[str, float],
+                        portfolio_value: float,
+                        market_data: pd.Series) -> List[Dict]:
+        """Exécute les signaux de trading"""
+        trades = []
+        
+        for signal in signals:
+            try:
+                if signal.direction == 'buy':
+                    size = self._calculate_buy_size(
+                        signal, portfolio_value, current_positions
+                    )
+                    if size > 0:
+                        trades.append({
+                            'symbol': signal.symbol,
+                            'type': 'buy',
+                            'size': size,
+                            'price': market_data[signal.symbol],
+                            'cost': size * market_data[signal.symbol] * 0.001  # 0.1% de coût
+                        })
+                        
+                elif signal.direction == 'sell':
+                    size = self._calculate_sell_size(
+                        signal, current_positions
+                    )
+                    if size > 0:
+                        trades.append({
+                            'symbol': signal.symbol,
+                            'type': 'sell',
+                            'size': size,
+                            'price': market_data[signal.symbol],
+                            'cost': size * market_data[signal.symbol] * 0.001
+                        })
+                        
+            except Exception as e:
+                print(f"Erreur exécution signal {signal.symbol}: {e}")
+                continue
+                
+        return trades
+
+    def _calculate_final_metrics(self, results: Dict, market_data: pd.DataFrame) -> EnhancedBacktestResult:
+        """Calcule les métriques finales du backtest"""
+        try:
+            # Calcul des rendements
+            portfolio_returns = results['portfolio_value'].pct_change().dropna()
+            
+            # Métriques de performance
+            performance_metrics = {
+                'total_return': (results['portfolio_value'].iloc[-1] / self.initial_capital) - 1,
+                'annual_return': self._calculate_annual_return(portfolio_returns),
+                'sharpe_ratio': self._calculate_sharpe_ratio(portfolio_returns),
+                'max_drawdown': self._calculate_max_drawdown(portfolio_returns)
+            }
+            
+            # Métriques de risque
+            risk_metrics = self.risk_manager.calculate_risk_metrics(portfolio_returns)
+            
+            # Contribution des données alternatives
+            alternative_contribution = self._calculate_alternative_contribution(
+                results['signals'], results['alternative_signals']
+            )
+            
+            # Qualité des signaux
+            signal_quality = self._evaluate_signal_quality(
+                results['signals'], portfolio_returns
+            )
+            
+            return EnhancedBacktestResult(
+                returns=portfolio_returns,
+                positions=results['positions'],
+                trades=results['trades'],
+                signals=results['signals'],
+                performance_metrics=performance_metrics,
+                risk_metrics=risk_metrics,
+                alternative_contribution=alternative_contribution,
+                signal_quality=signal_quality
+            )
+            
+        except Exception as e:
+            print(f"Erreur calcul métriques finales: {e}")
+            raise

src/analysis/goal_simulator.py

@@ -0,0 +1,219 @@
+# src/analysis/goal_simulator.py
+
+import numpy as np
+import pandas as pd
+from typing import Dict, List, Optional
+from dataclasses import dataclass
+from datetime import datetime
+from ..core.profiling import PersonalProfile
+
+@dataclass
+class GoalSimulationResult:
+    """Résultat de la simulation d'un objectif"""
+    success_probability: float
+    required_monthly_investment: float
+    risk_assessment: Dict[str, float]
+    recommended_adjustments: List[str]
+    timeline: pd.DataFrame
+    stress_test_results: Dict[str, float]
+
+@dataclass
+class InvestmentGoal:
+    """Définition d'un objectif d'investissement"""
+    name: str
+    target_amount: float
+    timeframe: int  # en années
+    priority: int
+    current_progress: float
+    required_return: float
+
+class GoalSimulator:
+    """Simulateur d'objectifs financiers"""
+    
+    def __init__(self, market_analyzer, risk_manager):
+        self.market_analyzer = market_analyzer
+        self.risk_manager = risk_manager
+        self.monte_carlo_sims = 1000
+        
+    async def simulate_goal_achievement(self,
+                                      goal: InvestmentGoal,
+                                      current_portfolio: Dict,
+                                      personal_profile: PersonalProfile) -> GoalSimulationResult:
+        """Simule la réalisation d'un objectif financier"""
+        try:
+            # Générer les scénarios de marché
+            scenarios = self._generate_market_scenarios(
+                timeframe=goal.timeframe,
+                current_portfolio=current_portfolio,
+                profile=personal_profile
+            )
+            
+            # Calculer la probabilité de succès
+            success_prob = self._calculate_success_probability(
+                scenarios=scenarios,
+                goal=goal
+            )
+            
+            # Calculer l'investissement mensuel requis
+            required_investment = self._calculate_required_investment(
+                goal=goal,
+                scenarios=scenarios,
+                success_target=0.8  # 80% de probabilité de succès
+            )
+            
+            # Analyse de risque
+            risk_assessment = self._assess_goal_risks(
+                goal=goal,
+                scenarios=scenarios,
+                personal_profile=personal_profile
+            )
+            
+            # Recommandations d'ajustement
+            adjustments = self._generate_recommendations(
+                goal=goal,
+                success_prob=success_prob,
+                risk_assessment=risk_assessment,
+                personal_profile=personal_profile
+            )
+            
+            return GoalSimulationResult(
+                success_probability=success_prob,
+                required_monthly_investment=required_investment,
+                risk_assessment=risk_assessment,
+                recommended_adjustments=adjustments,
+                timeline=self._generate_timeline(scenarios, goal),
+                stress_test_results=self._run_stress_tests(scenarios, goal)
+            )
+            
+        except Exception as e:
+            print(f"Erreur dans la simulation de l'objectif: {e}")
+            raise
+
+    def _generate_market_scenarios(self,
+                                 timeframe: int,
+                                 current_portfolio: Dict,
+                                 profile: PersonalProfile) -> np.ndarray:
+        """Génère des scénarios de marché via Monte Carlo"""
+        try:
+            # Paramètres de simulation
+            n_months = timeframe * 12
+            n_sims = self.monte_carlo_sims
+            
+            # Générer les rendements mensuels
+            monthly_returns = np.random.normal(
+                loc=0.005,  # 6% annuel
+                scale=0.02,  # Volatilité mensuelle
+                size=(n_sims, n_months)
+            )
+            
+            # Ajuster les rendements selon le profil de risque
+            adjusted_returns = self._adjust_returns_for_risk_profile(
+                monthly_returns, profile
+            )
+            
+            # Générer les trajectoires de portefeuille
+            initial_value = sum(current_portfolio.values())
+            scenarios = np.zeros((n_sims, n_months))
+            
+            for i in range(n_sims):
+                scenarios[i] = initial_value * np.cumprod(1 + adjusted_returns[i])
+                
+            return scenarios
+            
+        except Exception as e:
+            print(f"Erreur dans la génération des scénarios: {e}")
+            raise
+
+    def _calculate_success_probability(self,
+                                    scenarios: np.ndarray,
+                                    goal: InvestmentGoal) -> float:
+        """Calcule la probabilité d'atteindre l'objectif"""
+        try:
+            # Valeurs finales des scénarios
+            final_values = scenarios[:, -1]
+            
+            # Nombre de scénarios atteignant l'objectif
+            success_count = np.sum(final_values >= goal.target_amount)
+            
+            return success_count / len(scenarios)
+            
+        except Exception as e:
+            print(f"Erreur dans le calcul de la probabilité de succès: {e}")
+            return 0.0
+
+    def _calculate_required_investment(self,
+                                    goal: InvestmentGoal,
+                                    scenarios: np.ndarray,
+                                    success_target: float) -> float:
+        """Calcule l'investissement mensuel nécessaire"""
+        try:
+            current_gap = goal.target_amount - goal.current_progress
+            months_remaining = goal.timeframe * 12
+            
+            # Calculer le taux de rendement moyen des scénarios
+            avg_return = np.mean(np.diff(scenarios) / scenarios[:, :-1])
+            
+            # Formule PMT modifiée pour tenir compte du risque
+            r = (1 + avg_return) ** (1/12) - 1  # Taux mensuel
+            required_monthly = (current_gap * r) / ((1 + r) ** months_remaining - 1)
+            
+            # Ajouter une marge de sécurité
+            safety_margin = 1.1  # 10% de marge
+            return required_monthly * safety_margin
+            
+        except Exception as e:
+            print(f"Erreur dans le calcul de l'investissement requis: {e}")
+            return 0.0
+
+    def _assess_goal_risks(self,
+                          goal: InvestmentGoal,
+                          scenarios: np.ndarray,
+                          personal_profile: PersonalProfile) -> Dict[str, float]:
+        """Évalue les risques liés à l'objectif"""
+        try:
+            return {
+                'shortfall_risk': self._calculate_shortfall_risk(scenarios, goal),
+                'time_risk': self._calculate_time_risk(scenarios, goal),
+                'investment_risk': self._calculate_investment_risk(goal, personal_profile),
+                'liquidity_risk': self._calculate_liquidity_risk(goal, personal_profile)
+            }
+        except Exception as e:
+            print(f"Erreur dans l'évaluation des risques: {e}")
+            return {}
+
+    def _generate_recommendations(self,
+                                goal: InvestmentGoal,
+                                success_prob: float,
+                                risk_assessment: Dict[str, float],
+                                personal_profile: PersonalProfile) -> List[str]:
+        """Génère des recommandations d'ajustement"""
+        recommendations = []
+        
+        # Analyse du taux de succès
+        if success_prob < 0.6:
+            recommendations.append(
+                "La probabilité d'atteinte de l'objectif est faible. Considérez : "
+                "1. Augmenter l'épargne mensuelle "
+                "2. Allonger l'horizon d'investissement "
+                "3. Ajuster l'objectif à la baisse"
+            )
+            
+        # Analyse des risques
+        for risk_type, risk_level in risk_assessment.items():
+            if risk_level > 0.7:
+                recommendations.append(
+                    f"Risque {risk_type} élevé. Suggestion : "
+                    f"{self._get_risk_mitigation_strategy(risk_type)}"
+                )
+                
+        return recommendations
+
+    def _get_risk_mitigation_strategy(self, risk_type: str) -> str:
+        """Retourne une stratégie de mitigation pour chaque type de risque"""
+        strategies = {
+            'shortfall_risk': "Augmenter l'épargne ou réduire l'objectif",
+            'time_risk': "Prévoir une période tampon supplémentaire",
+            'investment_risk': "Diversifier davantage le portefeuille",
+            'liquidity_risk': "Maintenir une réserve de liquidité suffisante"
+        }
+        return strategies.get(risk_type, "Revoir la stratégie globale")

src/analysis/ml_analyzer.py

@@ -0,0 +1,994 @@
+# src/analysis/ml_analyzer.py
+
+import numpy as np
+import pandas as pd
+from typing import Dict, List, Optional, Any
+from datetime import datetime
+from sklearn.ensemble import RandomForestClassifier, GradientBoostingRegressor
+from sklearn.preprocessing import StandardScaler
+import torch
+import torch.nn as nn
+import logging
+
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+from ..core.types import MLAnalyzerProtocol
+
+class AlternativeDataAnalyzer:
+    """Analyze alternative data sources for market insights"""
+    
+    def __init__(self):
+        self.social_sentiment_model = RandomForestClassifier(n_estimators=100)
+        self.web_traffic_model = RandomForestClassifier(n_estimators=50)
+        
+    def analyze_social_sentiment(self, social_data: List[Dict]) -> float:
+        """Analyze social media sentiment"""
+        features = self._extract_social_features(social_data)
+        return float(self.social_sentiment_model.predict(features)[0])
+        
+    def analyze_web_traffic(self, traffic_data: pd.DataFrame) -> Dict[str, float]:
+        """Analyze web traffic patterns"""
+        features = self._prepare_traffic_features(traffic_data)
+        predictions = self.web_traffic_model.predict(features)
+        return {
+            'growth_score': float(np.mean(predictions)),
+            'trend_strength': float(np.std(predictions))
+        }
+
+
+class MarketImpactPredictor:
+    """Predicts market impact of trades using machine learning"""
+    
+    def __init__(self):
+        self.impact_model = GradientBoostingRegressor(
+            n_estimators=100,
+            learning_rate=0.1,
+            max_depth=3,
+            random_state=42
+        )
+        self.scaler = StandardScaler()
+        self.feature_columns = [
+            'trade_size_norm',
+            'volume_profile',
+            'volatility',
+            'bid_ask_spread',
+            'market_regime',
+            'time_of_day'
+        ]
+        
+    def predict_trade_impact(self,
+                           trade_size: float,
+                           market_data: pd.DataFrame,
+                           market_conditions: Optional[Dict] = None) -> Dict[str, float]:
+        """
+        Predict market impact of a trade
+        
+        Args:
+            trade_size: Size of the trade
+            market_data: Market data (prices, volumes, etc.)
+            market_conditions: Additional market condition indicators
+            
+        Returns:
+            Dictionary with impact predictions and metrics
+        """
+        try:
+            # Extract features
+            features = self._extract_impact_features(
+                trade_size, 
+                market_data, 
+                market_conditions
+            )
+            
+            # Scale features
+            scaled_features = self.scaler.transform(features)
+            
+            # Predict impact
+            base_impact = float(self.impact_model.predict(scaled_features)[0])
+            
+            # Adjust for market conditions
+            adjusted_impact = self._adjust_for_market_conditions(
+                base_impact,
+                market_conditions
+            )
+            
+            # Calculate confidence and risk metrics
+            confidence = self._calculate_prediction_confidence(features)
+            risk_metrics = self._calculate_impact_risk_metrics(
+                adjusted_impact,
+                market_data
+            )
+            
+            return {
+                'predicted_impact': adjusted_impact,
+                'base_impact': base_impact,
+                'confidence': confidence,
+                'risk_metrics': risk_metrics,
+                'recommended_sizing': self._calculate_recommended_sizing(
+                    trade_size,
+                    adjusted_impact,
+                    market_data
+                )
+            }
+            
+        except Exception as e:
+            print(f"Error predicting market impact: {e}")
+            return {
+                'predicted_impact': self._calculate_simple_impact(
+                    trade_size, 
+                    market_data
+                ),
+                'confidence': 0.0,
+                'risk_metrics': {}
+            }
+
+    def _extract_impact_features(self,
+                               trade_size: float,
+                               market_data: pd.DataFrame,
+                               market_conditions: Optional[Dict]) -> np.ndarray:
+        """Extract features for impact prediction"""
+        try:
+            features = []
+            
+            # Normalize trade size by average daily volume
+            avg_volume = market_data['volume'].mean()
+            trade_size_norm = trade_size / avg_volume if avg_volume > 0 else 0
+            features.append(trade_size_norm)
+            
+            # Volume profile
+            volume_profile = self._calculate_volume_profile(market_data)
+            features.append(volume_profile)
+            
+            # Market volatility
+            volatility = market_data['close'].pct_change().std()
+            features.append(volatility)
+            
+            # Bid-ask spread
+            spread = self._calculate_bid_ask_spread(market_data)
+            features.append(spread)
+            
+            # Market regime indicator
+            regime_indicator = self._get_regime_indicator(market_conditions)
+            features.append(regime_indicator)
+            
+            # Time of day effect
+            time_feature = self._calculate_time_feature(market_data)
+            features.append(time_feature)
+            
+            return np.array(features).reshape(1, -1)
+            
+        except Exception as e:
+            print(f"Error extracting impact features: {e}")
+            return np.zeros((1, len(self.feature_columns)))
+
+    def _adjust_for_market_conditions(self,
+                                    base_impact: float,
+                                    market_conditions: Optional[Dict]) -> float:
+        """Adjust impact prediction based on market conditions"""
+        try:
+            if not market_conditions:
+                return base_impact
+                
+            # Volatility adjustment
+            volatility_factor = market_conditions.get('volatility', 1.0)
+            
+            # Liquidity adjustment
+            liquidity_factor = 1 / market_conditions.get('liquidity', 1.0)
+            
+            # Regime adjustment
+            regime_factor = self._get_regime_factor(market_conditions)
+            
+            # Combined adjustment
+            adjustment = (volatility_factor * liquidity_factor * regime_factor)
+            
+            return base_impact * adjustment
+            
+        except Exception as e:
+            print(f"Error adjusting for market conditions: {e}")
+            return base_impact
+
+    def _calculate_prediction_confidence(self, features: np.ndarray) -> float:
+        """Calculate confidence score for impact prediction"""
+        try:
+            # Base confidence
+            confidence = 0.8
+            
+            # Adjust based on feature quality
+            for i, feature in enumerate(features[0]):
+                if np.isnan(feature) or np.isinf(feature):
+                    confidence *= 0.8
+                    
+            # Adjust based on feature values
+            trade_size_norm = features[0][0]
+            if trade_size_norm > 0.1:  # Large trades
+                confidence *= 0.9
+                
+            return float(confidence)
+            
+        except Exception as e:
+            print(f"Error calculating prediction confidence: {e}")
+            return 0.5
+
+    def _calculate_impact_risk_metrics(self,
+                                     impact: float,
+                                     market_data: pd.DataFrame) -> Dict[str, float]:
+        """Calculate risk metrics for impact prediction"""
+        try:
+            metrics = {}
+            
+            # Calculate VaR of impact
+            metrics['impact_var_95'] = impact * 1.645  # Assuming normal distribution
+            
+            # Calculate potential slippage
+            metrics['max_slippage'] = impact * 2
+            
+            # Timing risk
+            metrics['timing_risk'] = self._calculate_timing_risk(market_data)
+            
+            return metrics
+            
+        except Exception as e:
+            print(f"Error calculating impact risk metrics: {e}")
+            return {}
+
+    def _calculate_simple_impact(self,
+                               trade_size: float,
+                               market_data: pd.DataFrame) -> float:
+        """Calculate simple market impact estimate"""
+        try:
+            avg_volume = market_data['volume'].mean()
+            participation_rate = trade_size / avg_volume if avg_volume > 0 else 0
+            
+            # Square root model
+            return 0.1 * np.sqrt(participation_rate)
+            
+        except Exception as e:
+            print(f"Error calculating simple impact: {e}")
+            return 0.01  # Default 1 bp impact
+
+    def _calculate_recommended_sizing(self,
+                                   trade_size: float,
+                                   predicted_impact: float,
+                                   market_data: pd.DataFrame) -> Dict[str, float]:
+        """Calculate recommended trade sizing"""
+        try:
+            avg_volume = market_data['volume'].mean()
+            
+            # Calculate different size recommendations
+            aggressive = min(trade_size, avg_volume * 0.1)
+            normal = min(trade_size, avg_volume * 0.05)
+            passive = min(trade_size, avg_volume * 0.02)
+            
+            return {
+                'aggressive_size': float(aggressive),
+                'normal_size': float(normal),
+                'passive_size': float(passive),
+                'optimal_size': float(normal)  # Could be adjusted based on urgency
+            }
+            
+        except Exception as e:
+            print(f"Error calculating recommended sizing: {e}")
+            return {'optimal_size': trade_size * 0.05}
+
+    @staticmethod
+    def _calculate_volume_profile(market_data: pd.DataFrame) -> float:
+        """Calculate volume profile metric"""
+        try:
+            recent_volume = market_data['volume'].tail(20).mean()
+            hist_volume = market_data['volume'].mean()
+            return recent_volume / hist_volume if hist_volume > 0 else 1.0
+        except:
+            return 1.0
+
+    @staticmethod
+    def _calculate_bid_ask_spread(market_data: pd.DataFrame) -> float:
+        """Calculate average bid-ask spread"""
+        try:
+            if 'bid' in market_data and 'ask' in market_data:
+                spread = (market_data['ask'] - market_data['bid']) / market_data['ask']
+                return float(spread.mean())
+            return 0.001  # Default 10 bp spread
+        except:
+            return 0.001
+
+    @staticmethod
+    def _get_regime_indicator(market_conditions: Optional[Dict]) -> float:
+        """Get numerical indicator for market regime"""
+        try:
+            if not market_conditions:
+                return 0.0
+            regime = market_conditions.get('regime', 'normal')
+            regime_map = {
+                'crisis': -1.0,
+                'stress': -0.5,
+                'normal': 0.0,
+                'calm': 0.5,
+                'highly_liquid': 1.0
+            }
+            return regime_map.get(regime, 0.0)
+        except:
+            return 0.0
+
+    @staticmethod
+    def _calculate_time_feature(market_data: pd.DataFrame) -> float:
+        """Calculate time of day feature"""
+        try:
+            if isinstance(market_data.index, pd.DatetimeIndex):
+                hour = market_data.index[-1].hour
+                # Normalize to 0-1 range, with peak at market open/close
+                return np.sin(np.pi * hour / 12)
+            return 0.0
+        except:
+            return 0.0
+
+    @staticmethod
+    def _get_regime_factor(market_conditions: Optional[Dict]) -> float:
+        """Get adjustment factor for market regime"""
+        try:
+            if not market_conditions:
+                return 1.0
+            regime = market_conditions.get('regime', 'normal')
+            regime_factors = {
+                'crisis': 2.0,
+                'stress': 1.5,
+                'normal': 1.0,
+                'calm': 0.8,
+                'highly_liquid': 0.5
+            }
+            return regime_factors.get(regime, 1.0)
+        except:
+            return 1.0
+
+    @staticmethod
+    def _calculate_timing_risk(market_data: pd.DataFrame) -> float:
+        """Calculate timing risk metric"""
+        try:
+            returns = market_data['close'].pct_change()
+            volatility = returns.std()
+            return float(volatility * np.sqrt(252))
+        except:
+            return 0.2  # Default 20% annualized vol
+
+class SentimentAnalyzer:
+    """Advanced sentiment analyzer for market and news data"""
+    
+    def __init__(self):
+        self.sentiment_model = None
+        self.text_vectorizer = None
+        self.market_indicators = [
+            'price_momentum',
+            'volume_change',
+            'volatility',
+            'rsi',
+            'macd',
+            'social_sentiment'
+        ]
+        
+    def analyze_sentiment(self,
+                         market_data: pd.DataFrame,
+                         news_data: Optional[List[str]] = None,
+                         social_data: Optional[Dict[str, Any]] = None) -> Dict[str, float]:
+        """
+        Analyze overall market sentiment using multiple data sources.
+        
+        Args:
+            market_data: Market price and volume data
+            news_data: List of news articles/headlines
+            social_data: Social media sentiment data
+            
+        Returns:
+            Dictionary of sentiment scores
+        """
+        try:
+            # Market technical sentiment
+            market_sentiment = self._analyze_market_sentiment(market_data)
+            
+            # News sentiment
+            news_sentiment = self._analyze_news_sentiment(news_data) if news_data else 0.5
+            
+            # Social media sentiment
+            social_sentiment = self._analyze_social_sentiment(social_data) if social_data else 0.5
+            
+            # Combine all sentiment signals
+            composite_sentiment = self._calculate_composite_sentiment(
+                market_sentiment,
+                news_sentiment,
+                social_sentiment
+            )
+            
+            return {
+                'composite_sentiment': composite_sentiment,
+                'market_sentiment': market_sentiment,
+                'news_sentiment': news_sentiment,
+                'social_sentiment': social_sentiment,
+                'sentiment_indicators': self._calculate_sentiment_indicators(market_data),
+                'confidence_score': self._calculate_confidence_score(market_data)
+            }
+            
+        except Exception as e:
+            print(f"Error in sentiment analysis: {e}")
+            return {
+                'composite_sentiment': 0.5,
+                'market_sentiment': 0.5,
+                'news_sentiment': 0.5,
+                'social_sentiment': 0.5,
+                'sentiment_indicators': {},
+                'confidence_score': 0.0
+            }
+
+    def _analyze_market_sentiment(self, market_data: pd.DataFrame) -> float:
+        """Analyze sentiment from market data"""
+        try:
+            if market_data.empty:
+                return 0.5
+                
+            sentiment_scores = []
+            
+            # Price momentum
+            returns = market_data['close'].pct_change()
+            momentum = returns.rolling(window=20).mean().iloc[-1]
+            sentiment_scores.append(self._normalize_score(momentum, -0.02, 0.02))
+            
+            # Volume trend
+            volume_change = market_data['volume'].pct_change()
+            vol_trend = volume_change.rolling(window=20).mean().iloc[-1]
+            sentiment_scores.append(self._normalize_score(vol_trend, -0.1, 0.1))
+            
+            # RSI
+            rsi = self._calculate_rsi(market_data)
+            sentiment_scores.append(self._normalize_score(rsi, 30, 70))
+            
+            # Weighted average
+            weights = [0.5, 0.3, 0.2]
+            return sum(score * weight for score, weight 
+                      in zip(sentiment_scores, weights))
+                      
+        except Exception as e:
+            print(f"Error in market sentiment analysis: {e}")
+            return 0.5
+
+    def _analyze_news_sentiment(self, news_data: List[str]) -> float:
+        """Analyze sentiment from news articles"""
+        try:
+            if not news_data:
+                return 0.5
+                
+            # Simple keyword-based sentiment (placeholder)
+            positive_words = {'growth', 'profit', 'success', 'gain', 'rally'}
+            negative_words = {'loss', 'risk', 'decline', 'crash', 'fear'}
+            
+            total_score = 0
+            for text in news_data:
+                words = set(text.lower().split())
+                positive_count = len(words.intersection(positive_words))
+                negative_count = len(words.intersection(negative_words))
+                
+                if positive_count + negative_count > 0:
+                    score = positive_count / (positive_count + negative_count)
+                else:
+                    score = 0.5
+                    
+                total_score += score
+                
+            return total_score / len(news_data)
+            
+        except Exception as e:
+            print(f"Error in news sentiment analysis: {e}")
+            return 0.5
+
+    def _analyze_social_sentiment(self, social_data: Dict[str, Any]) -> float:
+        """Analyze sentiment from social media data"""
+        try:
+            if not social_data:
+                return 0.5
+                
+            sentiment_scores = []
+            
+            # Process different social media sources
+            for source, data in social_data.items():
+                if source == 'twitter':
+                    score = self._analyze_twitter_sentiment(data)
+                elif source == 'reddit':
+                    score = self._analyze_reddit_sentiment(data)
+                else:
+                    score = 0.5
+                    
+                sentiment_scores.append(score)
+                
+            return np.mean(sentiment_scores) if sentiment_scores else 0.5
+            
+        except Exception as e:
+            print(f"Error in social sentiment analysis: {e}")
+            return 0.5
+
+    def _calculate_composite_sentiment(self,
+                                    market_sentiment: float,
+                                    news_sentiment: float,
+                                    social_sentiment: float) -> float:
+        """Calculate weighted composite sentiment"""
+        weights = {
+            'market': 0.5,
+            'news': 0.3,
+            'social': 0.2
+        }
+        
+        composite = (
+            weights['market'] * market_sentiment +
+            weights['news'] * news_sentiment +
+            weights['social'] * social_sentiment
+        )
+        
+        return min(max(composite, 0), 1)  # Ensure between 0 and 1
+
+    def _calculate_sentiment_indicators(self, market_data: pd.DataFrame) -> Dict[str, float]:
+        """Calculate various sentiment indicators"""
+        try:
+            indicators = {}
+            
+            for indicator in self.market_indicators:
+                if indicator == 'price_momentum':
+                    value = self._calculate_momentum(market_data)
+                elif indicator == 'volume_change':
+                    value = self._calculate_volume_change(market_data)
+                elif indicator == 'volatility':
+                    value = self._calculate_volatility(market_data)
+                else:
+                    value = 0.0
+                    
+                indicators[indicator] = value
+                
+            return indicators
+            
+        except Exception as e:
+            print(f"Error calculating sentiment indicators: {e}")
+            return {}
+
+    @staticmethod
+    def _normalize_score(value: float, min_val: float, max_val: float) -> float:
+        """Normalize a value to a 0-1 range"""
+        try:
+            return min(max((value - min_val) / (max_val - min_val), 0), 1)
+        except:
+            return 0.5
+
+    @staticmethod
+    def _calculate_rsi(data: pd.DataFrame, periods: int = 14) -> float:
+        """Calculate RSI indicator"""
+        try:
+            delta = data['close'].diff()
+            gain = (delta.where(delta > 0, 0)).rolling(window=periods).mean()
+            loss = (-delta.where(delta < 0, 0)).rolling(window=periods).mean()
+            rs = gain / loss
+            return float(100 - (100 / (1 + rs.iloc[-1])))
+        except:
+            return 50.0
+
+    def _calculate_confidence_score(self, market_data: pd.DataFrame) -> float:
+        """Calculate confidence score for sentiment analysis"""
+        try:
+            # Volatility-based confidence
+            volatility = self._calculate_volatility(market_data)
+            volume = self._calculate_volume_change(market_data)
+            
+            # Lower confidence in high volatility periods
+            confidence = 1 - min(volatility, 0.5)
+            
+            # Higher confidence with higher volume
+            volume_factor = min(max(volume, 0), 1)
+            confidence *= (0.7 + 0.3 * volume_factor)
+            
+            return float(confidence)
+            
+        except Exception as e:
+            print(f"Error calculating confidence score: {e}")
+            return 0.0
+
+    @staticmethod
+    def _calculate_momentum(data: pd.DataFrame, window: int = 20) -> float:
+        """Calculate price momentum"""
+        try:
+            returns = data['close'].pct_change()
+            return float(returns.rolling(window=window).mean().iloc[-1])
+        except:
+            return 0.0
+
+    @staticmethod
+    def _calculate_volume_change(data: pd.DataFrame, window: int = 20) -> float:
+        """Calculate volume trend"""
+        try:
+            volume_change = data['volume'].pct_change()
+            return float(volume_change.rolling(window=window).mean().iloc[-1])
+        except:
+            return 0.0
+
+    @staticmethod
+    def _calculate_volatility(data: pd.DataFrame, window: int = 20) -> float:
+        """Calculate price volatility"""
+        try:
+            returns = data['close'].pct_change()
+            return float(returns.rolling(window=window).std().iloc[-1])
+        except:
+            return 0.0
+
+class MarketRegimeClassifier:
+    """Classifier for market regimes using machine learning"""
+    
+    def __init__(self):
+        self.model = GaussianMixture(n_components=3, random_state=42)
+        self.scaler = StandardScaler()
+        self.regimes = ['bear', 'neutral', 'bull']
+        
+    def extract_features(self, market_data: pd.DataFrame) -> np.ndarray:
+        """Extract relevant features for regime classification"""
+        features = []
+        
+        # Price-based features
+        returns = market_data['close'].pct_change()
+        features.extend([
+            returns.mean(),             # Mean return
+            returns.std(),              # Volatility
+            returns.skew(),             # Asymmetry
+            returns.kurt(),             # Kurtosis
+            self._calculate_momentum(market_data),  # Momentum
+            self._calculate_rsi(market_data),       # RSI
+            self._calculate_volatility_regime(returns)  # Volatility regime
+        ])
+        
+        return np.array(features).reshape(1, -1)
+
+    def predict_regime(self, market_data: pd.DataFrame) -> str:
+        """Predict current market regime"""
+        features = self.extract_features(market_data)
+        scaled_features = self.scaler.transform(features)
+        regime_idx = self.model.predict(scaled_features)[0]
+        return self.regimes[regime_idx]
+
+    def _calculate_momentum(self, data: pd.DataFrame, window: int = 63) -> float:
+        """Calculate price momentum"""
+        returns = data['close'].pct_change()
+        return returns.rolling(window=window).mean().iloc[-1]
+
+    def _calculate_rsi(self, data: pd.DataFrame, periods: int = 14) -> float:
+        """Calculate RSI indicator"""
+        delta = data['close'].pct_change()
+        gain = (delta.where(delta > 0, 0)).rolling(window=periods).mean()
+        loss = (-delta.where(delta < 0, 0)).rolling(window=periods).mean()
+        rs = gain / loss
+        return 100 - (100 / (1 + rs.iloc[-1]))
+
+    def _calculate_volatility_regime(self, returns: pd.Series, window: int = 21) -> float:
+        """Calculate volatility regime indicator"""
+        vol = returns.rolling(window=window).std() * np.sqrt(252)
+        return vol.iloc[-1]
+
+class MLEnhancedAnalyzer:
+    """Enhanced market analyzer with machine learning capabilities"""
+    def _setup_logger(self) -> logging.Logger:
+        """Configuration du système de logging"""
+        logger = logging.getLogger('Deepvest')
+        logger.setLevel(logging.INFO)
+        handler = logging.StreamHandler()
+        formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+        handler.setFormatter(formatter)
+        logger.addHandler(handler)
+        return logger
+    
+    def __init__(self):
+        self.regime_classifier = MarketRegimeClassifier()
+        self.sentiment_analyzer = self._initialize_sentiment_model()
+        
+    def _initialize_sentiment_model(self):
+        return GaussianMixture(n_components=2, random_state=42)
+        
+    def predict_market_regime(self, market_data: pd.DataFrame) -> str:
+        """Predict market regime"""
+        return self.regime_classifier.predict_regime(market_data)
+        
+    def analyze_market_sentiment(self, 
+                               market_data: pd.DataFrame, 
+                               news_data: Optional[List[str]] = None) -> float:
+        """Analyze market sentiment"""
+        market_features = self._extract_market_features(market_data)
+        sentiment_score = self.sentiment_analyzer.predict_proba(market_features)
+        if news_data:
+            news_sentiment = self._analyze_news_sentiment(news_data)
+            sentiment_score = 0.7 * sentiment_score + 0.3 * news_sentiment
+        return float(sentiment_score.mean())
+
+    def _extract_market_features(self, market_data: pd.DataFrame) -> np.ndarray:
+        """Extract features for sentiment analysis"""
+        if market_data.empty:
+            return np.array([[0]])
+            
+        features = []
+        returns = market_data['close'].pct_change().dropna()
+        
+        # Basic features
+        features.extend([
+            returns.mean(),
+            returns.std(),
+            returns.skew(),
+            returns.kurt()
+        ])
+        
+        # Technical features
+        features.extend([
+            self._calculate_macd(market_data),
+            self._calculate_rsi(market_data),
+            self._calculate_bollinger_bands(market_data)
+        ])
+        
+        return np.array(features).reshape(1, -1)
+
+    @staticmethod
+    def _calculate_macd(data: pd.DataFrame) -> float:
+        """Calculate MACD indicator"""
+        if 'close' not in data.columns or len(data) < 26:
+            return 0.0
+        exp1 = data['close'].ewm(span=12, adjust=False).mean()
+        exp2 = data['close'].ewm(span=26, adjust=False).mean()
+        macd = exp1 - exp2
+        return float(macd.iloc[-1])
+
+    @staticmethod
+    def _calculate_bollinger_bands(data: pd.DataFrame) -> float:
+        """Calculate Bollinger Bands position"""
+        if 'close' not in data.columns or len(data) < 20:
+            return 0.0
+        ma = data['close'].rolling(window=20).mean()
+        std = data['close'].rolling(window=20).std()
+        upper = ma + (std * 2)
+        lower = ma - (std * 2)
+        position = (data['close'] - lower) / (upper - lower)
+        return float(position.iloc[-1])
+
+    def _analyze_news_sentiment(self, news_data: List[str]) -> float:
+        """Simple sentiment analysis of news data"""
+        # Placeholder - would normally use NLP model
+        return 0.5
+
+class MLEnhancedAnalyzer(MLAnalyzerProtocol):
+    """ML-enhanced market analysis implementation"""
+    
+    def __init__(self):
+        # Modèles pour différentes tâches d'analyse
+        self.regime_classifier = RandomForestClassifier(n_estimators=100, random_state=42)
+        self.risk_predictor = GradientBoostingRegressor(n_estimators=100, random_state=42)
+        self.scaler = StandardScaler()
+        
+        # Modèle de sentiment
+        self.sentiment_tokenizer = AutoTokenizer.from_pretrained("nickmuchi/finbert-tone-finetuned-finance-text-classification")
+        self.sentiment_model = AutoModelForSequenceClassification.from_pretrained("nickmuchi/finbert-tone-finetuned-finance-text-classification")
+        
+    async def analyze_market_conditions(self,
+                                     market_data: pd.DataFrame,
+                                     news_data: Optional[List[str]] = None,
+                                     alternative_data: Optional[Dict] = None) -> Dict[str, Any]:
+        """Analyse complète des conditions de marché utilisant ML"""
+        try:
+            # Préparer les features
+            features = self._prepare_features(market_data)
+            scaled_features = self.scaler.transform(features)
+            
+            # Analyse du régime de marché
+            regime = self._predict_market_regime(scaled_features)
+            
+            # Analyse des risques
+            risk_metrics = self._analyze_risk_factors(market_data)
+            
+            # Analyse technique
+            technical_metrics = self._analyze_technical_factors(market_data)
+            
+            # Analyse du sentiment si des données sont disponibles
+            sentiment = {}
+            if news_data:
+                sentiment = await self._analyze_sentiment(news_data)
+            
+            # Analyse des données alternatives si disponibles
+            alt_insights = {}
+            if alternative_data:
+                alt_insights = self._analyze_alternative_data(alternative_data)
+            
+            return {
+                'regime': regime,
+                'risk_metrics': risk_metrics,
+                'technical_metrics': technical_metrics,
+                'sentiment': sentiment,
+                'alternative_insights': alt_insights,
+                'timestamp': datetime.now()
+            }
+            
+        except Exception as e:
+            print(f"Error in ML market analysis: {str(e)}")
+            return self._get_default_analysis()
+
+    def _prepare_features(self, market_data: pd.DataFrame) -> np.ndarray:
+        """Prépare les features pour l'analyse ML"""
+        try:
+            # Calculer les rendements si nécessaire
+            if 'returns' not in market_data.columns:
+                returns = market_data.pct_change().dropna()
+            else:
+                returns = market_data['returns'].dropna()
+            
+            features = []
+            
+            # Features basées sur les rendements
+            features.extend([
+                returns.mean(),
+                returns.std(),
+                returns.skew(),
+                returns.kurtosis(),
+                (returns < 0).mean()
+            ])
+            
+            # Features basées sur le volume si disponible
+            if 'volume' in market_data.columns:
+                volume = market_data['volume']
+                features.extend([
+                    volume.mean(),
+                    volume.std() / volume.mean(),
+                    (volume.pct_change() > 0).mean()
+                ])
+            
+            # Features techniques si disponibles
+            if 'close' in market_data.columns:
+                close_prices = market_data['close']
+                features.extend(self._calculate_technical_features(close_prices))
+            
+            return np.array(features).reshape(1, -1)
+            
+        except Exception as e:
+            print(f"Error preparing features: {str(e)}")
+            return np.zeros((1, 10))  # Features par défaut
+
+    def _predict_market_regime(self, features: np.ndarray) -> str:
+        """Prédit le régime de marché actuel"""
+        try:
+            prediction = self.regime_classifier.predict(features)[0]
+            regimes = ['BULL_MARKET', 'BEAR_MARKET', 'HIGH_VOLATILITY', 'LOW_VOLATILITY']
+            return regimes[prediction] if isinstance(prediction, (int, np.integer)) else 'LOW_VOLATILITY'
+        except Exception as e:
+            print(f"Error predicting regime: {str(e)}")
+            return 'LOW_VOLATILITY'
+
+    def _analyze_risk_factors(self, market_data: pd.DataFrame) -> Dict[str, float]:
+        """Analyse des facteurs de risque"""
+        try:
+            returns = market_data.pct_change().dropna()
+            
+            risk_metrics = {
+                'volatility': float(returns.std() * np.sqrt(252)),
+                'tail_risk': self._calculate_tail_risk(returns),
+                'var_95': float(np.percentile(returns, 5)),
+                'skewness': float(returns.skew()),
+                'kurtosis': float(returns.kurtosis())
+            }
+            
+            return risk_metrics
+            
+        except Exception as e:
+            print(f"Error analyzing risk factors: {str(e)}")
+            return {
+                'volatility': 0.15,
+                'tail_risk': 0.05,
+                'var_95': -0.02,
+                'skewness': 0.0,
+                'kurtosis': 3.0
+            }
+
+    async def _analyze_sentiment(self, news_data: List[str]) -> Dict[str, float]:
+        """Analyse du sentiment des nouvelles"""
+        try:
+            sentiments = []
+            for text in news_data:
+                # Tokenization et préparation
+                inputs = self.sentiment_tokenizer(text, return_tensors="pt", padding=True, truncation=True)
+                
+                # Analyse avec le modèle
+                with torch.no_grad():
+                    outputs = self.sentiment_model(**inputs)
+                    logits = outputs.logits
+                    probs = torch.softmax(logits, dim=1)
+                    sentiments.append(probs.tolist()[0])
+            
+            # Agrégation des sentiments
+            avg_sentiment = np.mean(sentiments, axis=0)
+            return {
+                'positive': float(avg_sentiment[2]),  # Indice 2 pour le sentiment positif
+                'neutral': float(avg_sentiment[1]),   # Indice 1 pour le sentiment neutre
+                'negative': float(avg_sentiment[0])   # Indice 0 pour le sentiment négatif
+            }
+            
+        except Exception as e:
+            print(f"Error analyzing sentiment: {str(e)}")
+            return {'positive': 0.33, 'neutral': 0.34, 'negative': 0.33}
+
+    def _analyze_technical_factors(self, market_data: pd.DataFrame) -> Dict[str, float]:
+        """Analyse des facteurs techniques"""
+        try:
+            close_prices = market_data['close']
+            
+            return {
+                'rsi': self._calculate_rsi(close_prices),
+                'macd': self._calculate_macd(close_prices),
+                'momentum': self._calculate_momentum(close_prices),
+                'trend_strength': self._calculate_trend_strength(close_prices)
+            }
+            
+        except Exception as e:
+            print(f"Error analyzing technical factors: {str(e)}")
+            return {
+                'rsi': 50.0,
+                'macd': 0.0,
+                'momentum': 0.0,
+                'trend_strength': 0.0
+            }
+
+    def _analyze_alternative_data(self, alternative_data: Dict) -> Dict[str, Any]:
+        """Analyse des données alternatives"""
+        insights = {}
+        
+        try:
+            # Analyse des données sociales si disponibles
+            if 'social_media' in alternative_data:
+                insights['social'] = self._analyze_social_data(alternative_data['social_media'])
+                
+            # Analyse des données de trafic web si disponibles
+            if 'web_traffic' in alternative_data:
+                insights['traffic'] = self._analyze_web_traffic(alternative_data['web_traffic'])
+                
+            # Analyse des données satellite si disponibles
+            if 'satellite' in alternative_data:
+                insights['satellite'] = self._analyze_satellite_data(alternative_data['satellite'])
+                
+        except Exception as e:
+            print(f"Error analyzing alternative data: {str(e)}")
+            
+        return insights
+
+    @staticmethod
+    def _calculate_rsi(prices: pd.Series, periods: int = 14) -> float:
+        """Calcul du RSI"""
+        try:
+            delta = prices.diff()
+            gain = (delta.where(delta > 0, 0)).rolling(window=periods).mean()
+            loss = (-delta.where(delta < 0, 0)).rolling(window=periods).mean()
+            rs = gain / loss
+            return float(100 - (100 / (1 + rs.iloc[-1])))
+        except Exception:
+            return 50.0
+
+    @staticmethod
+    def _calculate_macd(prices: pd.Series) -> float:
+        """Calcul du MACD"""
+        try:
+            exp1 = prices.ewm(span=12, adjust=False).mean()
+            exp2 = prices.ewm(span=26, adjust=False).mean()
+            macd = exp1 - exp2
+            signal = macd.ewm(span=9, adjust=False).mean()
+            return float(macd.iloc[-1] - signal.iloc[-1])
+        except Exception:
+            return 0.0
+
+    @staticmethod
+    def _get_default_analysis() -> Dict[str, Any]:
+        """Retourne une analyse par défaut en cas d'erreur"""
+        return {
+            'regime': 'LOW_VOLATILITY',
+            'risk_metrics': {
+                'volatility': 0.15,
+                'tail_risk': 0.05,
+                'var_95': -0.02
+            },
+            'technical_metrics': {
+                'rsi': 50.0,
+                'macd': 0.0,
+                'momentum': 0.0
+            },
+            'sentiment': {
+                'positive': 0.33,
+                'neutral': 0.34,
+                'negative': 0.33
+            },
+            'alternative_insights': {},
+            'timestamp': datetime.now()
+        }

src/analysis/scenario_manager.py

@@ -0,0 +1,205 @@
+# src/analysis/scenario_manager.py
+
+import numpy as np
+import pandas as pd
+from typing import Dict, List, Optional
+from dataclasses import dataclass
+from datetime import datetime, timedelta
+from enum import Enum
+
+class MarketScenario(Enum):
+    """Types de scénarios de marché"""
+    BULL_MARKET = "bull_market"
+    BEAR_MARKET = "bear_market"
+    HIGH_VOLATILITY = "high_volatility"
+    LOW_VOLATILITY = "low_volatility"
+    CRISIS = "crisis"
+    RECOVERY = "recovery"
+    SIDEWAYS = "sideways"
+    HIGH_INFLATION = "high_inflation"
+    STAGFLATION = "stagflation"
+
+@dataclass
+class ScenarioConfig:
+    """Configuration d'un scénario"""
+    scenario_type: MarketScenario
+    duration: int  # en jours
+    severity: float  # 0 à 1
+    parameters: Dict[str, float]
+    macro_conditions: Dict[str, float]
+
+class ScenarioManager:
+    """Gestionnaire de scénarios de marché"""
+    
+    def __init__(self, data_fetcher, market_analyzer, risk_manager):
+        self.data_fetcher = data_fetcher
+        self.market_analyzer = market_analyzer
+        self.risk_manager = risk_manager
+        
+    def generate_scenario(self, base_data: pd.DataFrame, config: ScenarioConfig) -> pd.DataFrame:
+        """Génère un scénario de marché spécifique"""
+        try:
+            # Cloner les données de base
+            scenario_data = base_data.copy()
+            
+            # Appliquer les modifications selon le scénario
+            if config.scenario_type == MarketScenario.BULL_MARKET:
+                scenario_data = self._generate_bull_market(scenario_data, config)
+            elif config.scenario_type == MarketScenario.BEAR_MARKET:
+                scenario_data = self._generate_bear_market(scenario_data, config)
+            elif config.scenario_type == MarketScenario.CRISIS:
+                scenario_data = self._generate_crisis(scenario_data, config)
+            # ... autres scénarios
+            
+            # Ajouter les conditions macro-économiques
+            scenario_data = self._add_macro_conditions(scenario_data, config.macro_conditions)
+            
+            return scenario_data
+            
+        except Exception as e:
+            print(f"Erreur dans la génération du scénario: {e}")
+            return base_data
+
+    async def test_strategy_under_scenarios(self,
+                                          strategy,
+                                          scenarios: List[ScenarioConfig],
+                                          base_portfolio: Dict[str, float]) -> Dict:
+        """Teste la stratégie sous différents scénarios"""
+        results = {}
+        
+        for scenario_config in scenarios:
+            try:
+                # Générer les données du scénario
+                scenario_data = self.generate_scenario(
+                    base_data=await self._get_base_data(),
+                    config=scenario_config
+                )
+                
+                # Tester la stratégie
+                scenario_results = await self._backtest_scenario(
+                    strategy=strategy,
+                    scenario_data=scenario_data,
+                    base_portfolio=base_portfolio,
+                    config=scenario_config
+                )
+                
+                results[scenario_config.scenario_type.value] = scenario_results
+                
+            except Exception as e:
+                print(f"Erreur test scénario {scenario_config.scenario_type}: {e}")
+                
+        return results
+
+    def generate_stress_scenarios(self) -> List[ScenarioConfig]:
+        """Génère une série de scénarios de stress"""
+        return [
+            ScenarioConfig(
+                scenario_type=MarketScenario.CRISIS,
+                duration=63,  # ~3 mois
+                severity=0.8,
+                parameters={
+                    'volatility_increase': 2.5,
+                    'correlation_increase': 0.4,
+                    'liquidity_decrease': 0.6
+                },
+                macro_conditions={
+                    'gdp_growth': -0.03,
+                    'inflation_rate': 0.06,
+                    'interest_rate': 0.04
+                }
+            ),
+            # ... autres scénarios de stress
+        ]
+
+    def _generate_bull_market(self, data: pd.DataFrame, config: ScenarioConfig) -> pd.DataFrame:
+        """Génère un scénario de marché haussier"""
+        try:
+            # Calculer les rendements de base
+            returns = data.pct_change()
+            
+            # Ajuster les rendements pour le marché haussier
+            bull_adjustment = 0.0002 * config.severity  # +20bp par jour en moyenne
+            adjusted_returns = returns + bull_adjustment
+            
+            # Ajuster la volatilité
+            vol_adjustment = 0.8  # Réduction de la volatilité
+            adjusted_returns = adjusted_returns * vol_adjustment
+            
+            # Reconstruire les prix
+            return (1 + adjusted_returns).cumprod() * data.iloc[0]
+            
+        except Exception as e:
+            print(f"Erreur génération bull market: {e}")
+            return data
+
+    def _generate_crisis(self, data: pd.DataFrame, config: ScenarioConfig) -> pd.DataFrame:
+        """Génère un scénario de crise"""
+        try:
+            # Phase 1: Chute initiale rapide
+            initial_drop = -0.15 * config.severity
+            data_crisis = data.copy()
+            drop_period = int(config.duration * 0.3)
+            
+            # Générer la chute
+            drop_returns = np.linspace(0, initial_drop, drop_period)
+            data_crisis.iloc[:drop_period] *= (1 + drop_returns).cumprod()
+            
+            # Phase 2: Haute volatilité
+            vol_period = data_crisis.iloc[drop_period:]
+            increased_vol = vol_period.pct_change() * (1 + config.parameters['volatility_increase'])
+            data_crisis.iloc[drop_period:] = (1 + increased_vol).cumprod() * vol_period.iloc[0]
+            
+            return data_crisis
+            
+        except Exception as e:
+            print(f"Erreur génération crise: {e}")
+            return data
+
+    def _add_macro_conditions(self, data: pd.DataFrame, macro_conditions: Dict[str, float]) -> pd.DataFrame:
+        """Ajoute les conditions macro-économiques aux données"""
+        data_with_macro = data.copy()
+        
+        for condition, value in macro_conditions.items():
+            data_with_macro[f'macro_{condition}'] = value
+            
+        return data_with_macro
+
+    async def _backtest_scenario(self,
+                               strategy,
+                               scenario_data: pd.DataFrame,
+                               base_portfolio: Dict[str, float],
+                               config: ScenarioConfig) -> Dict:
+        """Exécute un backtest sur un scénario spécifique"""
+        try:
+            # Ajuster les paramètres du risk manager pour le scénario
+            self.risk_manager.adjust_for_scenario(config)
+            
+            # Exécuter le backtest
+            results = await strategy.backtest(
+                data=scenario_data,
+                initial_portfolio=base_portfolio,
+                risk_manager=self.risk_manager
+            )
+            
+            # Analyser les résultats
+            analysis = self._analyze_scenario_results(results, config)
+            
+            return {
+                'config': config,
+                'results': results,
+                'analysis': analysis
+            }
+            
+        except Exception as e:
+            print(f"Erreur backtest scénario: {e}")
+            return {}
+
+    def _analyze_scenario_results(self, results: Dict, config: ScenarioConfig) -> Dict:
+        """Analyse les résultats d'un scénario"""
+        return {
+            'max_drawdown': self._calculate_max_drawdown(results['returns']),
+            'recovery_time': self._calculate_recovery_time(results['returns']),
+            'risk_adjusted_return': self._calculate_risk_adjusted_return(results['returns']),
+            'strategy_adaptation': self._evaluate_strategy_adaptation(results, config),
+            'risk_management_effectiveness': self._evaluate_risk_management(results)
+        }

src/analysis/strategy_optimizer.py

@@ -0,0 +1,230 @@
+# src/analysis/strategy_optimizer.py
+
+import numpy as np
+import pandas as pd
+from typing import Dict, List, Tuple
+from dataclasses import dataclass
+import optuna
+import matplotlib.pyplot as plt
+import seaborn as sns
+from concurrent.futures import ProcessPoolExecutor
+from datetime import datetime, timedelta
+
+from src.models.backtest_results import EnhancedBacktestResult
+
+
+@dataclass
+class OptimizationResult:
+    """Résultats de l'optimisation de la stratégie"""
+    best_params: Dict[str, float]
+    performance_metrics: Dict[str, float]
+    optimization_path: pd.DataFrame
+    parameter_importance: Dict[str, float]
+
+class StrategyOptimizer:
+    """Optimiseur de stratégie utilisant Optuna"""
+    
+    def __init__(self, enhanced_backtest_engine, n_trials: int = 100):
+        self.backtest_engine = enhanced_backtest_engine
+        self.n_trials = n_trials
+        self.study = None
+        
+    async def optimize_strategy(self,
+                              symbols: List[str],
+                              start_date: pd.Timestamp,
+                              end_date: pd.Timestamp) -> OptimizationResult:
+        """Optimise les paramètres de la stratégie"""
+        
+        # Création de l'étude Optuna
+        self.study = optuna.create_study(
+            direction="maximize",
+            study_name="strategy_optimization",
+            sampler=optuna.samplers.TPESampler(seed=42)
+        )
+        
+        # Exécution de l'optimisation
+        self.study.optimize(
+            lambda trial: self._objective(trial, symbols, start_date, end_date),
+            n_trials=self.n_trials,
+            show_progress_bar=True
+        )
+        
+        # Analyse des résultats
+        optimization_results = self._analyze_optimization_results()
+        
+        # Visualisation des résultats
+        self._plot_optimization_results()
+        
+        return optimization_results
+    
+    async def _objective(self, 
+                  trial: optuna.Trial,
+                  symbols: List[str],
+                  start_date: pd.Timestamp,
+                  end_date: pd.Timestamp) -> float:
+        """Fonction objectif pour l'optimisation"""
+        
+        # Paramètres à optimiser
+        params = {
+            'technical_weight': trial.suggest_float('technical_weight', 0.2, 0.6),
+            'alternative_weight': trial.suggest_float('alternative_weight', 0.1, 0.4),
+            'social_weight': trial.suggest_float('social_weight', 0.1, 0.4),
+            'signal_threshold': trial.suggest_float('signal_threshold', 0.3, 0.7),
+            'position_size_factor': trial.suggest_float('position_size_factor', 0.5, 2.0),
+            'stop_loss': trial.suggest_float('stop_loss', 0.02, 0.10),
+            'take_profit': trial.suggest_float('take_profit', 0.03, 0.15)
+        }
+        
+        # Exécution du backtest avec les paramètres actuels
+        results = await self.backtest_engine.run_enhanced_backtest(
+            symbols=symbols,
+            start_date=start_date,
+            end_date=end_date,
+            strategy_params=params
+        )
+        
+        # Calcul du score d'optimisation
+        optimization_score = self._calculate_optimization_score(results)
+        
+        return optimization_score
+    
+    def _calculate_optimization_score(self, results: Dict) -> float:
+        """Calcule le score pour l'optimisation"""
+        # Extraction des métriques
+        sharpe_ratio = results.performance_metrics['sharpe_ratio']
+        max_drawdown = abs(results.performance_metrics['max_drawdown'])
+        return_risk_ratio = results.performance_metrics['annual_return'] / max_drawdown
+        
+        # Combinaison pondérée des métriques
+        score = (0.4 * sharpe_ratio + 
+                0.3 * return_risk_ratio + 
+                0.3 * (1 / (1 + max_drawdown)))
+        
+        return score
+
+    def _analyze_optimization_results(self) -> OptimizationResult:
+        """Analyse des résultats de l'optimisation"""
+        # Meilleurs paramètres
+        best_params = self.study.best_params
+        
+        # Chemin d'optimisation
+        optimization_path = pd.DataFrame(
+            [t.params for t in self.study.trials],
+            index=[t.number for t in self.study.trials]
+        )
+        
+        # Importance des paramètres
+        parameter_importance = optuna.importance.get_param_importances(self.study)
+        
+        return OptimizationResult(
+            best_params=best_params,
+            performance_metrics=self.study.best_value,
+            optimization_path=optimization_path,
+            parameter_importance=parameter_importance
+        )
+
+    def _plot_optimization_results(self):
+        """Visualisation des résultats d'optimisation"""
+        # Configuration du style
+        plt.style.use('seaborn')
+        fig = plt.figure(figsize=(15, 10))
+        
+        # 1. Évolution de l'optimisation
+        plt.subplot(221)
+        optuna.visualization.matplotlib.plot_optimization_history(self.study)
+        plt.title('Progression de l\'optimisation')
+        
+        # 2. Importance des paramètres
+        plt.subplot(222)
+        optuna.visualization.matplotlib.plot_param_importances(self.study)
+        plt.title('Importance des paramètres')
+        
+        # 3. Corrélations entre paramètres
+        plt.subplot(223)
+        optuna.visualization.matplotlib.plot_parallel_coordinate(self.study)
+        plt.title('Corrélations des paramètres')
+        
+        # 4. Distribution des meilleurs paramètres
+        plt.subplot(224)
+        data = pd.DataFrame(
+            [t.params for t in self.study.trials],
+            columns=self.study.best_params.keys()
+        )
+        sns.boxplot(data=data)
+        plt.xticks(rotation=45)
+        plt.title('Distribution des paramètres')
+        
+        plt.tight_layout()
+        plt.show()
+
+# Visualisation détaillée des résultats de backtest
+class BacktestVisualizer:
+    """Visualisation détaillée des résultats de backtest"""
+    
+    @staticmethod
+    def create_performance_dashboard(results: EnhancedBacktestResult):
+        """Création d'un dashboard de performance complet"""
+        plt.style.use('seaborn')
+        fig = plt.figure(figsize=(20, 12))
+        
+        # 1. Courbe de croissance du portefeuille
+        plt.subplot(331)
+        cumulative_returns = (1 + results.returns).cumprod()
+        plt.plot(cumulative_returns.index, cumulative_returns.values)
+        plt.title('Performance du portefeuille')
+        
+        # 2. Drawdowns
+        plt.subplot(332)
+        drawdowns = BacktestVisualizer._calculate_drawdowns(results.returns)
+        plt.fill_between(drawdowns.index, drawdowns.values, 0, color='red', alpha=0.3)
+        plt.title('Drawdowns')
+        
+        # 3. Distribution des rendements
+        plt.subplot(333)
+        sns.histplot(results.returns, kde=True)
+        plt.title('Distribution des rendements')
+        
+        # 4. Heat map des positions
+        plt.subplot(334)
+        sns.heatmap(results.positions.T, cmap='RdYlGn', center=0)
+        plt.title('Évolution des positions')
+        
+        # 5. Contribution par signal
+        plt.subplot(335)
+        signal_returns = BacktestVisualizer._calculate_signal_returns(results)
+        sns.barplot(data=signal_returns)
+        plt.title('Performance par type de signal')
+        
+        # 6. Métriques de risque
+        plt.subplot(336)
+        risk_metrics = pd.Series(results.risk_metrics)
+        sns.barplot(x=risk_metrics.index, y=risk_metrics.values)
+        plt.xticks(rotation=45)
+        plt.title('Métriques de risque')
+        
+        # 7. Impact des données alternatives
+        plt.subplot(337)
+        alt_contribution = pd.Series(results.alternative_contribution)
+        sns.barplot(x=alt_contribution.index, y=alt_contribution.values)
+        plt.xticks(rotation=45)
+        plt.title('Contribution des données alternatives')
+        
+        plt.tight_layout()
+        plt.show()
+
+    @staticmethod
+    def _calculate_drawdowns(returns: pd.Series) -> pd.Series:
+        """Calcul des drawdowns"""
+        cumulative = (1 + returns).cumprod()
+        running_max = cumulative.expanding().max()
+        drawdowns = cumulative / running_max - 1
+        return drawdowns
+
+    @staticmethod
+    def _calculate_signal_returns(results: EnhancedBacktestResult) -> pd.DataFrame:
+        """Calcul des rendements par type de signal"""
+        signal_returns = pd.DataFrame()
+        for signal_type in results.signals['direction'].unique():
+            mask = results.signals['direction'] == signal_type
+            signal_returns[signal_type] = results.returns[mask].mean()
+        return signal_returns