Update data_processor.py

data_processor.py

@@ -7,15 +7,15 @@ class DataProcessor:
     def __init__(self):
         self.fundamentals_cache = {}
     
-    def get_asset_data(self, ticker="GC=F", interval="1d", period="max"):
-        """Fetch asset data from Yahoo Finance"""
+    def get_market_data(self, ticker="GC=F", interval="1d"):
+        """Fetch market data from Yahoo Finance for a given ticker"""
         try:
-            # Map internal intervals to yfinance format
             interval_map = {
                 "5m": "5m",
                 "15m": "15m",
                 "30m": "30m",
                 "1h": "60m",
+                "4h": "240m",
                 "1d": "1d",
                 "1wk": "1wk",
                 "1mo": "1mo",
@@ -24,9 +24,8 @@ class DataProcessor:
             
             yf_interval = interval_map.get(interval, "1d")
             
-            # Determine appropriate period based on interval
-            if interval in ["5m", "15m", "30m", "1h"]:
-                period = "60d"  # Intraday data limited to 60 days
+            if interval in ["5m", "15m", "30m", "1h", "4h"]:
+                period = "60d"
             elif interval in ["1d"]:
                 period = "1y"
             elif interval in ["1wk"]:
@@ -38,15 +37,14 @@ class DataProcessor:
             df = ticker_obj.history(interval=yf_interval, period=period)
             
             if df.empty:
-                raise ValueError("No data retrieved from Yahoo Finance")
+                raise ValueError(f"No data retrieved from Yahoo Finance for {ticker}")
             
-            # Ensure proper column names
             df.columns = [col.capitalize() for col in df.columns]
             
             return df
             
         except Exception as e:
-            print(f"Error fetching data for {ticker} with interval {interval}: {e}")
+            print(f"Error fetching data for {ticker}: {e}")
             return pd.DataFrame()
     
     def calculate_indicators(self, df):
@@ -54,19 +52,23 @@ class DataProcessor:
         if df.empty:
             return df
         
-        # Simple Moving Averages
+        # Simple Moving Averages (5, 20 as requested)
+        df['SMA_5'] = df['Close'].rolling(window=5).mean()
         df['SMA_20'] = df['Close'].rolling(window=20).mean()
-        df['SMA_50'] = df['Close'].rolling(window=50).mean()
         
         # Exponential Moving Averages
         df['EMA_12'] = df['Close'].ewm(span=12, adjust=False).mean()
         df['EMA_26'] = df['Close'].ewm(span=26, adjust=False).mean()
         
-        # MACD
+        # MACD (12, 26, 9)
         df['MACD'] = df['EMA_12'] - df['EMA_26']
         df['MACD_signal'] = df['MACD'].ewm(span=9, adjust=False).mean()
         df['MACD_histogram'] = df['MACD'] - df['MACD_signal']
         
+        # Split histogram into positive and negative for plotting
+        df['MACD_bar_positive'] = df['MACD_histogram'].where(df['MACD_histogram'] > 0, 0)
+        df['MACD_bar_negative'] = df['MACD_histogram'].where(df['MACD_histogram'] < 0, 0)
+        
         # RSI
         delta = df['Close'].diff()
         gain = (delta.where(delta > 0, 0)).rolling(window=14).mean()
@@ -89,43 +91,41 @@ class DataProcessor:
         df['ATR'] = true_range.rolling(window=14).mean()
         
         # Volume indicators
-        if 'Volume' in df.columns:
-            df['Volume_SMA'] = df['Volume'].rolling(window=20).mean()
-            df['Volume_ratio'] = df['Volume'] / df['Volume_SMA']
+        df['Volume_SMA'] = df['Volume'].rolling(window=20).mean()
+        df['Volume_ratio'] = df['Volume'] / df['Volume_SMA']
+        
+        # Stochastic Oscillator (14, 3)
+        low_14 = df['Low'].rolling(window=14).min()
+        high_14 = df['High'].rolling(window=14).max()
+        df['%K'] = 100 * (df['Close'] - low_14) / (high_14 - low_14)
+        df['%D'] = df['%K'].rolling(window=3).mean()
+        df['%SD'] = df['%D'].rolling(window=3).mean()
+        df['UL'] = 70  # Upper limit
+        df['DL'] = 30  # Lower limit
         
         return df
     
     def get_fundamental_data(self, ticker="GC=F"):
-        """Get fundamental market data"""
+        """Get fundamental gold market data (now generalized/mocked)"""
         try:
-            ticker_obj = yf.Ticker(ticker)
-            info = ticker_obj.info
-            
-            # Asset-specific fundamentals
             if ticker == "BTC-USD":
-                market_cap = info.get('marketCap', 0)
                 fundamentals = {
-                    "Strength Index": round(np.random.uniform(30, 80), 1),
-                    "Market Cap": f"${market_cap:,.0f}" if market_cap else "N/A",
-                    "24h Volume": f"${np.random.uniform(20, 80):.1f}B",
-                    "Volatility": f"{np.random.uniform(40, 120):.1f}%",
-                    "Network Hash Rate": f"{np.random.uniform(300, 600):.0f} EH/s",
-                    "Active Addresses": f"{np.random.uniform(500000, 1000000):,.0f}",
+                    "Crypto Volatility Index": round(np.random.uniform(50, 150), 1),
+                    "Dominance Index": f"{np.random.uniform(40, 60):.2f}%",
+                    "Fear & Greed Index": np.random.choice(["Extreme Fear", "Fear", "Neutral", "Greed", "Extreme Greed"]),
+                    "Hash Rate Trend": np.random.choice(["Increasing", "Stable", "Decreasing"]),
+                    "Institutional Flow (Net)": f"{np.random.uniform(-100, 100):,.0f}M USD",
                     "Market Sentiment": np.random.choice(["Bullish", "Neutral", "Bearish"]),
-                    "Institutional Adoption": np.random.choice(["High", "Medium", "Low"]),
-                    "Mining Difficulty Trend": np.random.choice(["Increasing", "Stable", "Decreasing"])
                 }
-            else:  # Gold
+            else:
                 fundamentals = {
-                    "Strength Index": round(np.random.uniform(30, 80), 1),
-                    "Dollar Index": round(np.random.uniform(90, 110), 1),
+                    "Gold Strength Index": round(np.random.uniform(30, 80), 1),
+                    "Dollar Index (DXY)": round(np.random.uniform(90, 110), 1),
                     "Real Interest Rate": f"{np.random.uniform(-2, 5):.2f}%",
                     "Gold Volatility": f"{np.random.uniform(10, 40):.1f}%",
                     "Commercial Hedgers (Net)": f"{np.random.uniform(-50000, 50000):,.0f}",
                     "Managed Money (Net)": f"{np.random.uniform(-100000, 100000):,.0f}",
                     "Market Sentiment": np.random.choice(["Bullish", "Neutral", "Bearish"]),
-                    "Central Bank Demand": np.random.choice(["High", "Medium", "Low"]),
-                    "Jewelry Demand Trend": np.random.choice(["Increasing", "Stable", "Decreasing"])
                 }
             
             return fundamentals
@@ -139,11 +139,9 @@ class DataProcessor:
         if df.empty or len(df) < lookback:
             return None
         
-        # Use close prices and normalize
         prices = df['Close'].iloc[-lookback:].values
         prices = prices.astype(np.float32)
         
-        # Normalize to help model performance
         mean = np.mean(prices)
         std = np.std(prices)
         normalized = (prices - mean) / (std + 1e-8)