Update App.py

App.py

@@ -1,97 +1,51 @@
-import requests
-import pandas as pd
-import numpy as np
-from sklearn.ensemble import RandomForestClassifier
-from textblob import TextBlob
-import tweepy
-import time
-
-class ExplosiveGrowthBot:
-    def __init__(self):
-        self.api_key = "YOUR_BINANCE_API_KEY"
-        self.base_url = "https://api.binance.com"
-        self.model = RandomForestClassifier()
-        self.data = pd.DataFrame()
-        self.twitter_api = self.setup_twitter_api()
-
-    def setup_twitter_api(self):
-        """Set up Twitter API for sentiment analysis."""
-        consumer_key = "YOUR_TWITTER_CONSUMER_KEY"
-        consumer_secret = "YOUR_TWITTER_CONSUMER_SECRET"
-        access_token = "YOUR_TWITTER_ACCESS_TOKEN"
-        access_token_secret = "YOUR_TWITTER_ACCESS_SECRET"
-
-        auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
-        auth.set_access_token(access_token, access_token_secret)
-        return tweepy.API(auth)
-
-    def fetch_market_data(self, symbol="BTCUSDT", interval="1h", limit=100):
-        """Fetch historical market data from Binance."""
-        url = f"{self.base_url}/api/v3/klines"
-        params = {"symbol": symbol, "interval": interval, "limit": limit}
-        response = requests.get(url, params=params)
-        if response.status_code == 200:
-            data = response.json()
-            df = pd.DataFrame(data, columns=["timestamp", "open", "high", "low", "close", "volume", "_", "_", "_", "_", "_"])
-            df["close"] = df["close"].astype(float)
-            df["volume"] = df["volume"].astype(float)
-            return df
+import gradio as gr
+from src.data_fetcher import fetch_crypto_data, fetch_stock_data, fetch_sentiment_data
+from src.model import train_model, predict_growth
+from src.visualizer import plot_price_trends, plot_sentiment_trends
+
+def analyze_asset(asset_type, symbol):
+    """
+    Analyze a stock or cryptocurrency symbol.
+    Fetches market data, performs sentiment analysis,
+    trains AI model, and provides predictions with visualizations.
+    """
+    try:
+        if asset_type == "Crypto":
+            market_data = fetch_crypto_data(symbol)
+        elif asset_type == "Stock":
+            market_data = fetch_stock_data(symbol)
         else:
-            print("Error fetching market data:", response.text)
-            return None
-
-    def analyze_sentiment(self, keyword):
-        """Analyze sentiment from Twitter."""
-        tweets = self.twitter_api.search_tweets(q=keyword, count=100, lang="en")
-        sentiments = []
-        for tweet in tweets:
-            analysis = TextBlob(tweet.text)
-            sentiments.append(analysis.sentiment.polarity)
-        return np.mean(sentiments)
-
-    def train_model(self, df):
-        """Train the AI model to predict explosive growth."""
-        df["target"] = (df["close"].pct_change() > 0.05).astype(int)  # Label: 1 if price increased by >5%
-        features = df[["close", "volume"]].dropna()
-        target = df["target"].dropna()
-        self.model.fit(features[:-1], target)
-
-    def predict_growth(self, latest_data):
-        """Predict whether the asset will experience explosive growth."""
-        prediction = self.model.predict([latest_data])
-        return prediction[0]
-
-    def execute_trade(self, symbol, action):
-        """Simulate trade execution."""
-        print(f"Executing {action} trade for {symbol}...")
-
-    def run(self):
-        """Main loop for the bot."""
-        symbols_to_watch = ["BTCUSDT", "ETHUSDT", "DOGEUSDT"]
-        
-        while True:
-            for symbol in symbols_to_watch:
-                # Fetch market data
-                df = self.fetch_market_data(symbol=symbol)
-                if df is not None:
-                    # Analyze sentiment
-                    sentiment_score = self.analyze_sentiment(symbol.replace("USDT", ""))
-                    print(f"Sentiment score for {symbol}: {sentiment_score}")
-
-                    # Train model and make predictions
-                    self.train_model(df)
-                    latest_data = df.iloc[-1][["close", "volume"]].values
-                    prediction = self.predict_growth(latest_data)
-
-                    # Decision-making based on prediction and sentiment
-                    if prediction == 1 and sentiment_score > 0.5:  # Strong buy signal
-                        self.execute_trade(symbol, "BUY")
-                    elif prediction == 0 and sentiment_score < -0.5:  # Strong sell signal
-                        self.execute_trade(symbol, "SELL")
-
-            time.sleep(300)  # Wait 5 minutes before checking again
-
-if __name__ == "__main__":
-    bot = ExplosiveGrowthBot()
-    bot.run()
-    
+            return "Invalid asset type."
+
+        sentiment_score = fetch_sentiment_data(symbol)
+        train_model(market_data)
+        latest_data = market_data.iloc[-1][["close", "volume"]].values.tolist()
+        prediction = predict_growth(latest_data)
+
+        price_plot = plot_price_trends(market_data)
+        sentiment_plot = plot_sentiment_trends(symbol)
+
+        action = "BUY" if prediction == 1 else "SELL"
+        result = {
+            "Symbol": symbol,
+            "Sentiment Score": f"{sentiment_score:.2f}",
+            "Prediction": action,
+            "Visualizations": [price_plot, sentiment_plot],
+        }
+        return result
+
+    except Exception as e:
+        return {"Error": str(e)}
+
+# Gradio Interface
+asset_type_input = gr.Radio(["Crypto", "Stock"], label="Asset Type")
+symbol_input = gr.Textbox(label="Enter Symbol (e.g., BTCUSDT or AAPL)")
+output_result = gr.JSON(label="Analysis Results")
+
+gr.Interface(
+    fn=analyze_asset,
+    inputs=[asset_type_input, symbol_input],
+    outputs=output_result,
+    title="Explosive Growth Bot",
+    description="Predicts explosive growth in stocks and cryptocurrencies using AI.",
+).launch()