Update app.py

app.py

@@ -1,115 +1,94 @@
-import streamlit as st
-import requests
-import pandas as pd
-import matplotlib.pyplot as plt
-from datetime import datetime, timedelta
-import numpy as np
-
-# Mapping des cryptomonnaies et devises avec leurs IDs pour CoinCap
-coins = {
-    "Bitcoin": "bitcoin",
-    "Ripple": "ripple",
-    "Ethereum": "ethereum",
-    "Tether": "tether",
-    "Stellar": "stellar"
-}
-
-currencies = {
-    "Dollar (USD)": "usd",
-    "Euro (EUR)": "eur",
-    "Livre (GBP)": "gbp",
-    "Bitcoin (BTC)": "btc",
-    "Tether (USDT)": "usdt"
-}
-
-# Fonction pour récupérer les données de CoinCap
-def get_crypto_prices(selected_coins, start_time, end_time):
-    prices = {}
-    for coin, coin_id in selected_coins.items():
-        url = f'https://api.coincap.io/v2/assets/{coin_id}/history'
-        params = {
-            'interval': 'm15',  # Intervalle de 15 minutes
-            'start': int(start_time.timestamp() * 1000),  # Timestamp en millisecondes
-            'end': int(end_time.timestamp() * 1000)
-        }
-        response = requests.get(url, params=params)
-        if response.status_code == 200:
-            data = response.json().get('data', [])
-            prices[coin] = [[int(item['time']), float(item['priceUsd'])] for item in data]
-        else:
-            st.error(f"Erreur lors de la récupération des prix pour {coin}: {response.status_code}")
-    return prices
-
-# Fonction de prédiction (simple extrapolation basée sur la tendance)
-def predict_future_prices(data, future_hours=24):
+# Fonction pour appliquer différents patterns
+def predict_patterns(data, future_hours=24):
     # Convertir les données en DataFrame
     df = pd.DataFrame(data, columns=["timestamp", "price"])
     df["timestamp"] = pd.to_datetime(df["timestamp"], unit="ms")
     df.set_index("timestamp", inplace=True)
 
-    # Calculer la tendance moyenne des 48 dernières heures
-    trend = (df["price"].iloc[-1] - df["price"].iloc[0]) / len(df)
-
     # Générer les futures timestamps
     last_timestamp = df.index[-1]
     future_timestamps = [last_timestamp + timedelta(minutes=15 * i) for i in range(1, (future_hours * 60 // 15) + 1)]
 
-    # Générer les futurs prix en extrapolant la tendance
+    # Calculer des métriques utiles
     last_price = df["price"].iloc[-1]
-    future_prices = [last_price + i * trend for i in range(1, len(future_timestamps) + 1)]
-
-    # Retourner un DataFrame des prédictions
-    future_df = pd.DataFrame({"timestamp": future_timestamps, "price": future_prices})
-    return future_df
-
-# Streamlit App
-st.title("Analyse Multi-Crypto avec Prédictions (CoinCap)")
-st.sidebar.header("Paramètres")
-
-# Choix des cryptomonnaies
-selected_coins = st.sidebar.multiselect(
-    "Choisissez les cryptomonnaies",
-    list(coins.keys()),
-    default=["Bitcoin", "Ethereum"]
-)
-
-# Choix de la devise
-selected_currency = st.sidebar.selectbox(
-    "Choisissez la devise",
-    list(currencies.keys()),
-    index=0
-)
-
-# Période de temps
-end_time = datetime.now()
-start_time = end_time - timedelta(hours=48)  # Dernières 48 heures
-
-# Conversion des sélections en IDs
-selected_coin_ids = {coin: coins[coin] for coin in selected_coins}
-
-# Récupération des données
-st.write(f"### Données pour : {', '.join(selected_coins)} en {selected_currency}")
-crypto_prices = get_crypto_prices(selected_coin_ids, start_time, end_time)
-
-# Affichage des graphiques avec prédictions
+    trend = (df["price"].iloc[-1] - df["price"].iloc[0]) / len(df)
+    sma = df["price"].rolling(window=10).mean().iloc[-1]  # Moyenne mobile simple (sur 10 points)
+    ema = df["price"].ewm(span=10, adjust=False).mean().iloc[-1]  # Moyenne mobile exponentielle
+
+    # Liste des patterns
+    patterns = {}
+
+    # 1. Tendance linéaire
+    patterns["Trend"] = [last_price + i * trend for i in range(1, len(future_timestamps) + 1)]
+
+    # 2. Moyenne Mobile Simple
+    patterns["SMA"] = [sma] * len(future_timestamps)
+
+    # 3. Moyenne Mobile Exponentielle
+    patterns["EMA"] = [ema] * len(future_timestamps)
+
+    # 4. Cycle Répété
+    cycle_amplitude = (df["price"].max() - df["price"].min()) / 2
+    patterns["Cycle"] = [
+        last_price + cycle_amplitude * np.sin(2 * np.pi * i / len(future_timestamps))
+        for i in range(len(future_timestamps))
+    ]
+
+    # 5. Rebond
+    patterns["Rebound"] = [last_price + trend * (0.5 ** i) for i in range(len(future_timestamps))]
+
+    # 6. Effet Plateau
+    patterns["Plateau"] = [last_price] * len(future_timestamps)
+
+    # 7. Renversement de Tendance
+    reverse_trend = -trend
+    patterns["Reversal"] = [last_price + i * reverse_trend for i in range(len(future_timestamps))]
+
+    # 8. Récupération après Crash
+    mean_price = df["price"].mean()
+    patterns["Recovery"] = [last_price + (mean_price - last_price) * (i / len(future_timestamps)) for i in range(len(future_timestamps))]
+
+    # 9. Accélération de la Tendance
+    patterns["Acceleration"] = [last_price + (trend * 1.5) * i for i in range(len(future_timestamps))]
+
+    # 10. Volatilité Aléatoire
+    random_volatility = np.random.normal(0, trend * 0.5, len(future_timestamps))
+    patterns["Random"] = [last_price + sum(random_volatility[:i]) for i in range(len(future_timestamps))]
+
+    # Retourner les données des patterns avec leurs timestamps
+    pattern_dfs = {
+        pattern_name: pd.DataFrame({"timestamp": future_timestamps, "price": prices})
+        for pattern_name, prices in patterns.items()
+    }
+    return pattern_dfs
+
+# Partie graphique intégrant les patterns
 for coin, price_data in crypto_prices.items():
     if price_data:
         # Convertir les données en DataFrame
         df = pd.DataFrame(price_data, columns=["timestamp", "price"])
         df["timestamp"] = pd.to_datetime(df["timestamp"], unit="ms")
 
-        # Prédiction des 24 prochaines heures
-        future_df = predict_future_prices(price_data, future_hours=24)
+        # Générer les patterns de prédiction
+        patterns = predict_patterns(price_data, future_hours=24)
 
-        # Affichage du graphique
-        st.write(f"#### {coin} - Prix en {selected_currency}")
+        # Affichage des graphiques
+        st.write(f"#### {coin} - Prix et Prédictions en {selected_currency}")
         fig, ax = plt.subplots(figsize=(12, 6))
 
         # Graphique des prix réels
         ax.plot(df["timestamp"], df["price"], label="Prix réel", color="blue")
 
-        # Graphique des prédictions
-        ax.plot(future_df["timestamp"], future_df["price"], label="Prédiction (24h)", color="orange", linestyle="dashed")
+        # Affichage des prédictions
+        colors = ["orange", "green", "red", "purple", "brown", "pink", "cyan", "black", "gray", "magenta"]
+        for i, (pattern_name, pattern_df) in enumerate(patterns.items()):
+            ax.plot(
+                pattern_df["timestamp"],
+                pattern_df["price"],
+                label=f"Prédiction ({pattern_name})",
+                linestyle="dashed",
+                color=colors[i % len(colors)]
+            )
 
         # Ajustements
         ax.set_title(f"{coin} - Prix (48h réels + 24h prévus)")