Update app.py

app.py

@@ -1,188 +1,48 @@
+import streamlit as st
 import pandas as pd
 import numpy as np
-from datetime import timedelta
-from sklearn.metrics import mean_squared_error
-import streamlit as st
 import requests
 
-# Fonction pour récupérer les taux des cryptomonnaies via l'API CoinCap
-def get_crypto_data(crypto_symbol="bitcoin", limit=100):
-    url = f"https://api.coincap.io/v2/assets/{crypto_symbol}/history?interval=m15
+# 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)
-    
-    if response.status_code == 200:
-        data = response.json()['data']
-        df = pd.DataFrame(data)
-        df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')
-        df['price'] = pd.to_numeric(df['price'])
-        df.set_index('timestamp', inplace=True)
-        return df
-    else:
-        st.error("Erreur lors de la récupération des données de l'API CoinCap.")
-        return None
-
-# 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 = {}
+    data = response.json()
 
-    # 10 patterns précédents
-    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))]
+    # 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)
 
-    # 20 nouveaux patterns
-    patterns["Descending Triangle"] = [
-        last_price - (i * 0.1 * cycle_amplitude) for i in range(len(future_timestamps))
-    ]
-    patterns["Ascending Triangle"] = [
-        last_price + (i * 0.1 * cycle_amplitude) for i in range(len(future_timestamps))
-    ]
-    patterns["Double Top"] = [
-        last_price + cycle_amplitude * (-1 if i < len(future_timestamps) // 2 else 1)
-        for i in range(len(future_timestamps))
-    ]
-    patterns["Double Bottom"] = [
-        last_price - cycle_amplitude * (1 if i < len(future_timestamps) // 2 else -1)
-        for i in range(len(future_timestamps))
-    ]
-    patterns["Head and Shoulders"] = [
-        last_price + cycle_amplitude * (1 if (i % 10 < 3 or i % 10 > 6) else -1)
-        for i in range(len(future_timestamps))
-    ]
-    patterns["Inverse Head and Shoulders"] = [
-        last_price - cycle_amplitude * (1 if (i % 10 < 3 or i % 10 > 6) else -1)
-        for i in range(len(future_timestamps))
-    ]
-    patterns["Flag Pattern"] = [
-        last_price + trend * (0.3 * np.sin(2 * np.pi * i / len(future_timestamps)))
-        for i in range(len(future_timestamps))
-    ]
-    patterns["Cup and Handle"] = [
-        last_price + (np.sqrt(i) if i < len(future_timestamps) * 0.7 else 0)
-        for i in range(len(future_timestamps))
-    ]
-    patterns["Pennant"] = [
-        last_price + (cycle_amplitude / (i + 1)) for i in range(len(future_timestamps))
-    ]
-    patterns["Wedge Up"] = [
-        last_price + (cycle_amplitude * 0.5 * (1 + np.sin(i))) for i in range(len(future_timestamps))
-    ]
-    patterns["Wedge Down"] = [
-        last_price - (cycle_amplitude * 0.5 * (1 + np.sin(i))) for i in range(len(future_timestamps))
-    ]
-    patterns["Triple Top"] = [
-        last_price + cycle_amplitude * (-1 if i % 15 < 5 else 1)
-        for i in range(len(future_timestamps))
-    ]
-    patterns["Triple Bottom"] = [
-        last_price - cycle_amplitude * (1 if i % 15 < 5 else -1)
-        for i in range(len(future_timestamps))
-    ]
-    patterns["Falling Channel"] = [
-        last_price - trend * i for i in range(len(future_timestamps))
-    ]
-    patterns["Rising Channel"] = [
-        last_price + trend * i for i in range(len(future_timestamps))
-    ]
-    patterns["Symmetrical Triangle"] = [
-        last_price + cycle_amplitude * (np.sin(i) * (1 - i / len(future_timestamps)))
-        for i in range(len(future_timestamps))
-    ]
-    patterns["Rounding Bottom"] = [
-        last_price + cycle_amplitude * (np.sqrt(i / len(future_timestamps)))
-        for i in range(len(future_timestamps))
-    ]
-    patterns["Broadening Formation"] = [
-        last_price + cycle_amplitude * (1 + i / len(future_timestamps))
-        for i in range(len(future_timestamps))
-    ]
-    patterns["Rectangle"] = [
-        last_price + (cycle_amplitude * (-1 if i % 20 < 10 else 1))
-        for i in range(len(future_timestamps))
-    ]
+    if 'data' not in data:
+        st.error(f"Erreur : Impossible de récupérer les données pour {crypto_symbol}")
+        return pd.DataFrame()
 
-    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 meilleur pattern basé sur la MSE (Mean Squared Error)
-def identify_best_pattern(df, patterns):
-    actual_values = df["price"].values
-    mse_values = {}
-
-    for pattern_name, pattern_df in patterns.items():
-        predicted_values = pattern_df["price"].values
-
-        # Limiter la longueur des prédictions pour éviter des séries trop longues
-        if len(predicted_values) > len(actual_values):
-            predicted_values = predicted_values[:len(actual_values)]
-        
-        # Assurez-vous que les longueurs sont identiques
-        if len(actual_values) != len(predicted_values):
-            st.warning(f"Avertissement : Longueur des séries différentes pour le pattern {pattern_name}.")
-            continue
-        
-        mse = mean_squared_error(actual_values, predicted_values)
-        mse_values[pattern_name] = mse
+    # Vérifier la structure et s'assurer que les colonnes sont correctes
+    raw_data = data['data']
     
-    if mse_values:
-        best_pattern = min(mse_values, key=mse_values.get)
-        return best_pattern, patterns[best_pattern]
-    else:
-        st.error("Aucun pattern valide n'a été trouvé.")
-        return None, None
-
-# Interface utilisateur Streamlit
-st.title("Analyse des tendances de prix de Cryptomonnaies")
+    if len(raw_data) == 0:
+        st.error("Aucune donnée disponible pour cette crypto-monnaie.")
+        return pd.DataFrame()
 
-# Sélection de la cryptomonnaie
-crypto_symbol = st.selectbox("Sélectionnez la cryptomonnaie", ["bitcoin", "ethereum", "litecoin", "dogecoin"])
+    # 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())
 
-# Récupérer les données de la cryptomonnaie via l'API CoinCap
-df = get_crypto_data(crypto_symbol=crypto_symbol)
-
-if df is not None:
-    # Affichage des données récupérées
-    st.write(f"Données de {crypto_symbol.upper()}")
-    st.write(df)
+    # 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()
 
-    # Prédiction des patterns
-    patterns = predict_patterns(df[['timestamp', 'price']].values.tolist())
+    return df
 
-    # Identification du meilleur pattern
-    best_pattern_name, best_pattern_df = identify_best_pattern(df, patterns)
+# Exemple d'utilisation dans Streamlit
+crypto_symbol = "bitcoin"  # Vous pouvez changer cela pour d'autres cryptos comme 'ethereum'
+df = get_crypto_data(crypto_symbol)
 
-    if best_pattern_name:
-        st.write(f"Le meilleur pattern pour {crypto_symbol.upper()} est : {best_pattern_name}")
-        st.write(best_pattern_df)
-    else:
-        st.write("Aucun pattern n'a été identifié.")
+if not df.empty:
+    st.write("Données crypto:", df)
+else:
+    st.write("Pas de données à afficher.")