Update Gradio app with multiple files

app.py

@@ -1,11 +1,14 @@
 import gradio as gr
 import pandas as pd
-import plotly.graph_objects as go
+import numpy as np
+import matplotlib.pyplot as plt
+import mplfinance as mpf
 from data_processor import DataProcessor
 from sentiment_analyzer import SentimentAnalyzer
 from model_handler import ModelHandler
 from trading_logic import TradingLogic
-import numpy as np
+import io
+import base64
 
 # Global instances
 data_processor = DataProcessor()
@@ -13,72 +16,60 @@ sentiment_analyzer = SentimentAnalyzer()
 model_handler = ModelHandler()
 trading_logic = TradingLogic()
 
-def create_chart_analysis(interval):
-    """Create chart with technical indicators"""
+# Asset mapping
+asset_map = {
+    "Gold Futures (GC=F)": "GC=F",
+    "Bitcoin USD (BTC-USD)": "BTC-USD"
+}
+
+def create_chart_analysis(interval, asset_name):
+    """Create chart with technical indicators using mplfinance"""
     try:
-        df = data_processor.get_gold_data(interval)
+        ticker = asset_map[asset_name]
+        df = data_processor.get_asset_data(ticker, interval)
         if df.empty:
             return "No data available", None, None
         
         # Calculate indicators
         df = data_processor.calculate_indicators(df)
         
-        # Create candlestick chart
-        fig = go.Figure(data=[
-            go.Candlestick(
-                x=df.index,
-                open=df['Open'],
-                high=df['High'],
-                low=df['Low'],
-                close=df['Close'],
-                name='Gold Price'
-            )
-        ])
+        # Create main candlestick chart with mplfinance
+        # Prepare additional plots for indicators
+        ap = []
+        
+        # Add moving averages
+        ap.append(mpf.make_addplot(df['SMA_20'], color='#FFA500', width=1.5, label='SMA 20'))
+        ap.append(mpf.make_addplot(df['SMA_50'], color='#FF4500', width=1.5, label='SMA 50'))
         
         # Add Bollinger Bands
-        fig.add_trace(go.Scatter(
-            x=df.index, y=df['BB_upper'],
-            line=dict(color='rgba(255,255,255,0.3)', width=1),
-            name='BB Upper', showlegend=False
-        ))
-        fig.add_trace(go.Scatter(
-            x=df.index, y=df['BB_lower'],
-            line=dict(color='rgba(255,255,255,0.3)', width=1),
-            fill='tonexty', fillcolor='rgba(255,255,255,0.1)',
-            name='BB Lower', showlegend=False
-        ))
+        ap.append(mpf.make_addplot(df['BB_upper'], color='#4169E1', width=1, linestyle='dashed', label='BB Upper'))
+        ap.append(mpf.make_addplot(df['BB_lower'], color='#4169E1', width=1, linestyle='dashed', label='BB Lower'))
         
-        # Add moving averages
-        fig.add_trace(go.Scatter(
-            x=df.index, y=df['SMA_20'],
-            line=dict(color='#FFD700', width=2),
-            name='SMA 20'
-        ))
-        fig.add_trace(go.Scatter(
-            x=df.index, y=df['SMA_50'],
-            line=dict(color='#FFA500', width=2),
-            name='SMA 50'
-        ))
-        
-        fig.update_layout(
-            title=f'Gold Futures (GC=F) - {interval}',
-            yaxis_title='Price (USD)',
-            xaxis_title='Date',
-            template='plotly_dark',
-            height=500,
-            margin=dict(l=50, r=50, t=50, b=50),
-            xaxis_rangeslider_visible=False,
-            paper_bgcolor='rgba(0,0,0,0)',
-            plot_bgcolor='rgba(0,0,0,0)',
-            font=dict(color='white')
+        # Create figure
+        fig, axes = mpf.plot(
+            df[-100:],  # Show last 100 candles
+            type='candle',
+            style='yahoo',
+            title=f'{asset_name} - {interval}',
+            ylabel='Price (USD)',
+            volume=True,
+            addplot=ap,
+            figsize=(12, 8),
+            returnfig=True,
+            warn_too_much_data=200
         )
         
-        # KOREKSI: Panggil prepare_for_chronos sebelum prediksi
+        # Adjust layout
+        fig.suptitle(f'{asset_name} Price Chart', fontsize=16, color='black')
+        fig.patch.set_facecolor('white')
+        axes[0].set_facecolor('white')
+        axes[0].grid(True, alpha=0.3)
+        
+        # Prepare data for Chronos
         prepared_data = data_processor.prepare_for_chronos(df)
-
+        
         # Generate predictions
         predictions = model_handler.predict(prepared_data, horizon=10)
-
         current_price = df['Close'].iloc[-1]
         
         # Get signal
@@ -93,102 +84,99 @@ def create_chart_analysis(interval):
         
         # Create metrics display
         metrics = {
-            "Current Price": f"${current_price:.2f}",
+            "Current Price": f"${current_price:,.2f}",
             "Signal": signal.upper(),
             "Confidence": f"{confidence:.1%}",
-            "Take Profit": f"${tp:.2f}" if tp else "N/A",
-            "Stop Loss": f"${sl:.2f}" if sl else "N/A",
+            "Take Profit": f"${tp:,.2f}" if tp else "N/A",
+            "Stop Loss": f"${sl:,.2f}" if sl else "N/A",
             "RSI": f"{df['RSI'].iloc[-1]:.1f}",
             "MACD": f"{df['MACD'].iloc[-1]:.4f}",
             "Volume": f"{df['Volume'].iloc[-1]:,.0f}"
         }
         
-        # Create prediction chart
-        pred_fig = go.Figure()
+        # Create prediction chart using matplotlib
+        pred_fig, ax = plt.subplots(figsize=(10, 4), facecolor='white')
+        pred_fig.patch.set_facecolor('white')
+        
+        # Plot historical prices (last 30 points)
+        hist_data = df['Close'].iloc[-30:]
+        hist_dates = df.index[-30:]
+        ax.plot(hist_dates, hist_data, color='#4169E1', linewidth=2, label='Historical')
         
-        # Check if predictions are valid before plotting
-        if predictions.any():
+        # Plot predictions
+        if predictions.any() and len(predictions) > 0:
             future_dates = pd.date_range(
                 start=df.index[-1], periods=len(predictions), freq='D'
             )
+            ax.plot(future_dates, predictions, color='#FF6600', linewidth=2, 
+                   marker='o', markersize=4, label='Predictions')
             
-            pred_fig.add_trace(go.Scatter(
-                x=future_dates, y=predictions,
-                mode='lines+markers',
-                line=dict(color='#FFD700', width=3),
-                marker=dict(size=6),
-                name='Predictions'
-            ))
-            
-            pred_fig.add_trace(go.Scatter(
-                x=[df.index[-1], future_dates[0]],
-                y=[current_price, predictions[0]],
-                mode='lines',
-                line=dict(color='rgba(255,215,0,0.5)', width=2, dash='dash'),
-                showlegend=False
-            ))
-        
-        pred_fig.update_layout(
-            title='Price Prediction (Next 10 Periods)',
-            yaxis_title='Price (USD)',
-            xaxis_title='Date',
-            template='plotly_dark',
-            height=300,
-            paper_bgcolor='rgba(0,0,0,0)',
-            plot_bgcolor='rgba(0,0,0,0)',
-            font=dict(color='white')
-        )
+            # Connect historical to prediction
+            ax.plot([hist_dates[-1], future_dates[0]], 
+                   [hist_data.iloc[-1], predictions[0]], 
+                   color='#FF6600', linewidth=1, linestyle='--')
+        
+        ax.set_title('Price Prediction (Next 10 Periods)', fontsize=12, color='black')
+        ax.set_xlabel('Date', color='black')
+        ax.set_ylabel('Price (USD)', color='black')
+        ax.legend()
+        ax.grid(True, alpha=0.3)
+        ax.tick_params(colors='black')
         
         return fig, metrics, pred_fig
         
     except Exception as e:
         return str(e), None, None
 
-def analyze_sentiment():
-    """Analyze gold market sentiment"""
+def analyze_sentiment(asset_name):
+    """Analyze market sentiment for selected asset"""
     try:
-        sentiment_score, news_summary = sentiment_analyzer.analyze_gold_sentiment()
-        
-        # Create sentiment gauge
-        fig = go.Figure(go.Indicator(
-            mode="gauge+number+delta",
-            value=sentiment_score,
-            domain={'x': [0, 1], 'y': [0, 1]},
-            title={'text': "Gold Market Sentiment"},
-            delta={'reference': 0},
-            gauge={
-                'axis': {'range': [-1, 1]},
-                'bar': {'color': "#FFD700"},
-                'steps': [
-                    {'range': [-1, -0.5], 'color': "rgba(255,0,0,0.5)"},
-                    {'range': [-0.5, 0.5], 'color': "rgba(255,255,255,0.3)"},
-                    {'range': [0.5, 1], 'color': "rgba(0,255,0,0.5)"}
-                ],
-                'threshold': {
-                    'line': {'color': "white", 'width': 4},
-                    'thickness': 0.75,
-                    'value': 0
-                }
-            }
-        ))
-        
-        fig.update_layout(
-            template='plotly_dark',
-            height=300,
-            paper_bgcolor='rgba(0,0,0,0)',
-            plot_bgcolor='rgba(0,0,0,0)',
-            font=dict(color='white')
-        )
+        sentiment_score, news_summary = sentiment_analyzer.analyze_sentiment(asset_name)
+        
+        # Create sentiment gauge using matplotlib
+        fig, ax = plt.subplots(figsize=(6, 4), facecolor='white')
+        fig.patch.set_facecolor('white')
+        
+        # Create gauge
+        ax.set_xlim(-1.5, 1.5)
+        ax.set_ylim(0, 1)
+        ax.set_aspect('equal')
+        
+        # Draw gauge background
+        theta = np.linspace(np.pi, 0, 100)
+        ax.plot(np.cos(theta), np.sin(theta), color='lightgray', linewidth=10)
+        
+        # Draw colored regions
+        ax.fill_between(np.cos(theta[50:]), np.sin(theta[50:]), 0, 
+                       where=np.cos(theta[50:])<0, color='red', alpha=0.3)
+        ax.fill_between(np.cos(theta[25:75]), np.sin(theta[25:75]), 0, 
+                       color='gray', alpha=0.3)
+        ax.fill_between(np.cos(theta[:50]), np.sin(theta[:50]), 0, 
+                       where=np.cos(theta[:50])>0, color='green', alpha=0.3)
+        
+        # Draw needle
+        needle_angle = np.pi * (1 - (sentiment_score + 1) / 2)
+        ax.plot([0, 0.8*np.cos(needle_angle)], [0, 0.8*np.sin(needle_angle)], 
+               color='gold', linewidth=4)
+        
+        # Add score text
+        ax.text(0, -0.2, f"{sentiment_score:.2f}", ha='center', va='center', 
+               fontsize=16, color='black', weight='bold')
+        ax.set_title(f'{asset_name} Market Sentiment', color='black')
+        
+        # Remove axes
+        ax.axis('off')
         
         return fig, news_summary
         
     except Exception as e:
         return str(e), None
 
-def get_fundamentals():
+def get_fundamentals(asset_name):
     """Get fundamental analysis data"""
     try:
-        fundamentals = data_processor.get_fundamental_data()
+        ticker = asset_map[asset_name]
+        fundamentals = data_processor.get_fundamental_data(ticker)
         
         # Create fundamentals table
         table_data = []
@@ -198,28 +186,21 @@ def get_fundamentals():
         df = pd.DataFrame(table_data, columns=['Metric', 'Value'])
         
         # Create fundamentals gauge chart
-        fig = go.Figure(go.Indicator(
-            mode="gauge+number",
-            value=fundamentals.get('Gold Strength Index', 50),
-            title={'text': "Gold Strength Index"},
-            gauge={
-                'axis': {'range': [0, 100]},
-                'bar': {'color': "#FFD700"},
-                'steps': [
-                    {'range': [0, 30], 'color': "rgba(255,0,0,0.5)"},
-                    {'range': [30, 70], 'color': "rgba(255,255,255,0.3)"},
-                    {'range': [70, 100], 'color': "rgba(0,255,0,0.5)"}
-                ]
-            }
-        ))
-        
-        fig.update_layout(
-            template='plotly_dark',
-            height=300,
-            paper_bgcolor='rgba(0,0,0,0)',
-            plot_bgcolor='rgba(0,0,0,0)',
-            font=dict(color='white')
-        )
+        fig, ax = plt.subplots(figsize=(6, 4), facecolor='white')
+        fig.patch.set_facecolor('white')
+        
+        strength_index = fundamentals.get('Strength Index', 50)
+        
+        # Create horizontal bar gauge
+        ax.barh([0], [strength_index], height=0.3, color='gold', alpha=0.7)
+        ax.set_xlim(0, 100)
+        ax.set_ylim(-0.5, 0.5)
+        ax.set_title(f'{asset_name} Strength Index', color='black')
+        ax.set_xlabel('Index Value', color='black')
+        ax.text(strength_index, 0, f'{strength_index:.1f}', 
+               ha='left', va='center', fontsize=12, color='black', weight='bold')
+        ax.grid(True, alpha=0.3)
+        ax.tick_params(colors='black')
         
         return fig, df
         
@@ -228,73 +209,89 @@ def get_fundamentals():
 
 # Create Gradio interface
 with gr.Blocks(
-    theme=gr.themes.Default(primary_hue="yellow", secondary_hue="yellow"),
-    title="Gold Trading Analysis & Prediction",
+    theme=gr.themes.Default(primary_hue="blue", secondary_hue="blue"),
+    title="Trading Analysis & Prediction",
     css="""
-        .gradio-container {background-color: #000000; color: #FFFFFF}
-        .gr-button-primary {background-color: #FFD700 !important; color: #000000 !important}
-        .gr-button-secondary {border-color: #FFD700 !important; color: #FFD700 !important}
-        .gr-tab button {color: #FFFFFF !important}
-        .gr-tab button.selected {background-color: #FFD700 !important; color: #000000 !important}
-        .gr-highlighted {background-color: #1a1a1a !important}
-        .anycoder-link {color: #FFD700 !important; text-decoration: none; font-weight: bold}
+        .gradio-container {background-color: #FFFFFF; color: #000000}
+        .gr-button-primary {background-color: #4169E1 !important; color: #FFFFFF !important}
+        .gr-button-secondary {border-color: #4169E1 !important; color: #4169E1 !important}
+        .gr-tab button {color: #000000 !important}
+        .gr-tab button.selected {background-color: #4169E1 !important; color: #FFFFFF !important}
+        .gr-highlighted {background-color: #F0F0F0 !important}
+        .anycoder-link {color: #4169E1 !important; text-decoration: none; font-weight: bold}
+        .gr-json {background-color: #FFFFFF !important; color: #000000 !important}
     """
 ) as demo:
     
     # Header with anycoder link
     gr.HTML("""
         <div style="text-align: center; padding: 20px;">
-            <h1 style="color: #FFD700;">Gold Trading Analysis & Prediction</h1>
-            <p>Advanced AI-powered analysis for Gold Futures (GC=F)</p>
+            <h1 style="color: #4169E1;">Trading Analysis & Prediction</h1>
+            <p>Advanced AI-powered analysis for Gold and Bitcoin</p>
             <a href="https://huggingface.co/spaces/akhaliq/anycoder" target="_blank" class="anycoder-link">Built with anycoder</a>
         </div>
     """)
     
     with gr.Row():
-        interval_dropdown = gr.Dropdown(
-            choices=[
-                "5m", "15m", "30m", "1h", "4h", "1d", "1wk", "1mo", "3mo"
-            ],
-            value="1d",
-            label="Time Interval",
-            info="Select analysis timeframe"
-        )
-        refresh_btn = gr.Button("売 Refresh Data", variant="primary")
+        with gr.Column(scale=1):
+            asset_dropdown = gr.Dropdown(
+                choices=list(asset_map.keys()),
+                value="Gold Futures (GC=F)",
+                label="Select Asset",
+                info="Choose trading pair"
+            )
+        with gr.Column(scale=1):
+            interval_dropdown = gr.Dropdown(
+                choices=[
+                    "5m", "15m", "30m", "1h", "4h", "1d", "1wk", "1mo", "3mo"
+                ],
+                value="1d",
+                label="Time Interval",
+                info="Select analysis timeframe"
+            )
+        with gr.Column(scale=1):
+            refresh_btn = gr.Button("Refresh Data", variant="primary")
     
     with gr.Tabs():
-        with gr.TabItem("投 Chart Analysis"):
+        with gr.TabItem("Chart Analysis"):
             with gr.Row():
-                chart_plot = gr.Plot(label="Price Chart")
-                pred_plot = gr.Plot(label="Predictions")
+                with gr.Column(scale=2):
+                    chart_plot = gr.Plot(label="Price Chart")
+                with gr.Column(scale=1):
+                    metrics_output = gr.JSON(label="Trading Metrics")
             
             with gr.Row():
-                metrics_output = gr.JSON(label="Trading Metrics")
+                pred_plot = gr.Plot(label="Price Predictions")
         
-        with gr.TabItem("堂 Sentiment Analysis"):
+        with gr.TabItem("Sentiment Analysis"):
             with gr.Row():
-                sentiment_gauge = gr.Plot(label="Sentiment Score")
-                news_display = gr.HTML(label="Market News")
+                with gr.Column(scale=1):
+                    sentiment_gauge = gr.Plot(label="Sentiment Score")
+                with gr.Column(scale=1):
+                    news_display = gr.HTML(label="Market News")
         
-        with gr.TabItem("嶋 Fundamentals"):
+        with gr.TabItem("Fundamentals"):
             with gr.Row():
-                fundamentals_gauge = gr.Plot(label="Strength Index")
-                fundamentals_table = gr.Dataframe(
-                    headers=["Metric", "Value"],
-                    label="Key Fundamentals",
-                    interactive=False
-                )
+                with gr.Column(scale=1):
+                    fundamentals_gauge = gr.Plot(label="Strength Index")
+                with gr.Column(scale=1):
+                    fundamentals_table = gr.Dataframe(
+                        headers=["Metric", "Value"],
+                        label="Key Fundamentals",
+                        interactive=False
+                    )
     
     # Event handlers
-    def update_all(interval):
-        chart, metrics, pred = create_chart_analysis(interval)
-        sentiment, news = analyze_sentiment()
-        fund_gauge, fund_table = get_fundamentals()
+    def update_all(interval, asset):
+        chart, metrics, pred = create_chart_analysis(interval, asset)
+        sentiment, news = analyze_sentiment(asset)
+        fund_gauge, fund_table = get_fundamentals(asset)
         
         return chart, metrics, pred, sentiment, news, fund_gauge, fund_table
     
     refresh_btn.click(
         fn=update_all,
-        inputs=interval_dropdown,
+        inputs=[interval_dropdown, asset_dropdown],
         outputs=[
             chart_plot, metrics_output, pred_plot,
             sentiment_gauge, news_display,
@@ -304,7 +301,7 @@ with gr.Blocks(
     
     demo.load(
         fn=update_all,
-        inputs=interval_dropdown,
+        inputs=[interval_dropdown, asset_dropdown],
         outputs=[
             chart_plot, metrics_output, pred_plot,
             sentiment_gauge, news_display,

data_processor.py

@@ -5,11 +5,10 @@ from datetime import datetime, timedelta
 
 class DataProcessor:
     def __init__(self):
-        self.ticker = "GC=F"
         self.fundamentals_cache = {}
     
-    def get_gold_data(self, interval="1d", period="max"):
-        """Fetch gold futures data from Yahoo Finance"""
+    def get_asset_data(self, ticker="GC=F", interval="1d", period="max"):
+        """Fetch asset data from Yahoo Finance"""
         try:
             # Map internal intervals to yfinance format
             interval_map = {
@@ -36,8 +35,8 @@ class DataProcessor:
             else:
                 period = "max"
             
-            ticker = yf.Ticker(self.ticker)
-            df = ticker.history(interval=yf_interval, period=period)
+            ticker_obj = yf.Ticker(ticker)
+            df = ticker_obj.history(interval=yf_interval, period=period)
             
             if df.empty:
                 raise ValueError("No data retrieved from Yahoo Finance")
@@ -96,24 +95,37 @@ class DataProcessor:
         
         return df
     
-    def get_fundamental_data(self):
-        """Get fundamental gold market data"""
+    def get_fundamental_data(self, ticker="GC=F"):
+        """Get fundamental market data"""
         try:
-            ticker = yf.Ticker(self.ticker)
-            info = ticker.info
+            ticker_obj = yf.Ticker(ticker)
+            info = ticker_obj.info
             
-            # Mock some gold-specific fundamentals as yfinance may not have all
-            fundamentals = {
-                "Gold Strength Index": round(np.random.uniform(30, 80), 1),
-                "Dollar Index": 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"])
-            }
+            # Asset-specific fundamentals
+            if ticker == "BTC-USD":
+                fundamentals = {
+                    "Strength Index": round(np.random.uniform(30, 80), 1),
+                    "Market Cap": f"${info.get('marketCap', 0):,.0f}" if info.get('marketCap') 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}",
+                    "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
+                fundamentals = {
+                    "Strength Index": round(np.random.uniform(30, 80), 1),
+                    "Dollar Index": 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
             

model_handler.py

@@ -1,6 +1,5 @@
 import numpy as np
 import torch
-# PENTING: Class ini adalah satu-satunya cara yang benar untuk memuat Chronos-2
 from chronos import BaseChronosPipeline 
 
 class ModelHandler:
@@ -15,7 +14,6 @@ class ModelHandler:
         try:
             print(f"Loading {self.model_name} on {self.device}...")
             
-            # Pemuatan otomatis oleh pipeline (sudah terbukti berhasil di langkah sebelumnya)
             self.pipeline = BaseChronosPipeline.from_pretrained(
                 self.model_name,
                 device_map=self.device,
@@ -34,7 +32,7 @@ class ModelHandler:
                 return np.array([0] * horizon)
             
             if self.pipeline is None:
-                # --- Fallback Logic ---
+                # Fallback Logic
                 values = data['original']
                 recent_trend = np.polyfit(range(len(values[-20:])), values[-20:], 1)[0]
                 
@@ -48,11 +46,10 @@ class ModelHandler:
                 
                 return np.array(predictions)
             
-            # --- Chronos-2 Inference ---
+            # Chronos-2 Inference
             predictions_samples = self.pipeline.predict(
                 data['original'],
                 prediction_length=horizon,
-                # KOREKSI: Mengganti 'num_samples' menjadi 'n_samples'
                 n_samples=20 
             )
             

requirements.txt

@@ -9,4 +9,6 @@ scipy
 scikit-learn
 safetensors
 huggingface-hub
-chronos-forecasting
+chronos-forecasting
+mplfinance
+matplotlib

sentiment_analyzer.py

@@ -3,7 +3,7 @@ from datetime import datetime
 
 class SentimentAnalyzer:
     def __init__(self):
-        self.sentiment_sources = [
+        self.gold_sources = [
             "Federal Reserve hints at rate pause - positive for gold",
             "Inflation data higher than expected - gold demand rising",
             "Dollar strength weighs on precious metals",
@@ -13,12 +13,25 @@ class SentimentAnalyzer:
             "Technical breakout above resistance level",
             "Profit-taking observed after recent rally"
         ]
+        self.bitcoin_sources = [
+            "Institutional adoption of Bitcoin accelerates",
+            "Regulatory clarity improves - positive for crypto",
+            "Bitcoin halving event supports price",
+            "Macro uncertainty drives Bitcoin demand",
+            "Spot ETF inflows reach record highs",
+            "Network hash rate reaches new ATH",
+            "Whale accumulation detected on-chain",
+            "DeFi TVL growth supports crypto market"
+        ]
     
-    def analyze_gold_sentiment(self):
-        """Analyze sentiment for gold market"""
+    def analyze_sentiment(self, asset_name):
+        """Analyze sentiment for selected asset"""
         try:
-            # Simulate sentiment analysis
-            # In production, would use actual news API and NLP model
+            # Select appropriate news sources
+            if "Bitcoin" in asset_name:
+                sources = self.bitcoin_sources
+            else:
+                sources = self.gold_sources
             
             # Generate random sentiment around current market conditions
             base_sentiment = random.uniform(-0.5, 0.5)
@@ -35,16 +48,16 @@ class SentimentAnalyzer:
             
             # Generate news summary
             num_news = random.randint(3, 6)
-            selected_news = random.sample(self.sentiment_sources, num_news)
+            selected_news = random.sample(sources, num_news)
             
-            news_html = "<div style='max-height: 300px; overflow-y: auto;'>"
-            news_html += "<h4 style='color: #FFD700;'>Latest Gold News</h4>"
+            news_html = f"<div style='max-height: 300px; overflow-y: auto;'>"
+            news_html += f"<h4 style='color: #4169E1;'>{asset_name} Market News</h4>"
             
             for i, news in enumerate(selected_news, 1):
-                sentiment_label = "🟢" if "positive" in news or "rising" in news or "support" in news else \
+                sentiment_label = "🟢" if "positive" in news or "rising" in news or "support" in news or "accelerates" in news or " ATH" in news else \
                                   "🔴" if "weighs" in news or "outflows" in news or "Profit-taking" in news else \
                                   "🟡"
-                news_html += f"<p style='margin: 10px 0; padding: 10px; background: rgba(255,255,255,0.05); border-radius: 5px;'>{sentiment_label} {news}</p>"
+                news_html += f"<p style='margin: 10px 0; padding: 10px; background: rgba(65,105,225,0.05); border-radius: 5px;'>{sentiment_label} {news}</p>"
             
             news_html += "</div>"