Update app.py

app.py

@@ -1,48 +1,151 @@
 import streamlit as st
+import requests
 import pandas as pd
+import matplotlib.pyplot as plt
 import numpy as np
-import requests
+from datetime import datetime, timedelta
+from sklearn.metrics import mean_squared_error
 
-# Fonction pour obtenir les données de la crypto-monnaie via l'API CoinCap
-def get_crypto_data(crypto_symbol="bitcoin", lookback=30):
-    url = f"https://api.coincap.io/v2/assets/{crypto_symbol}/history?interval=m15"
-    response = requests.get(url)
-    data = response.json()
-
-    # Afficher les premières lignes des données retournées pour vérifier la structure
-    st.write("Données brutes de l'API CoinCap:", data)
-
-    if 'data' not in data:
-        st.error(f"Erreur : Impossible de récupérer les données pour {crypto_symbol}")
-        return pd.DataFrame()
-
-    # Vérifier la structure et s'assurer que les colonnes sont correctes
-    raw_data = data['data']
-    
-    if len(raw_data) == 0:
-        st.error("Aucune donnée disponible pour cette crypto-monnaie.")
-        return pd.DataFrame()
-
-    # Convertir les données en DataFrame et afficher les premières lignes pour vérifier la structure
-    df = pd.DataFrame(raw_data)
-    st.write("Données transformées en DataFrame:", df.head())
-
-    # Vérifier les noms de colonnes avant de procéder
-    if 'time' in df.columns:
-        df['timestamp'] = pd.to_datetime(df['time'], unit='ms')
-        df.set_index('timestamp', inplace=True)
-        df.drop(columns=['time'], inplace=True)  # Supprimer la colonne 'time' si nécessaire
-    else:
-        st.error("Le champ 'time' n'existe pas dans les données.")
-        return pd.DataFrame()
+# Fonction pour récupérer les prix historiques
+def get_crypto_prices(coins, start_time, end_time, interval='m15'):
+    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}")
+            st.write(response.text)  # Debug pour afficher l'erreur complète
+    return prices
+
+# Fonction pour prédire les tendances basées sur les patterns
+def predict_patterns(data, future_hours=24):
+    df = pd.DataFrame(data, columns=["timestamp", "price"])
+    df["timestamp"] = pd.to_datetime(df["timestamp"], unit="ms")
+    df.set_index("timestamp", inplace=True)
+
+    last_timestamp = df.index[-1]
+    future_timestamps = [last_timestamp + timedelta(minutes=15 * i) for i in range(1, (future_hours * 60 // 15) + 1)]
+
+    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]
+    ema = df["price"].ewm(span=10, adjust=False).mean().iloc[-1]
+    cycle_amplitude = (df["price"].max() - df["price"].min()) / 2
+    mean_price = df["price"].mean()
+
+    patterns = {}
+
+    patterns["Trend"] = [last_price + i * trend for i in range(1, len(future_timestamps) + 1)]
+    patterns["Reversal"] = [last_price - i * trend for i in range(1, len(future_timestamps) + 1)]
+    patterns["SMA"] = [sma] * len(future_timestamps)
+    patterns["EMA"] = [ema] * len(future_timestamps)
+    patterns["Cycle"] = [
+        last_price + cycle_amplitude * np.sin(2 * np.pi * i / len(future_timestamps))
+        for i in range(len(future_timestamps))
+    ]
+    patterns["Rebound"] = [last_price + trend * (0.5 ** i) for i in range(len(future_timestamps))]
+    patterns["Plateau"] = [last_price] * len(future_timestamps)
+    patterns["Breakout"] = [
+        last_price + (trend * 2 if i < len(future_timestamps) // 2 else -trend * 2)
+        for i in range(len(future_timestamps))
+    ]
+    patterns["Recovery"] = [last_price + (mean_price - last_price) * (i / len(future_timestamps)) for i in range(len(future_timestamps))]
+    patterns["Acceleration"] = [last_price + (trend * 1.5) * i for i in range(len(future_timestamps))]
+
+    pattern_dfs = {
+        pattern_name: pd.DataFrame({"timestamp": future_timestamps, "price": prices})
+        for pattern_name, prices in patterns.items()
+    }
+    return pattern_dfs
+
+# Fonction pour identifier le pattern le plus ressemblant
+def identify_best_pattern(df, patterns):
+    mse_scores = {}
+    actual_values = df["price"].values[-len(df) // 2:]  # Dernières heures
+
+    for pattern_name, pattern_df in patterns.items():
+        predicted_values = np.array(pattern_df["price"].values[:len(actual_values)])
+        min_length = min(len(actual_values), len(predicted_values))
+        mse = mean_squared_error(actual_values[:min_length], predicted_values[:min_length])
+        mse_scores[pattern_name] = mse
 
-    return df
+    # Sélection du pattern avec la MSE la plus faible
+    best_pattern = min(mse_scores, key=mse_scores.get)
+    return best_pattern
 
-# Exemple d'utilisation dans Streamlit
-crypto_symbol = "bitcoin"  # Vous pouvez changer cela pour d'autres cryptos comme 'ethereum'
-df = get_crypto_data(crypto_symbol)
+# Configuration des dates
+end_time = datetime.now()
+start_time = end_time - timedelta(hours=48)
 
-if not df.empty:
-    st.write("Données crypto:", df)
-else:
-    st.write("Pas de données à afficher.")
+# Liste des cryptos avec leurs IDs corrects sur CoinCap
+coins = {
+    "Bitcoin": "bitcoin",
+    "Ripple": "xrp",
+    "Ethereum": "ethereum",
+    "Tether": "tether",
+    "Stellar": "stellar"
+}
+
+# Récupération des prix
+crypto_prices = get_crypto_prices(coins, start_time, end_time)
+
+# Affichage des graphiques
+st.title("Analyse et Prédictions des Cryptos avec Patterns")
+for coin, price_data in crypto_prices.items():
+    if price_data:
+        df = pd.DataFrame(price_data, columns=["timestamp", "price"])
+        df["timestamp"] = pd.to_datetime(df["timestamp"], unit="ms")
+
+        patterns = predict_patterns(price_data, future_hours=24)
+        best_pattern = identify_best_pattern(df, patterns)
+
+        st.write(f"#### {coin} - Prix et Prédictions")
+        fig, ax = plt.subplots(figsize=(12, 6))
+        ax.plot(df["timestamp"], df["price"], label="Prix réel", color="blue")
+
+        # Affiche uniquement le meilleur pattern
+        best_pattern_df = patterns[best_pattern]
+        ax.plot(
+            best_pattern_df["timestamp"],
+            best_pattern_df["price"],
+            label=f"Prédiction ({best_pattern})",
+            linestyle="dashed",
+            color="orange"
+        )
+
+        ax.set_title(f"{coin} - Prix (48h réels + 24h prévu avec {best_pattern})")
+        ax.set_xlabel("Temps")
+        ax.set_ylabel("Prix (USD)")
+        ax.legend()
+        st.pyplot(fig)
+
+        # Texte explicatif du pattern choisi
+        explanation = {
+            "Trend": "Ce pattern indique que le prix continue sur la tendance actuelle, il suit la direction des prix précédents.",
+            "Reversal": "Ce pattern suggère que le prix pourrait inverser la tendance actuelle, en suivant la direction opposée.",
+            "SMA": "Le prix pourrait se stabiliser autour de la moyenne mobile simple (SMA), une approximation de la tendance générale.",
+            "EMA": "Ce pattern suit la moyenne mobile exponentielle (EMA), qui réagit plus rapidement aux changements de prix.",
+            "Cycle": "Le pattern de cycle suppose une oscillation autour d'un point central, représentant des mouvements de prix cycliques.",
+            "Rebound": "Le prix pourrait rebondir après avoir montré des signes de ralentissement, suivant une courbe d'amortissement.",
+            "Plateau": "Ce pattern suggère que le prix restera relativement stable et horizontal, sans mouvements majeurs.",
+            "Breakout": "Le breakout indique une rupture de la tendance actuelle, avec une direction plus forte dans une des deux directions.",
+            "Recovery": "Le pattern de récupération suggère que le prix pourrait revenir à sa moyenne historique après une variation importante.",
+            "Acceleration": "L'accélération suggère un mouvement rapide des prix, souvent après une période de stagnation ou de consolidation."
+        }
+
+        # Afficher l'explication sous le graphique
+        st.write(f"### Explication du pattern ({best_pattern}):")
+        st.write(explanation[best_pattern])
+
+    else:
+        st.warning(f"Aucune donnée disponible pour {coin}")