Update app.py

app.py

@@ -1,12 +1,14 @@
+# app.py
 import gradio as gr
 import pandas as pd
-import requests
+import numpy as np
 from prophet import Prophet
 import plotly.graph_objs as go
 import math
-import numpy as np
-from data_fetcher import fetch_crypto_data, fetch_stock_data, fetch_sentiment_data  # Import the data fetcher module
-from src.model import train_model, predict_growth  # Import your model functions
+import requests  # For API calls
+from sklearn.ensemble import RandomForestClassifier  # For the model
+from textblob import TextBlob  # For sentiment analysis (optional)
+
 
 # --- Replace with your Alpha Vantage API key ---
 ALPHA_VANTAGE_API_KEY = "YOUR_ALPHA_VANTAGE_API_KEY"  # <--- Replace with your key
@@ -16,6 +18,63 @@ CRYPTO_SYMBOLS = ["BTCUSDT", "ETHUSDT"]
 STOCK_SYMBOLS = ["AAPL", "MSFT"]
 INTERVAL_OPTIONS = ["1h", "60min"]  # Consistent naming
 
+# --- Data Fetching Functions ---
+def fetch_crypto_data(symbol, interval="1h", limit=100):
+    """Fetch crypto market data from Binance."""
+    try:
+        url = f"https://api.binance.com/api/v3/klines"
+        params = {"symbol": symbol, "interval": interval, "limit": limit}
+        response = requests.get(url, params=params)
+        response.raise_for_status()  # Raise HTTPError for bad responses (4xx or 5xx)
+        data = response.json()
+        df = pd.DataFrame(data, columns=["timestamp", "open", "high", "low", "close", "volume"])
+        df["timestamp"] = pd.to_datetime(df["timestamp"], unit="ms")
+        df[["open", "high", "low", "close", "volume"]] = df[["open", "high", "low", "close", "volume"]].astype(float)
+        return df.dropna()
+    except requests.exceptions.RequestException as e:
+        raise Exception(f"Error fetching crypto data: {e}")
+    except (ValueError, KeyError) as e:
+        raise Exception(f"Error parsing crypto data: {e}")
+
+
+def fetch_stock_data(symbol, interval="60min"):
+    """Fetch stock market data from Alpha Vantage."""
+    try:
+        url = f"https://www.alphavantage.co/query"
+        params = {"function": "TIME_SERIES_INTRADAY", "symbol": symbol, "interval": interval,
+                  "apikey": ALPHA_VANTAGE_API_KEY}
+        response = requests.get(url, params=params)
+        response.raise_for_status() # Raise HTTPError for bad responses
+        data = response.json()
+        if "Time Series (60min)" in data: # Check the JSON for the correct key
+            time_series_data = data["Time Series (60min)"]
+            df = pd.DataFrame(time_series_data).T.reset_index()
+            df.columns = ["timestamp", "open", "high", "low", "close", "volume"] # Standardize
+            df["timestamp"] = pd.to_datetime(df["timestamp"])
+            df[["open", "high", "low", "close", "volume"]] = df[["open", "high", "low", "close", "volume"]].astype(float)
+            return df.dropna()
+        else:
+           raise Exception(f"Error: Could not retrieve stock data.  Check API Key, Symbol, and Interval. Response: {data}")
+
+    except requests.exceptions.RequestException as e:
+        raise Exception(f"Error fetching stock data: {e}")
+    except (ValueError, KeyError) as e:
+        raise Exception(f"Error parsing stock data: {e}")
+
+def fetch_sentiment_data(keyword):  # Placeholder - replace with a real sentiment analysis method
+    """Analyze sentiment from social media (placeholder)."""
+    try:
+        tweets = [
+            f"{keyword} is going to moon!",
+            f"I hate {keyword}, it's trash!",
+            f"{keyword} is amazing!"
+        ]
+        sentiments = [TextBlob(tweet).sentiment.polarity for tweet in tweets]
+        return sum(sentiments) / len(sentiments) / len(sentiments) if sentiments else 0  # Avoid ZeroDivisionError
+    except Exception as e:
+        print(f"Sentiment analysis error: {e}")
+        return 0
+
 # --- Technical Analysis Functions ---
 def calculate_technical_indicators(df):
     """Calculates RSI, MACD, and Bollinger Bands."""
@@ -164,31 +223,60 @@ def create_forecast_plot(forecast_df):
     )
     return fig
 
+# --- Model Training and Prediction ---
+model = RandomForestClassifier()  # Moved here
+
+def train_model(df):
+    """Train the AI model."""
+    if df.empty:
+        return  # Or raise an exception, or return a default model.
+    df["target"] = (df["close"].pct_change() > 0.05).astype(int)  # Target: 1 if price increased by >5%
+    features = df[["close", "volume"]].dropna()
+    target = df["target"].dropna()
+    if not features.empty and not target.empty: #check data is available
+      model.fit(features, target)
+    else:
+        print("Not enough data for model training.")
+
+def predict_growth(latest_data):
+    """Predict explosive growth."""
+    if not hasattr(model, 'estimators_') or len(model.estimators_) == 0:  # Check if model is trained
+        return [0]  # Or return an error message, or a default value
+
+    try:
+        prediction = model.predict(latest_data.reshape(1, -1))
+        return prediction
+    except Exception as e:
+        print(f"Prediction error: {e}")
+        return [0]
+
 # --- Main Prediction and Display Function ---
-def analyze_market(market_type, symbol, interval, forecast_steps, daily_seasonality, weekly_seasonality, yearly_seasonality, seasonality_mode, changepoint_prior_scale):
+def analyze_market(market_type, symbol, interval, forecast_steps, daily_seasonality, weekly_seasonality, yearly_seasonality, seasonality_mode, changepoint_prior_scale, sentiment_keyword=""):
     """Main function to orchestrate data fetching, analysis, and prediction."""
     df = pd.DataFrame()
     error_message = ""
-
+    sentiment_score = 0  # Initialize sentiment score
     # 1. Data Fetching
-    if market_type == "Crypto":
-        try:
-            df = fetch_crypto_data(symbol)
-        except Exception as e:
-            error_message = f"Error fetching crypto data: {e}"
-    elif market_type == "Stock":
-        try:
-            df = fetch_stock_data(symbol)
-        except Exception as e:
-            error_message = f"Error fetching stock data: {e}"
-    else:
-        error_message = "Invalid market type selected."
+    try:
+        if market_type == "Crypto":
+            df = fetch_crypto_data(symbol, interval=interval)
+        elif market_type == "Stock":
+            df = fetch_stock_data(symbol, interval=interval)
+        else:
+            error_message = "Invalid market type selected."
+            return None, None, None, None, None, "", error_message, 0  # Also return sentiment
 
-    if df.empty:
-        return None, None, None, None, None, "", error_message  # Correctly pass the error message
+        if sentiment_keyword: # If a keyword for sentiment is entered:
+            sentiment_score = fetch_sentiment_data(sentiment_keyword)
+    except Exception as e:
+        error_message = f"Data Fetching Error: {e}"
+        return None, None, None, None, None, "", error_message, 0 #Return error + sentiment
 
+    if df.empty:
+        error_message = "No data fetched."
+        return None, None, None, None, None, "", error_message, 0  # Return empty + sentiment
     # 2. Preprocessing & Technical Analysis
-    df["timestamp"] = pd.to_datetime(df["timestamp"])  # No unit arg as it's handled in fetcher
+    df["timestamp"] = pd.to_datetime(df["timestamp"])
     numeric_cols = ["open", "high", "low", "close", "volume"]
     df[numeric_cols] = df[numeric_cols].astype(float)
     df = calculate_technical_indicators(df)
@@ -209,7 +297,7 @@ def analyze_market(market_type, symbol, interval, forecast_steps, daily_seasonal
 
     if prophet_error:
         error_message = f"Prophet Error: {prophet_error}"
-        return None, None, None, None, None, "", error_message #Return error
+        return None, None, None, None, None, "", error_message, sentiment_score #Return prophet error
 
     forecast_plot = create_forecast_plot(forecast_df)
 
@@ -233,8 +321,8 @@ def analyze_market(market_type, symbol, interval, forecast_steps, daily_seasonal
     # Prepare forecast data for the Dataframe output
     forecast_df_display = forecast_df.loc[:, ["ds", "yhat", "yhat_lower", "yhat_upper"]].copy()
     forecast_df_display.rename(columns={"ds": "Date", "yhat": "Forecast", "yhat_lower": "Lower Bound", "yhat_upper": "Upper Bound"}, inplace=True)
+    return forecast_plot, tech_plot, rsi_plot, macd_plot, forecast_df_display, growth_label, error_message, sentiment_score
 
-    return forecast_plot, tech_plot, rsi_plot, macd_plot, forecast_df_display, growth_label, error_message #Return error
 # --- Gradio Interface ---
 with gr.Blocks(theme=gr.themes.Base()) as demo:
     gr.Markdown("# Market Analysis and Prediction")
@@ -250,6 +338,7 @@ with gr.Blocks(theme=gr.themes.Base()) as demo:
             yearly_box = gr.Checkbox(label="Yearly Seasonality", value=False)
             seasonality_mode_dd = gr.Dropdown(label="Seasonality Mode", choices=["additive", "multiplicative"], value="additive")
             changepoint_scale_slider = gr.Slider(label="Changepoint Prior Scale", minimum=0.01, maximum=1.0, step=0.01, value=0.05)
+            sentiment_keyword_txt = gr.Textbox(label="Sentiment Keyword (optional)") #Add Sentiment input
 
         with gr.Column():
             forecast_plot = gr.Plot(label="Price Forecast")
@@ -260,6 +349,7 @@ with gr.Blocks(theme=gr.themes.Base()) as demo:
                 macd_plot = gr.Plot(label="MACD")
             forecast_df = gr.Dataframe(label="Forecast Data", headers=["Date", "Forecast", "Lower Bound", "Upper Bound"])
             growth_label_output = gr.Label(label="Explosive Growth Prediction") # Added for prediction.
+            sentiment_label_output = gr.Number(label="Sentiment Score") # Added for sentiment output
 
     # Event Listener to update symbol dropdown based on market type
     def update_symbol_choices(market_type):
@@ -283,8 +373,9 @@ with gr.Blocks(theme=gr.themes.Base()) as demo:
             yearly_box,
             seasonality_mode_dd,
             changepoint_scale_slider,
+            sentiment_keyword_txt,  # Add sentiment keyword to the input
         ],
-        outputs=[forecast_plot, tech_plot, rsi_plot, macd_plot, forecast_df, growth_label_output]
+        outputs=[forecast_plot, tech_plot, rsi_plot, macd_plot, forecast_df, growth_label_output, gr.Label(label="Error Message"), sentiment_label_output] # Add sentiment score to the output
     )
 
 if __name__ == "__main__":