Create app.py

app.py

@@ -0,0 +1,167 @@
+import streamlit as st
+import requests
+import pandas as pd
+import matplotlib.pyplot as plt
+import numpy as np
+from datetime import datetime, timedelta
+from sklearn.metrics import mean_squared_error
+
+# 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 un pattern similaire dans l'historique
+def find_similar_pattern(df, pred_data, window_size=5):
+    mse_scores = {}
+    for i in range(len(df) - window_size):
+        history_segment = df["price"].iloc[i:i + window_size].values
+        mse = mean_squared_error(history_segment, pred_data[:len(history_segment)])
+        mse_scores[i] = mse
+
+    # Trouver le segment avec le plus faible MSE
+    best_start_index = min(mse_scores, key=mse_scores.get)
+    similar_pattern = df["price"].iloc[best_start_index:best_start_index + window_size].values
+    return similar_pattern
+
+# Fonction pour générer une courbe dynamique basée sur les patterns passés
+def generate_dynamic_curve(df, initial_prediction, future_hours=24, window_size=5):
+    dynamic_curve = []
+    pred_data = initial_prediction[:window_size]  # Les premières données de la prédiction
+
+    # Générer une courbe en utilisant les patterns historiques de manière dynamique
+    for _ in range(future_hours // (window_size)):
+        similar_pattern = find_similar_pattern(df, pred_data, window_size)
+        dynamic_curve.extend(similar_pattern)  # Ajoute le pattern trouvé à la courbe
+        pred_data = similar_pattern  # Met à jour la prédiction avec le dernier pattern trouvé
+
+    return dynamic_curve
+
+# Configuration des dates
+end_time = datetime.now()
+start_time = end_time - timedelta(hours=48)
+
+# 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 la prédiction initiale (en jaune)
+        best_pattern_df = patterns[best_pattern]
+        ax.plot(
+            best_pattern_df["timestamp"],
+            best_pattern_df["price"],
+            label=f"Prédiction initiale ({best_pattern})",
+            linestyle="dashed",
+            color="yellow"
+        )
+
+        # Génère la courbe dynamique (en vert) basée sur les patterns historiques
+        dynamic_curve = generate_dynamic_curve(df, best_pattern_df["price"].values)
+        future_timestamps = pd.date_range(df["timestamp"].iloc[-1], periods=(24 * 60 // 15) + 1, freq="15T")
+        ax.plot(future_timestamps, dynamic_curve, label="Prédiction dynamique (basée sur historique)", linestyle="dashed", color="green")
+
+        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}")