Upload 9 files

STOCK-MARKET-APP/app.py

@@ -0,0 +1,14 @@
+import streamlit as st
+from view_page import StockDashboard
+from model_page import StockModelPage
+
+def main():
+    st.set_page_config(layout='wide', page_title='Stock Analysis', page_icon=':dollar:')
+    page = st.sidebar.radio('Pages', ['View Page', 'Model Page'])
+    if page == 'View Page':
+       StockDashboard().run()
+    elif page == 'Model Page':
+       StockModelPage().run()
+
+if __name__ == '__main__':
+    main()

STOCK-MARKET-APP/config.py

@@ -0,0 +1,58 @@
+# Configuration settings for the stock forecasting app
+
+# Rate limiting settings
+RATE_LIMIT_DELAY = 0.5  # Minimum delay between API calls (seconds)
+MAX_RETRIES = 3  # Maximum number of retries for failed requests
+BASE_RETRY_DELAY = 3  # Base delay for exponential backoff (seconds)
+
+# Cache settings
+DEFAULT_CACHE_TTL = 300  # Default cache time-to-live (seconds) - 5 minutes
+MODEL_CACHE_TTL = 600   # Cache TTL for model data (seconds) - 10 minutes
+
+# API settings
+YAHOO_FINANCE_TIMEOUT = 10  # Timeout for yfinance requests (seconds)
+
+# UI settings
+DEFAULT_TICKERS = ['NVDA', 'AAPL', 'GOOGL', 'MSFT', 'AMZN']
+PERIOD_MAP = {
+    'all': 'max',
+    '1m': '1mo', 
+    '6m': '6mo', 
+    '1y': '1y'
+}
+
+# Error messages
+ERROR_MESSAGES = {
+    'rate_limit': """
+    🚫 **Rate Limit Exceeded**
+    
+    Yahoo Finance has temporarily limited your requests. This happens when too many requests are made in a short time.
+    
+    **What you can do:**
+    - Wait 5-10 minutes before trying again
+    - Use the cached data if available
+    - Try a different stock ticker
+    
+    The app will automatically retry with delays between requests.
+    """,
+    'network': """
+    🌐 **Network Error**
+    
+    There seems to be a connectivity issue.
+    
+    **What you can do:**
+    - Check your internet connection
+    - Try refreshing the page
+    - Wait a moment and try again
+    """,
+    'no_data': """
+    📊 **No Data Available**
+    
+    No stock data was found for the selected ticker and time period.
+    
+    **What you can do:**
+    - Try a different time period
+    - Check if the ticker symbol is correct
+    - Try a different stock ticker
+    """
+}

STOCK-MARKET-APP/mode.page.txt

@@ -0,0 +1,49 @@
+import pandas as pd
+import streamlit as st
+from model import Model
+from plots import Plots
+from stock_data_loader import StockDataLoader
+
+class StockModelPage:
+    def __init__(self):
+        self.tickers = ['NVDA', 'AAPL', 'GOOGL', 'MSFT', 'AMZN']
+        self.setup_sidebar()
+
+    def setup_sidebar(self):
+        self.ticker = st.sidebar.selectbox('Choose Stock Ticker', self.tickers)
+        self.start_date = st.sidebar.date_input('Start Date', value=pd.to_datetime('2010-01-01'))
+        self.end_date = st.sidebar.date_input('End Date', value=pd.to_datetime('today'))
+        self.load_button_clicked = st.sidebar.button('Load Data')
+
+    def load_data(self):
+        if self.load_button_clicked:
+            loader = StockDataLoader(self.ticker, self.start_date, self.end_date)
+            st.session_state['stock_data'] = loader.get_stock_data()
+            st.write("--------------------------------------------")
+            st.write(f"Data for {self.ticker} from {self.start_date} to {self.end_date} loaded successfully!")
+
+    def handle_model_training(self):
+        if 'stock_data' in st.session_state:
+            stock_data = st.session_state['stock_data']
+            if st.button('Train Model'):
+                st.write("Training Model...")
+                model = Model(stock_data)
+                model.train_lstm()
+                predictions = model.make_predictions()
+                future_predictions = model.forecast_future(days=5)
+                self.plot_predictions(stock_data, predictions, future_predictions)
+            else:
+                st.write("Click the button above to train the model.")
+        else:
+            st.write("--------------------------------------------")
+            st.write("Please load data before training the model.")
+
+    def plot_predictions(self, stock_data, predictions, future_predictions):
+        plot_instance = Plots(stock_data)
+        plot_instance.plot_predictions(predictions, future_predictions)
+
+    def run(self):
+        st.write("--------------------------------------------")
+        st.write(f'<div style="font-size:50px">🤖 Real-Time Stock Prediction', unsafe_allow_html=True)
+        self.load_data()
+        self.handle_model_training()

STOCK-MARKET-APP/model.py

@@ -0,0 +1,51 @@
+import numpy as np
+from sklearn.preprocessing import MinMaxScaler
+from keras.models import Sequential
+from keras.layers import LSTM, Dense
+import warnings
+warnings.filterwarnings("ignore")
+
+class Model:
+    def __init__(self, data):
+        self.data = data
+        self.scaler = MinMaxScaler(feature_range=(0, 1))
+        self.model = None
+
+    def prepare_data(self, look_back=1):
+        scaled_data = self.scaler.fit_transform(self.data['Close'].values.reshape(-1, 1))
+        def create_dataset(dataset):
+            X, Y = [], []
+            for i in range(len(dataset) - look_back):
+                a = dataset[i:(i + look_back), 0]
+                X.append(a)
+                Y.append(dataset[i + look_back, 0])
+            return np.array(X), np.array(Y)
+        
+        X, Y = create_dataset(scaled_data)
+        X = np.reshape(X, (X.shape[0], 1, X.shape[1]))
+        return X, Y
+
+    def train_lstm(self, epochs=5, batch_size=1):
+        X, Y = self.prepare_data()
+        self.model = Sequential()
+        self.model.add(LSTM(50, input_shape=(1, 1)))
+        self.model.add(Dense(1))
+        self.model.compile(loss='mean_squared_error', optimizer='adam')
+        self.model.fit(X, Y, epochs=epochs, batch_size=batch_size, verbose=0)
+
+    def make_predictions(self):
+        X, _ = self.prepare_data()
+        predictions = self.model.predict(X)
+        predictions = self.scaler.inverse_transform(predictions)
+        return predictions
+
+    def forecast_future(self, days=5):
+        last_value = self.data['Close'].values[-1:].reshape(-1, 1)
+        last_scaled = self.scaler.transform(last_value)
+        future_predictions = []
+        for _ in range(days):
+            prediction = self.model.predict(last_scaled.reshape(1, 1, 1))[0]
+            future_predictions.append(prediction)
+            last_scaled = prediction  
+        future_predictions = self.scaler.inverse_transform(future_predictions)
+        return future_predictions

STOCK-MARKET-APP/plots.py

@@ -0,0 +1,49 @@
+import pandas as pd 
+import streamlit as st
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+
+
+class StockChart:
+    def __init__(self, data):
+        self.data = data
+        self.fig = make_subplots(rows=2, cols=1, vertical_spacing=0.01, shared_xaxes=True)
+
+    def add_price_chart(self):
+        self.fig.add_trace(go.Scatter(x=self.data.index, y=self.data['Open'], name='Open Price', marker_color='#1F77B4'), row=1, col=1)
+        self.fig.add_trace(go.Scatter(x=self.data.index, y=self.data['High'], name='High Price', marker_color='#9467BD'), row=1, col=1)
+        self.fig.add_trace(go.Scatter(x=self.data.index, y=self.data['Low'], name='Low Price', marker_color='#D62728'), row=1, col=1)
+        self.fig.add_trace(go.Scatter(x=self.data.index, y=self.data['Close'], name='Close Price', marker_color='#76B900'), row=1, col=1)
+
+    
+    def add_oversold_overbought_lines(self):
+        self.fig.add_hline(y=30, line_dash='dash', line_color='limegreen', line_width=1, row=1, col=1)
+        self.fig.add_hline(y=70, line_dash='dash', line_color='red', line_width=1, row=1, col=1)
+        self.fig.update_yaxes(title_text='RSI Score', row=1, col=1)
+
+    def add_volume_chart(self):
+        colors = ['#9C1F0B' if row['Open'] - row['Close'] >= 0 else '#2B8308' for index, row in self.data.iterrows()]
+        self.fig.add_trace(go.Bar(x=self.data.index, y=self.data['Volume'], showlegend=False, marker_color=colors), row=2, col=1)
+
+    def render_chart(self):
+        self.fig.update_layout(title='Historical Price and Volume', height=500, margin=dict(l=0, r=10, b=10, t=25))
+        st.plotly_chart(self.fig, use_container_width=True)        
+
+class Plots:
+    def __init__(self, data):
+        self.data = data
+
+    def plot_predictions(self, predictions, future_predictions):
+
+        predicted_dates = self.data.index[-len(predictions):]  
+        future_dates = pd.date_range(start=self.data.index[-1] + pd.Timedelta(days=1), periods=len(future_predictions), freq='B')
+        predictions = [float(val) for val in predictions if pd.notna(val)]
+        future_predictions = [float(val) for val in future_predictions if pd.notna(val)]
+
+        fig = make_subplots(rows=1, cols=1)
+        fig.add_trace(go.Scatter(x=self.data.index, y=self.data['Close'], mode='lines', name='Actual Stock Prices', marker_color='blue'))
+        fig.add_trace(go.Scatter(x=predicted_dates, y=predictions, mode='lines', name='LSTM Predicted Prices', marker_color='red', line=dict(dash='dash')))
+        fig.add_trace(go.Scatter(x=future_dates, y=future_predictions, mode='lines', name='Future Predictions', marker_color='green', line=dict(dash='dot')))
+
+        fig.update_layout(title='Comparison of Actual, Predicted, and Future Stock Prices', xaxis_title='Date', yaxis_title='Price', legend_title='Legend', height=500)
+        st.plotly_chart(fig, use_container_width=True)

STOCK-MARKET-APP/requirement.txt

@@ -0,0 +1,9 @@
+numpy
+pandas
+seaborn
+matplotlib
+keras
+tensorflow
+scikit-learn
+yfinance 
+plotly

STOCK-MARKET-APP/stock_data_loader.py

@@ -0,0 +1,19 @@
+import pandas as pd
+import yfinance as yf
+
+import warnings
+warnings.filterwarnings("ignore")
+
+class StockDataLoader:
+    def __init__(self, ticker, start_date, end_date):
+        self.ticker = ticker
+        self.start_date = start_date
+        self.end_date = end_date
+
+    def get_stock_data(self):
+        stock = yf.Ticker(self.ticker)
+        stock_data = stock.history(start=self.start_date, end=self.end_date)
+        stock_data.reset_index(inplace=True)
+        stock_data['Date'] = pd.to_datetime(stock_data['Date'])
+        stock_data.set_index('Date', inplace=True)
+        return stock_data

STOCK-MARKET-APP/utils.py

@@ -0,0 +1,324 @@
+import time
+import streamlit as st
+import yfinance as yf
+from functools import wraps
+import pandas as pd
+import numpy as np
+import random
+from datetime import datetime, timedelta
+try:
+    import pandas_datareader.data as web
+    PANDAS_DATAREADER_AVAILABLE = True
+except ImportError:
+    PANDAS_DATAREADER_AVAILABLE = False
+    st.warning("pandas_datareader not available. Install it with: pip install pandas-datareader")
+
+class RateLimitManager:
+    """Manages rate limiting for API calls"""
+    
+    def __init__(self, min_delay=3.0):
+        self.min_delay = min_delay
+        self.last_call_time = 0
+    
+    def wait_if_needed(self):
+        """Ensure minimum delay between API calls"""
+        current_time = time.time()
+        time_since_last_call = current_time - self.last_call_time
+        
+        if time_since_last_call < self.min_delay:
+            sleep_time = self.min_delay - time_since_last_call + random.uniform(0.5, 1.5)
+            time.sleep(sleep_time)
+        
+        self.last_call_time = time.time()
+
+# Global rate limit manager
+rate_limiter = RateLimitManager()
+
+def create_sample_data(ticker, period='1mo'):
+    """Create sample data when API is unavailable"""
+    
+    # Define sample data for common tickers
+    sample_data = {
+        'NVDA': {'base_price': 450, 'volatility': 0.03, 'trend': 0.001},
+        'AAPL': {'base_price': 190, 'volatility': 0.02, 'trend': 0.0005},
+        'GOOGL': {'base_price': 140, 'volatility': 0.025, 'trend': 0.0008},
+        'MSFT': {'base_price': 420, 'volatility': 0.02, 'trend': 0.0007},
+        'AMZN': {'base_price': 150, 'volatility': 0.025, 'trend': 0.0006}
+    }
+    
+    # Get parameters for ticker or use defaults
+    params = sample_data.get(ticker, {'base_price': 100, 'volatility': 0.02, 'trend': 0.0005})
+    
+    # Generate date range based on period
+    if period == 'max' or period == '1y':
+        days = 252
+    elif period == '6mo':
+        days = 126
+    elif period == '1mo':
+        days = 30
+    else:
+        days = 30
+    
+    # Create date range
+    end_date = datetime.now()
+    start_date = end_date - timedelta(days=days)
+    dates = pd.date_range(start=start_date, end=end_date, freq='D')
+    
+    # Remove weekends
+    dates = dates[dates.weekday < 5]
+    
+    # Generate price data
+    np.random.seed(42)  # For consistent sample data
+    returns = np.random.normal(params['trend'], params['volatility'], len(dates))
+    
+    prices = [params['base_price']]
+    for ret in returns[1:]:
+        prices.append(prices[-1] * (1 + ret))
+    
+    # Create DataFrame
+    df = pd.DataFrame(index=dates[:len(prices)])
+    df['Close'] = prices
+    df['Open'] = df['Close'].shift(1).fillna(df['Close'])
+    df['High'] = df['Close'] * (1 + np.random.uniform(0, 0.02, len(df)))
+    df['Low'] = df['Close'] * (1 - np.random.uniform(0, 0.02, len(df)))
+    df['Volume'] = np.random.randint(1000000, 10000000, len(df))
+    
+    return df
+
+def retry_with_backoff(max_retries=5, base_delay=10):
+    """Decorator for retrying functions with exponential backoff"""
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            for attempt in range(max_retries):
+                try:
+                    rate_limiter.wait_if_needed()
+                    return func(*args, **kwargs)
+                except Exception as e:
+                    error_msg = str(e).lower()
+                    
+                    if any(keyword in error_msg for keyword in ['rate', 'limit', '429', 'too many requests']):
+                        if attempt < max_retries - 1:
+                            wait_time = base_delay * (2 ** attempt) + random.uniform(2, 5)
+                            st.warning(f"🚫 Rate limit hit. Waiting {wait_time:.1f} seconds before retry {attempt + 2}/{max_retries}...")
+                            time.sleep(wait_time)
+                            continue
+                        else:
+                            st.error("⏱️ Rate limit exceeded after all retries. Using sample data.")
+                            return None
+                    elif any(keyword in error_msg for keyword in ['expecting value', 'no timezone', 'delisted', 'json']):
+                        if attempt < max_retries - 1:
+                            wait_time = base_delay + random.uniform(2, 4)
+                            st.warning(f"🔄 Data parsing error. Retrying in {wait_time:.1f} seconds... (attempt {attempt + 2}/{max_retries})")
+                            time.sleep(wait_time)
+                            continue
+                        else:
+                            st.warning("⚠️ Unable to fetch real data. Using sample data for demonstration.")
+                            return None
+                    else:
+                        if attempt < max_retries - 1:
+                            wait_time = base_delay + random.uniform(1, 3)
+                            st.warning(f"❗ Error: {str(e)[:100]}... Retrying in {wait_time:.1f} seconds...")
+                            time.sleep(wait_time)
+                            continue
+                        else:
+                            st.error(f"❌ Failed after {max_retries} attempts: {str(e)[:100]}...")
+                            return None
+            return None
+        return wrapper
+    return decorator
+
+def fetch_data_with_stooq(ticker_symbol, start_date=None, end_date=None, period='1mo'):
+    """Fetch stock data using pandas_datareader with stooq as source"""
+    if not PANDAS_DATAREADER_AVAILABLE:
+        return None
+    
+    try:
+        # Convert period to date range if start/end not provided
+        if start_date is None or end_date is None:
+            end_date = datetime.now()
+            if period == 'max' or period == '1y':
+                start_date = end_date - timedelta(days=365)
+            elif period == '6mo':
+                start_date = end_date - timedelta(days=180)
+            elif period == '1mo':
+                start_date = end_date - timedelta(days=30)
+            elif period == '5d':
+                start_date = end_date - timedelta(days=5)
+            else:
+                start_date = end_date - timedelta(days=30)
+        
+        # Fetch data from stooq
+        df = web.DataReader(ticker_symbol, 'stooq', start_date, end_date)
+        
+        if df.empty:
+            return None
+        
+        # Stooq returns data in reverse chronological order, so sort it
+        df = df.sort_index()
+        
+        # Ensure we have the required columns
+        required_columns = ['Open', 'High', 'Low', 'Close', 'Volume']
+        if all(col in df.columns for col in required_columns):
+            return df
+        else:
+            st.warning(f"Missing columns in stooq data: {[col for col in required_columns if col not in df.columns]}")
+            return None
+            
+    except Exception as e:
+        st.error(f"Error fetching data from stooq: {str(e)}")
+        return None
+
+def safe_yfinance_call(ticker_symbol, operation='history', **kwargs):
+    """Safely call multiple data sources with fallback to sample data"""
+    
+    # First try stooq (pandas_datareader) for historical data
+    if operation == 'history' and PANDAS_DATAREADER_AVAILABLE:
+        try:
+            st.sidebar.info(f"🔄 Trying stooq API for {ticker_symbol}...")
+            stooq_data = fetch_data_with_stooq(
+                ticker_symbol, 
+                start_date=kwargs.get('start'),
+                end_date=kwargs.get('end'),
+                period=kwargs.get('period', '1mo')
+            )
+            
+            if stooq_data is not None and not stooq_data.empty:
+                st.sidebar.success(f"✅ Real data from stooq for {ticker_symbol}")
+                return stooq_data
+            else:
+                st.sidebar.warning(f"⚠️ Stooq failed for {ticker_symbol}")
+        except Exception as e:
+            st.sidebar.warning(f"⚠️ Stooq error: {str(e)[:50]}...")
+    
+    # If stooq fails or for info operation, try yfinance as backup
+    try:
+        st.sidebar.info(f"🔄 Trying yfinance API for {ticker_symbol}...")
+        ticker = yf.Ticker(ticker_symbol)
+        
+        if operation == 'history':
+            result = ticker.history(
+                timeout=10,
+                prepost=False,
+                auto_adjust=True,
+                back_adjust=False,
+                repair=True,
+                keepna=False,
+                actions=False,
+                **kwargs
+            )
+            
+            if result is not None and not result.empty and len(result) > 0:
+                st.sidebar.success(f"✅ Real data from yfinance for {ticker_symbol}")
+                return result
+            else:
+                st.sidebar.warning(f"⚠️ yfinance returned empty data for {ticker_symbol}")
+                
+        elif operation == 'info':
+            result = ticker.info
+            if result and isinstance(result, dict) and len(result) > 1:
+                st.sidebar.success(f"✅ Info from yfinance for {ticker_symbol}")
+                return result
+            else:
+                st.sidebar.warning(f"⚠️ yfinance info empty for {ticker_symbol}")
+            
+        else:
+            raise ValueError(f"Unsupported operation: {operation}")
+            
+    except Exception as e:
+        st.sidebar.warning(f"⚠️ yfinance also failed: {str(e)[:50]}...")
+    
+    # Finally fallback to sample data
+    if operation == 'history':
+        st.sidebar.warning(f"📊 Using sample data for {ticker_symbol}")
+        return create_sample_data(ticker_symbol, kwargs.get('period', '1mo'))
+    elif operation == 'info':
+        sample_prices = {
+            'NVDA': 450, 'AAPL': 190, 'GOOGL': 140, 'MSFT': 420, 'AMZN': 150
+        }
+        base_price = sample_prices.get(ticker_symbol, 100)
+        return {
+            'symbol': ticker_symbol,
+            'shortName': f'{ticker_symbol} Inc.',
+            'currentPrice': base_price + random.uniform(-2, 2),
+            'previousClose': base_price
+        }
+    else:
+        raise Exception(f"All data sources failed for {ticker_symbol}")
+
+def get_cached_data(cache_key, ttl_seconds=300):
+    """Get cached data from session state if still valid"""
+    if cache_key in st.session_state:
+        cache_time_key = f"cache_time_{cache_key}"
+        if cache_time_key in st.session_state:
+            cache_time = st.session_state[cache_time_key]
+            if time.time() - cache_time < ttl_seconds:
+                return st.session_state[cache_key]
+    return None
+
+def set_cached_data(cache_key, data):
+    """Cache data in session state with timestamp"""
+    st.session_state[cache_key] = data
+    st.session_state[f"cache_time_{cache_key}"] = time.time()
+
+def clear_cache(pattern=None):
+    """Clear cached data matching pattern"""
+    if pattern is None:
+        # Clear all cache
+        keys_to_remove = [key for key in st.session_state.keys() 
+                         if key.startswith('cache_time_') or key.startswith('data_')]
+    else:
+        keys_to_remove = [key for key in st.session_state.keys() if pattern in key]
+    
+    for key in keys_to_remove:
+        del st.session_state[key]
+    
+    return len(keys_to_remove)
+
+def format_error_message(error):
+    """Format error messages for better user experience"""
+    error_str = str(error).lower()
+    
+    if "rate" in error_str or "limit" in error_str:
+        return ("🚫 **Rate Limit Exceeded**\n\n"
+                "Yahoo Finance has temporarily limited your requests. This happens when too many requests are made in a short time.\n\n"
+                "**What you can do:**\n"
+                "- Wait 5-10 minutes before trying again\n"
+                "- Use the cached data if available\n"
+                "- Try a different stock ticker\n\n"
+                "The app will automatically retry with delays between requests.")
+    elif "network" in error_str or "connection" in error_str:
+        return ("🌐 **Network Error**\n\n"
+                "There seems to be a connectivity issue.\n\n"
+                "**What you can do:**\n"
+                "- Check your internet connection\n"
+                "- Try refreshing the page\n"
+                "- Wait a moment and try again")
+    else:
+        return f"❌ **Error**: {str(error)}"
+
+def display_cache_info():
+    """Display cache information in sidebar"""
+    with st.sidebar:
+        with st.expander("Cache Information"):
+            cache_items = [key for key in st.session_state.keys() 
+                          if key.startswith('data_') or key.startswith('model_data_')]
+            
+            if cache_items:
+                st.write(f"**Cached items:** {len(cache_items)}")
+                for item in cache_items[:5]:  # Show first 5 items
+                    cache_time_key = f"cache_time_{item}"
+                    if cache_time_key in st.session_state:
+                        cache_time = st.session_state[cache_time_key]
+                        age_minutes = (time.time() - cache_time) / 60
+                        st.write(f"• {item.replace('data_', '')}: {age_minutes:.1f}m ago")
+                
+                if len(cache_items) > 5:
+                    st.write(f"... and {len(cache_items) - 5} more")
+                    
+                if st.button("Clear All Cache"):
+                    cleared = clear_cache()
+                    st.success(f"Cleared {cleared} cached items")
+                    st.experimental_rerun()
+            else:
+                st.write("No cached data")

STOCK-MARKET-APP/view_page.py

@@ -0,0 +1,48 @@
+from stock_data_loader import StockDataLoader
+import streamlit as st
+import pandas as pd
+import yfinance as yf
+from datetime import datetime
+from plots import Plots, StockChart
+
+class StockDashboard:
+    def __init__(self):
+        self.tickers = ['NVDA', 'AAPL', 'GOOGL', 'MSFT', 'AMZN']
+        self.period_map = {'all': 'max','1m': '1mo', '6m': '6mo', '1y': '1y'}
+
+    def render_sidebar(self):
+        st.sidebar.header("Choose your filter:")
+        self.ticker = st.sidebar.selectbox('Choose Ticker', options=self.tickers, help='Select a ticker')
+        self.selected_range = st.sidebar.selectbox('Select Period', options=list(self.period_map.keys()))
+
+    def load_data(self):
+        self.yf_data = yf.Ticker(self.ticker)
+        self.df_history = self.yf_data.history(period=self.period_map[self.selected_range])
+        self.current_price = self.yf_data.info.get('currentPrice', 'N/A')
+        self.previous_close = self.yf_data.info.get('previousClose', 'N/A')
+          
+    def display_header(self):
+        company_name = self.yf_data.info['shortName']
+        symbol = self.yf_data.info['symbol']
+        st.subheader(f'{company_name} ({symbol}) 💰')
+        st.divider()
+        if self.current_price != 'N/A' and self.previous_close != 'N/A':
+            price_change = self.current_price - self.previous_close
+            price_change_ratio = (abs(price_change) / self.previous_close * 100)
+            price_change_direction = "+" if price_change > 0 else "-"
+            st.metric(label='Current Price', value=f"{self.current_price:.2f}",
+                      delta=f"{price_change:.2f} ({price_change_direction}{price_change_ratio:.2f}%)")
+
+    def plot_data(self):
+        chart = StockChart(self.df_history)
+        chart.add_price_chart()
+        chart.add_oversold_overbought_lines()
+        chart.add_volume_chart()
+        chart.render_chart()
+
+    def run(self):
+        st.write("--------------------------------------------")
+        self.render_sidebar()
+        self.load_data()
+        self.display_header()
+        self.plot_data()