Update app.py

app.py

@@ -1,21 +1,346 @@
-**ETH Pump/Dump Probabilities (Next 12 Hours):**
-- RSI: Pump: 90.00%, Dump: 0.00%
-- MACD: Pump: 60.00%, Dump: 0.00%
-- EMA: Pump: 90.00%, Dump: 0.00%
-- ATR: Pump: 60.00%, Dump: 0.00%
-
-**Price Predictions (Next 7 Days):**
-Date         Price
-October 10   1800.00
-October 11   1850.00
-October 12   1900.00
-October 13   1950.00
-October 14   2000.00
-
-**Latest Crypto News Sentiment:**
-- **Ethereum Price Surges to New Highs** (Bullish) - October 10
-  [Read more](https://example.com/eth-price-surge)
-- **Ethereum Faces Resistance at $2000** (Bearish) - October 9
-  [Read more](https://example.com/eth-resistance)
-- **Ethereum Developers Announce Major Upgrade** (Neutral) - October 8
-  [Read more](https://example.com/eth-upgrade)
+import gradio as gr
+import yfinance as yf
+import pandas as pd
+import numpy as np
+from datetime import datetime, timedelta
+import feedparser
+from textblob import TextBlob
+from statsmodels.tsa.holtwinters import ExponentialSmoothing
+
+# Function to fetch cryptocurrency data
+def get_crypto_data(symbol, period="30d", interval="1h"):
+    crypto = yf.Ticker(f"{symbol}-USD")
+    data = crypto.history(period=period, interval=interval)
+    return data
+
+# Function to calculate RSI
+def calculate_rsi(data, period=14):
+    delta = data['Close'].diff()
+    gain = (delta.where(delta > 0, 0)).rolling(window=period).mean()
+    loss = (-delta.where(delta < 0, 0)).rolling(window=period).mean()
+    rs = gain / loss
+    rsi = 100 - (100 / (1 + rs))
+    return rsi
+
+# Function to calculate MACD
+def calculate_macd(data, short_window=12, long_window=26, signal_window=9):
+    short_ema = data['Close'].ewm(span=short_window, adjust=False).mean()
+    long_ema = data['Close'].ewm(span=long_window, adjust=False).mean()
+    macd = short_ema - long_ema
+    signal = macd.ewm(span=signal_window, adjust=False).mean()
+    return macd, signal
+
+# Function to calculate EMA
+def calculate_ema(data, period=20):
+    return data['Close'].ewm(span=period, adjust=False).mean()
+
+# Function to calculate ATR
+def calculate_atr(data, period=14):
+    high_low = data['High'] - data['Low']
+    high_close = np.abs(data['High'] - data['Close'].shift())
+    low_close = np.abs(data['Low'] - data['Close'].shift())
+    true_range = pd.concat([high_low, high_close, low_close], axis=1).max(axis=1)
+    atr = true_range.rolling(window=period).mean()
+    return atr
+
+# Function to calculate Stochastic Oscillator
+def calculate_stochastic(data, period=14):
+    high = data['High'].rolling(window=period).max()
+    low = data['Low'].rolling(window=period).min()
+    stoch_k = 100 * ((data['Close'] - low) / (high - low))
+    stoch_d = stoch_k.rolling(window=3).mean()
+    return stoch_k, stoch_d
+
+# Function to calculate Bollinger Bands
+def calculate_bollinger_bands(data, period=20, std_dev=2):
+    sma = data['Close'].rolling(window=period).mean()
+    std = data['Close'].rolling(window=period).std()
+    upper_band = sma + (std * std_dev)
+    lower_band = sma - (std * std_dev)
+    return upper_band, lower_band
+
+# Function to calculate On-Balance Volume (OBV)
+def calculate_obv(data):
+    obv = (np.sign(data['Close'].diff()) * data['Volume']).cumsum()
+    return obv
+
+# Function to calculate Average Directional Index (ADX)
+def calculate_adx(data, period=14):
+    high = data['High']
+    low = data['Low']
+    close = data['Close']
+    
+    # Calculate +DM and -DM
+    plus_dm = high.diff()
+    minus_dm = -low.diff()
+    plus_dm[plus_dm < 0] = 0
+    minus_dm[minus_dm < 0] = 0
+    
+    # Calculate True Range (TR)
+    tr = pd.concat([high - low, abs(high - close.shift()), abs(low - close.shift())], axis=1).max(axis=1)
+    
+    # Calculate +DI and -DI
+    plus_di = 100 * (plus_dm.ewm(alpha=1/period).mean() / tr.ewm(alpha=1/period).mean())
+    minus_di = 100 * (minus_dm.ewm(alpha=1/period).mean() / tr.ewm(alpha=1/period).mean())
+    
+    # Calculate ADX
+    dx = 100 * abs(plus_di - minus_di) / (plus_di + minus_di)
+    adx = dx.ewm(alpha=1/period).mean()
+    return adx
+
+# Function to calculate Fibonacci Retracement levels
+def calculate_fibonacci_levels(data):
+    high = data['High'].max()
+    low = data['Low'].min()
+    diff = high - low
+    return {
+        "23.6%": high - diff * 0.236,
+        "38.2%": high - diff * 0.382,
+        "50%": high - diff * 0.5,
+        "61.8%": high - diff * 0.618,
+        "78.6%": high - diff * 0.786,
+    }
+
+# Function to calculate probabilities for the next 12 hours
+def calculate_probabilities(data):
+    # Calculate indicators on the entire dataset
+    data['RSI'] = calculate_rsi(data)
+    data['MACD'], data['MACD_Signal'] = calculate_macd(data)
+    data['EMA_50'] = calculate_ema(data, period=50)
+    data['EMA_200'] = calculate_ema(data, period=200)
+    data['ATR'] = calculate_atr(data)
+    data['Stoch_K'], data['Stoch_D'] = calculate_stochastic(data)
+    data['Upper_Band'], data['Lower_Band'] = calculate_bollinger_bands(data)
+    data['OBV'] = calculate_obv(data)
+    data['ADX'] = calculate_adx(data)
+    
+    # Use the most recent values for predictions
+    recent_data = data.iloc[-1]
+    
+    # Calculate probabilities based on recent data
+    probabilities = {
+        "RSI": {"Pump": 0, "Dump": 0},
+        "MACD": {"Pump": 0, "Dump": 0},
+        "EMA": {"Pump": 0, "Dump": 0},
+        "ATR": {"Pump": 0, "Dump": 0},
+        "Stochastic": {"Pump": 0, "Dump": 0},
+        "Bollinger Bands": {"Pump": 0, "Dump": 0},
+        "OBV": {"Pump": 0, "Dump": 0},
+        "ADX": {"Pump": 0, "Dump": 0},
+    }
+    
+    # RSI
+    rsi = recent_data['RSI']
+    if rsi < 25:
+        probabilities["RSI"]["Pump"] = 90  # Strong Pump
+    elif 25 <= rsi < 30:
+        probabilities["RSI"]["Pump"] = 60  # Moderate Pump
+    elif 70 < rsi <= 75:
+        probabilities["RSI"]["Dump"] = 60  # Moderate Dump
+    elif rsi > 75:
+        probabilities["RSI"]["Dump"] = 90  # Strong Dump
+    
+    # MACD
+    macd = recent_data['MACD']
+    macd_signal = recent_data['MACD_Signal']
+    if macd > macd_signal and macd > 0:
+        probabilities["MACD"]["Pump"] = 90  # Strong Pump
+    elif macd > macd_signal and macd <= 0:
+        probabilities["MACD"]["Pump"] = 60  # Moderate Pump
+    elif macd < macd_signal and macd >= 0:
+        probabilities["MACD"]["Dump"] = 60  # Moderate Dump
+    elif macd < macd_signal and macd < 0:
+        probabilities["MACD"]["Dump"] = 90  # Strong Dump
+    
+    # EMA
+    ema_short = recent_data['EMA_50']
+    ema_long = recent_data['EMA_200']
+    close = recent_data['Close']
+    if ema_short > ema_long and close > ema_short:
+        probabilities["EMA"]["Pump"] = 90  # Strong Pump
+    elif ema_short > ema_long and close <= ema_short:
+        probabilities["EMA"]["Pump"] = 60  # Moderate Pump
+    elif ema_short < ema_long and close >= ema_short:
+        probabilities["EMA"]["Dump"] = 60  # Moderate Dump
+    elif ema_short < ema_long and close < ema_short:
+        probabilities["EMA"]["Dump"] = 90  # Strong Dump
+    
+    # ATR
+    atr = recent_data['ATR']
+    if atr > 100:
+        probabilities["ATR"]["Pump"] = 90  # Strong Pump
+    elif 50 < atr <= 100:
+        probabilities["ATR"]["Pump"] = 60  # Moderate Pump
+    elif -100 <= atr < -50:
+        probabilities["ATR"]["Dump"] = 60  # Moderate Dump
+    elif atr < -100:
+        probabilities["ATR"]["Dump"] = 90  # Strong Dump
+    
+    # Stochastic Oscillator
+    stoch_k = recent_data['Stoch_K']
+    stoch_d = recent_data['Stoch_D']
+    if stoch_k < 20 and stoch_d < 20:
+        probabilities["Stochastic"]["Pump"] = 90  # Strong Pump
+    elif 20 <= stoch_k < 30 and 20 <= stoch_d < 30:
+        probabilities["Stochastic"]["Pump"] = 60  # Moderate Pump
+    elif 70 < stoch_k <= 80 and 70 < stoch_d <= 80:
+        probabilities["Stochastic"]["Dump"] = 60  # Moderate Dump
+    elif stoch_k > 80 and stoch_d > 80:
+        probabilities["Stochastic"]["Dump"] = 90  # Strong Dump
+    
+    # Bollinger Bands
+    close = recent_data['Close']
+    upper_band = recent_data['Upper_Band']
+    lower_band = recent_data['Lower_Band']
+    if close <= lower_band:
+        probabilities["Bollinger Bands"]["Pump"] = 90  # Strong Pump
+    elif lower_band < close <= lower_band * 1.05:
+        probabilities["Bollinger Bands"]["Pump"] = 60  # Moderate Pump
+    elif upper_band * 0.95 <= close < upper_band:
+        probabilities["Bollinger Bands"]["Dump"] = 60  # Moderate Dump
+    elif close >= upper_band:
+        probabilities["Bollinger Bands"]["Dump"] = 90  # Strong Dump
+    
+    # OBV
+    obv = recent_data['OBV']
+    if obv > 100000:
+        probabilities["OBV"]["Pump"] = 90  # Strong Pump
+    elif 50000 < obv <= 100000:
+        probabilities["OBV"]["Pump"] = 60  # Moderate Pump
+    elif -100000 <= obv < -50000:
+        probabilities["OBV"]["Dump"] = 60  # Moderate Dump
+    elif obv < -100000:
+        probabilities["OBV"]["Dump"] = 90  # Strong Dump
+    
+    # ADX
+    adx = recent_data['ADX']
+    if adx > 25:
+        probabilities["ADX"]["Pump"] = 90  # Strong Pump
+    elif 20 < adx <= 25:
+        probabilities["ADX"]["Pump"] = 60  # Moderate Pump
+    elif 15 < adx <= 20:
+        probabilities["ADX"]["Dump"] = 60  # Moderate Dump
+    elif adx <= 15:
+        probabilities["ADX"]["Dump"] = 90  # Strong Dump
+    
+    return probabilities, recent_data
+
+# Function to predict future prices using Exponential Smoothing
+def predict_price(data, days=7):
+    try:
+        # Prepare data for Exponential Smoothing
+        df = data[['Close']]
+        
+        # Train the model
+        model = ExponentialSmoothing(df, trend="add", seasonal="add", seasonal_periods=7)
+        fit = model.fit()
+        
+        # Make future predictions
+        forecast = fit.forecast(steps=days)
+        
+        # Format predictions with dates
+        last_date = data.index[-1]
+        dates = pd.date_range(start=last_date + timedelta(days=1), periods=days)
+        forecast_df = pd.DataFrame({"Date": dates, "Price": forecast})
+        forecast_df["Date"] = forecast_df["Date"].dt.strftime("%B %d")  # Format as "Month Day"
+        forecast_df["Price"] = forecast_df["Price"].round(2)
+        
+        return forecast_df
+    except Exception as e:
+        return f"Error predicting prices: {e}"
+
+# Function to fetch news from top 5 crypto news sites and perform sentiment analysis
+def fetch_crypto_news(symbol):
+    try:
+        # List of RSS feeds for top 5 crypto news sites
+        rss_feeds = [
+            "https://coindesk.com/feed/",
+            "https://cointelegraph.com/rss",
+            "https://cryptoslate.com/feed/",
+            "https://www.newsbtc.com/feed/",
+            "https://news.bitcoin.com/feed/"
+        ]
+        
+        news_items = []
+        for feed_url in rss_feeds:
+            feed = feedparser.parse(feed_url)
+            for entry in feed.entries[:5]:  # Limit to 5 articles per site
+                if symbol.lower() in entry.title.lower() or symbol.lower() in entry.summary.lower():
+                    # Perform sentiment analysis on the article title
+                    analysis = TextBlob(entry.title)
+                    sentiment = "Bullish" if analysis.sentiment.polarity > 0 else "Bearish" if analysis.sentiment.polarity < 0 else "Neutral"
+                    
+                    # Format the date as "Month Day"
+                    published_date = datetime.strptime(entry.published, "%a, %d %b %Y %H:%M:%S %z").strftime("%B %d")
+                    
+                    news_items.append({
+                        "title": entry.title,
+                        "link": entry.link,
+                        "sentiment": sentiment,
+                        "published": published_date,
+                    })
+        return news_items[:5]  # Return top 5 articles
+    except Exception as e:
+        return f"Error fetching crypto news: {e}"
+
+# Gradio Interface
+def crypto_app(symbol):
+    if symbol:
+        # Fetch data
+        data = get_crypto_data(symbol)
+        if data.empty:
+            return f"No data found for {symbol}. Please check the symbol and try again."
+        else:
+            # Ensure the DataFrame has enough rows
+            if len(data) < 20:
+                return f"Not enough data to calculate indicators. Only {len(data)} rows available. Please try a longer period."
+            else:
+                # Calculate probabilities for the next 12 hours
+                probabilities, recent_data = calculate_probabilities(data)
+                
+                # Predict future prices
+                price_predictions = predict_price(data)
+                
+                # Fetch crypto news and sentiment
+                news_items = fetch_crypto_news(symbol)
+                
+                # Calculate Fibonacci Retracement levels
+                fib_levels = calculate_fibonacci_levels(data)
+                
+                # Prepare output
+                output = f"**{symbol} Pump/Dump Probabilities (Next 12 Hours):**\n"
+                for indicator, values in probabilities.items():
+                    output += f"- **{indicator}**: Pump: {values['Pump']:.2f}%, Dump: {values['Dump']:.2f}%\n"
+                
+                output += "\n**Price Predictions (Next 7 Days):**\n"
+                if isinstance(price_predictions, pd.DataFrame):
+                    output += price_predictions.to_string(index=False)
+                else:
+                    output += price_predictions
+                
+                output += "\n\n**Fibonacci Retracement Levels:**\n"
+                for level, price in fib_levels.items():
+                    output += f"- **{level}**: ${price:.2f}\n"
+                
+                output += "\n**Latest Crypto News Sentiment:**\n"
+                if isinstance(news_items, list):
+                    for news in news_items:
+                        output += f"- **{news['title']}** ({news['sentiment']}) - {news['published']}\n"
+                        output += f"  [Read more]({news['link']})\n"
+                else:
+                    output += news_items
+                
+                return output
+    else:
+        return "Please enter a cryptocurrency symbol."
+
+# Gradio Interface
+iface = gr.Interface(
+    fn=crypto_app,
+    inputs=gr.Textbox(placeholder="Enter cryptocurrency symbol (e.g., ETH, BTC)"),
+    outputs="text",
+    title="Crypto Information Finder and Pump/Dump Predictor 📈📉",
+    description="This app provides technical indicator-based predictions, price forecasts, and sentiment analysis for any cryptocurrency.",
+)
+
+iface.launch()