Update app.py

app.py

@@ -1,85 +1,97 @@
-# Fonction pour appliquer différents patterns
+import streamlit as st
+import requests
+import pandas as pd
+import matplotlib.pyplot as plt
+import numpy as np
+from datetime import datetime, timedelta
+
+# Fonction pour récupérer les prix
+def get_crypto_prices(coins, start_time, end_time, interval='m15', currency='usd'):
+    prices = {}
+    for coin, coin_id in coins.items():
+        url = f'https://api.coincap.io/v2/assets/{coin_id}/history'
+        params = {
+            'interval': interval,
+            'start': int(start_time.timestamp() * 1000),
+            '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]
+            if data:
+                prices[coin].append([int(end_time.timestamp() * 1000), float(data[-1]['priceUsd'])])
+        else:
+            st.error(f"Erreur lors de la récupération des prix pour {coin}: {response.status_code}")
+    return prices
+
+# Fonction pour générer des prédictions basées sur des 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)
 
-    # 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)]
 
-    # Calculer des métriques utiles
     last_price = df["price"].iloc[-1]
     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
+    sma = df["price"].rolling(window=10).mean().iloc[-1]
+    ema = df["price"].ewm(span=10, adjust=False).mean().iloc[-1]
 
-    # 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
+    patterns["Reversal"] = [last_price + i * -trend for i in range(len(future_timestamps))]
     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
+# Configuration des dates
+end_time = datetime.now()
+start_time = end_time - timedelta(hours=48)
+
+# Liste des cryptos
+coins = {
+    "Bitcoin": "bitcoin",
+    "Ripple": "ripple",
+    "Ethereum": "ethereum",
+    "Tether": "tether",
+    "Stellar": "stellar"
+}
+
+# Récupération des prix
+crypto_prices = get_crypto_prices(coins, start_time, end_time)
+
+# Affichage des graphiques
 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")
 
-        # Générer les patterns de prédiction
         patterns = predict_patterns(price_data, future_hours=24)
 
-        # Affichage des graphiques
-        st.write(f"#### {coin} - Prix et Prédictions en {selected_currency}")
+        st.write(f"#### {coin} - Prix et Prédictions")
         fig, ax = plt.subplots(figsize=(12, 6))
-
-        # Graphique des prix réels
         ax.plot(df["timestamp"], df["price"], label="Prix réel", color="blue")
 
-        # 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(
@@ -90,12 +102,10 @@ for coin, price_data in crypto_prices.items():
                 color=colors[i % len(colors)]
             )
 
-        # Ajustements
         ax.set_title(f"{coin} - Prix (48h réels + 24h prévus)")
         ax.set_xlabel("Temps")
-        ax.set_ylabel(f"Prix en {selected_currency}")
+        ax.set_ylabel("Prix (USD)")
         ax.legend()
-
         st.pyplot(fig)
     else:
         st.warning(f"Aucune donnée disponible pour {coin}")