ui updates

app.py

@@ -1,7 +1,5 @@
 import streamlit as st
-st.set_page_config(layout="wide")
 import yfinance as yf
-# import alpaca as tradeapi
 import alpaca_trade_api as alpaca
 from newsapi import NewsApiClient
 from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer
@@ -18,16 +16,18 @@ import plotly.graph_objs as go
 from sklearn.preprocessing import minmax_scale
 from plotly.subplots import make_subplots
 
-# Configure logging
-logging.basicConfig(level=logging.INFO)
+# Configure logging with timestamps
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(levelname)s - %(message)s",
+    datefmt="%Y-%m-%d %H:%M:%S"
+)
 logger = logging.getLogger(__name__)
 
-AUTO_TRADE_LOG_PATH = "auto_trade_log.json"  # Path to store auto trade log
-
-# The trading history events are saved in the file "auto_trade_log.json"
-# This file is created and updated in the current working directory where you run your Streamlit app.
-
+# Use session state keys instead of file paths
+AUTO_TRADE_LOG_KEY = "auto_trade_log"  # Session state key for trade log
 AUTO_TRADE_INTERVAL = 10800  # Interval in seconds (e.g., 10800 seconds = 3 hours)
+st.set_page_config(layout="wide")
 
 class AlpacaTrader:
     def __init__(self, API_KEY, API_SECRET, BASE_URL):
@@ -39,7 +39,7 @@ class AlpacaTrader:
     def get_market_status(self):
         return self.alpaca.get_clock().is_open
 
-    def buy(self, symbol, qty):
+    def buy(self, symbol, qty, reason=None):
         try:
             # Ensure at least $1000 in cash before buying
             account = self.alpaca.get_account()
@@ -48,13 +48,27 @@ class AlpacaTrader:
                 logger.warning(f"Low cash: (${cash_balance}) to buy {symbol}. Minimum $1000 required.")
                 return None
             order = self.alpaca.submit_order(symbol=symbol, qty=qty, side='buy', type='market', time_in_force='day')
-            logger.info(f"Bought {qty} shares of {symbol}")
+            if reason:
+                logger.info(f"Bought {qty} shares of {symbol} [Reason: {reason}]")
+            else:
+                logger.info(f"Bought {qty} shares of {symbol}")
+            
+            # Record the trade
+            if order:
+                self.trades.append({
+                    'symbol': symbol, 
+                    'qty': qty, 
+                    'action': 'Buy', 
+                    'time': datetime.now(),
+                    'reason': reason
+                })
+            
             return order
         except Exception as e:
             logger.error(f"Error buying {symbol}: {e}")
             return None
 
-    def sell(self, symbol, qty):
+    def sell(self, symbol, qty, reason=None):
         # Check if position exists and has enough quantity before attempting to sell
         positions = {p.symbol: float(p.qty) for p in self.alpaca.list_positions()}
         if symbol not in positions:
@@ -65,7 +79,21 @@ class AlpacaTrader:
             return None
         try:
             order = self.alpaca.submit_order(symbol=symbol, qty=qty, side='sell', type='market', time_in_force='day')
-            logger.info(f"Sold {qty} shares of {symbol}")
+            if reason:
+                logger.info(f"Sold {qty} shares of {symbol} [Reason: {reason}]")
+            else:
+                logger.info(f"Sold {qty} shares of {symbol}")
+            
+            # Record the trade
+            if order:
+                self.trades.append({
+                    'symbol': symbol, 
+                    'qty': qty, 
+                    'action': 'Sell', 
+                    'time': datetime.now(),
+                    'reason': reason
+                })
+            
             return order
         except Exception as e:
             logger.error(f"Error selling {symbol}: {e}")
@@ -74,7 +102,9 @@ class AlpacaTrader:
     def getHoldings(self):
         positions = self.alpaca.list_positions()
         for position in positions:
-            self.holdings[position.symbol] = position.market_value
+            self.holdings[position.symbol] = float(position.market_value)
+        
+        # Return holdings as a dictionary for internal use
         return self.holdings
 
     def getCash(self):
@@ -105,7 +135,9 @@ class NewsSentiment:
 
     def get_news_sentiment(self, symbols):
         '''
+        The News API has a rate limit of 100 requests per day for free accounts. If you exceed this limit, you'll get a rateLimited error. Example error message:
         ERROR:__main__:Error getting news for APLD: {'status': 'error', 'code': 'rateLimited', 'message': 'You have made too many requests recently. Developer accounts are limited to 100 requests over a 24 hour period (50 requests available every 12 hours). Please upgrade to a paid plan if you need more requests.'}
+        
         '''
         sentiment = {}
         for symbol in symbols:
@@ -170,7 +202,8 @@ class StockAnalyzer:
                         }
                     }
                 else:
-                    logger.warning(f"No bar data for symbol: {symbol}")
+                    # Only log at debug level to avoid spamming warnings for missing bar data
+                    logger.debug(f"No bar data for symbol: {symbol}")
                     bars_data[symbol] = {'bar_data': None}
         except Exception as e:
             logger.warning(f"Error fetching bars in batch: {e}")
@@ -240,7 +273,7 @@ class StockAnalyzer:
                 if info['bar_data'] is not None
             }
             top_volume_stocks = sorted(volume_data, key=volume_data.get, reverse=True)[:num_stocks]
-            print(f'top_volume_stocks = {top_volume_stocks}')
+            logger.info(f'top_volume_stocks = {top_volume_stocks}')
 
             return top_volume_stocks
         except Exception as e:
@@ -272,19 +305,8 @@ class TradingApp:
         symbols = list(self.data.keys())
         symbol_to_name = self.analyzer.symbol_to_name
         n = len(symbols)
-
         # Calculate columns based on n for best fit
-        if n <= 3:
-            cols = n
-        elif n <= 6:
-            cols = 3
-        elif n <= 8:
-            cols = 4
-        elif n <= 12:
-            cols = 4
-        else:
-            cols = 5
-
+        cols = 3
         rows = (n + cols - 1) // cols
         subplot_titles = [
             f"{symbol} - {symbol_to_name.get(symbol, '')}" for symbol in symbols
@@ -327,201 +349,112 @@ class TradingApp:
         with st.sidebar:
             st.header("Manual Trade")
             symbol = st.text_input('Enter stock symbol')
-            qty = int(st.number_input('Enter quantity'))
-            action = st.selectbox('Action', ['Buy', 'Sell'])
-            if st.button('Execute'):
-                if action == 'Buy':
-                    order = self.alpaca.buy(symbol, qty)
-                else:
-                    order = self.alpaca.sell(symbol, qty)
-                if order:
-                    st.success(f"Order executed: {action} {qty} shares of {symbol}")
-                else:
-                    st.error("Order failed")
-            st.header("Portfolio")
-            st.write("Cash Balance:")
-            st.write(self.alpaca.getCash())
-            st.write("Holdings:")
-            st.write(self.alpaca.getHoldings())
-            st.write("Recent Trades:")
-            st.write(pd.DataFrame(self.alpaca.trades))
-
-    def auto_trade_based_on_sentiment(self, sentiment):
-        # Add company name to each action
-        actions = []
-        symbol_to_name = self.analyzer.symbol_to_name
-        for symbol, sentiment_value in sentiment.items():
-            action = None
-            if sentiment_value == 'Positive':
-                order = self.alpaca.buy(symbol, 1)
-                action = 'Buy'
-            elif sentiment_value == 'Negative':
-                order = self.alpaca.sell(symbol, 1)
-                action = 'Sell'
-            else:
-                order = None
-                action = 'Hold'
-            actions.append({
-                'symbol': symbol,
-                'company_name': symbol_to_name.get(symbol, ''),
-                'sentiment': sentiment_value,
-                'action': action
-            })
-        self.auto_trade_log = actions
-        return actions
 
-def background_auto_trade(app):
-    # This function runs in a background thread and does not require a TTY.
-    # The warning "tcgetpgrp failed: Not a tty" is harmless and can be ignored.
-    # It is likely caused by the environment in which the script is running (e.g., Streamlit, Docker, or a notebook).
-    # No code changes are needed for this warning.
-    while True:
-        sentiment = app.sentiment.get_news_sentiment(app.analyzer.symbols)
-        actions = []
-        for symbol, sentiment_value in sentiment.items():
-            action = None
-            if sentiment_value == 'Positive':
-                order = app.alpaca.buy(symbol, 1)
-                action = 'Buy'
-            elif sentiment_value == 'Negative':
-                order = app.alpaca.sell(symbol, 1)
-                action = 'Sell'
-            else:
-                order = None
-                action = 'Hold'
-            actions.append({
-                'symbol': symbol,
-                'sentiment': sentiment_value,
-                'action': action
-            })
-        # Append to log file instead of overwriting
-        log_entry = {
-            "timestamp": datetime.now().isoformat(),
-            "actions": actions,
-            "sentiment": sentiment
-        }
-        try:
-            if os.path.exists(AUTO_TRADE_LOG_PATH):
-                with open(AUTO_TRADE_LOG_PATH, "r") as f:
-                    log_data = json.load(f)
+            # Fetch the current stock price dynamically using Alpaca's API
+            def get_stock_price(symbol):
+                try:
+                    if not symbol:
+                        return None
+                    last_trade = self.alpaca.alpaca.get_latest_trade(symbol)
+                    return last_trade.price
+                except Exception as e:
+                    logger.error(f"Error fetching stock price for {symbol}: {e}")
+                    return None
+
+            # Update stock price when a new symbol is entered
+            if symbol:
+                if "stock_price" not in st.session_state or st.session_state.get("last_symbol") != symbol:
+                    st.session_state["stock_price"] = get_stock_price(symbol)
+                    st.session_state["last_symbol"] = symbol
+
+            stock_price = st.session_state.get("stock_price")
+            # Explicitly display the stock price below the input field
+            if stock_price is not None:
+                st.write(f"Current stock price for {symbol.upper()}: ${stock_price:,.2f}")
             else:
-                log_data = []
-        except Exception:
-            log_data = []
-        log_data.append(log_entry)
-        with open(AUTO_TRADE_LOG_PATH, "w") as f:
-            json.dump(log_data, f)
-        time.sleep(AUTO_TRADE_INTERVAL)
-
-def load_auto_trade_log():
-    try:
-        with open(AUTO_TRADE_LOG_PATH, "r") as f:
-            return json.load(f)
-    except Exception:
-        return None
-
-class TradingApp:
-    def __init__(self):
-        self.alpaca = AlpacaTrader(st.secrets['ALPACA_API_KEY'], st.secrets['ALPACA_SECRET_KEY'], 'https://paper-api.alpaca.markets')
-        self.sentiment = NewsSentiment(st.secrets['NEWS_API_KEY'])
-        self.analyzer = StockAnalyzer(self.alpaca)
-        self.data = self.analyzer.get_historical_data(self.analyzer.symbols)
-        self.auto_trade_log = []  # Store automatic trade actions
-
-    def display_charts(self):
-        # Dynamically adjust columns based on number of stocks and available width
-        symbols = list(self.data.keys())
-        symbol_to_name = self.analyzer.symbol_to_name
-        n = len(symbols)
-
-        # Calculate columns based on n for best fit
-        if n <= 3:
-            cols = n
-        elif n <= 6:
-            cols = 3
-        elif n <= 8:
-            cols = 4
-        elif n <= 12:
-            cols = 4
-        else:
-            cols = 5
-
-        rows = (n + cols - 1) // cols
-        subplot_titles = [
-            f"{symbol} - {symbol_to_name.get(symbol, '')}" for symbol in symbols
-        ]
-        fig = make_subplots(rows=rows, cols=cols, subplot_titles=subplot_titles)
-        for idx, symbol in enumerate(symbols):
-            df = self.data[symbol]
-            if not df.empty:
-                row = idx // cols + 1
-                col = idx % cols + 1
-                fig.add_trace(
-                    go.Scatter(
-                        x=df.index,
-                        y=df['Close'],
-                        mode='lines',
-                        name=symbol,
-                        hovertemplate=f"%{{x}}<br>{symbol}: %{{y:.2f}}<extra></extra>"
-                    ),
-                    row=row,
-                    col=col
-                )
-        fig.update_layout(
-            title="Top Volume Stocks - Price Charts (Since 2023)",
-            height=max(400 * rows, 600),
-            showlegend=False,
-            dragmode=False,
-        )
-        # Enable scroll-zoom for each subplot (individual zoom)
-        fig.update_layout(
-            xaxis=dict(fixedrange=False),
-            yaxis=dict(fixedrange=False),
-        )
-        for i in range(1, rows * cols + 1):
-            fig.layout[f'xaxis{i}'].update(fixedrange=False)
-            fig.layout[f'yaxis{i}'].update(fixedrange=False)
-        st.plotly_chart(fig, use_container_width=True, config={"scrollZoom": True})
+                st.write("Enter a valid stock symbol to see the price.")
+
+            # Allow user to enter either quantity or amount
+            trade_option = st.radio("Trade Option", ["Enter Quantity", "Enter Amount"])
+            qty = st.number_input('Enter quantity', min_value=0.0, step=0.01, value=0.0) if trade_option == "Enter Quantity" else None
+            amount = st.number_input('Enter amount ($)', min_value=0.0, step=0.01, value=0.0) if trade_option == "Enter Amount" else None
+
+            # Dynamically calculate the other field
+            if stock_price:
+                if trade_option == "Enter Quantity" and qty:
+                    amount = qty * stock_price
+                    st.write(f"Calculated Amount: ${amount:,.2f}")
+                elif trade_option == "Enter Amount" and amount:
+                    qty = float(amount / stock_price)
+                    st.write(f"Calculated Quantity: {qty:,.2f}")
 
-    def manual_trade(self):
-        # Move all user inputs to the sidebar
-        with st.sidebar:
-            st.header("Manual Trade")
-            symbol = st.text_input('Enter stock symbol')
-            qty = int(st.number_input('Enter quantity'))
             action = st.selectbox('Action', ['Buy', 'Sell'])
             if st.button('Execute'):
-                if action == 'Buy':
-                    order = self.alpaca.buy(symbol, qty)
-                else:
-                    order = self.alpaca.sell(symbol, qty)
-                if order:
-                    st.success(f"Order executed: {action} {qty} shares of {symbol}")
+                if stock_price and qty:
+                    is_market_open = self.alpaca.get_market_status()
+                    if action == 'Buy':
+                        order = self.alpaca.buy(symbol, qty, reason="Manual Trade")
+                    else:
+                        order = self.alpaca.sell(symbol, qty, reason="Manual Trade")
+                    
+                    if order:
+                        if not is_market_open:
+                            _, _, next_open, _ = get_market_times(self.alpaca.alpaca)
+                            next_open_time = next_open.strftime('%Y-%m-%d %H:%M:%S') if next_open else "unknown"
+                            st.warning(f"Market is currently closed. The {action.lower()} order for {qty} shares of {symbol} has been submitted and will execute when the market opens at {next_open_time}.")
+                        else:
+                            st.success(f"Order executed: {action} {qty} shares of {symbol}")
+                    else:
+                        st.error("Order failed")
                 else:
-                    st.error("Order failed")
-            st.header("Portfolio")
-            st.write("Cash Balance:")
-            st.write(self.alpaca.getCash())
-            st.write("Holdings:")
-            st.write(self.alpaca.getHoldings())
-            st.write("Recent Trades:")
-            st.write(pd.DataFrame(self.alpaca.trades))
+                    st.error("Please enter a valid stock symbol and trade details.")
+
+            # Display portfolio information in the sidebar
+            st.header("Alpaca Cash Portfolio")
+
+            def refresh_portfolio():
+                account = self.alpaca.alpaca.get_account()
+                portfolio_data = {
+                    "Metric": ["Cash Balance", "Buying Power", "Equity", "Portfolio Value"],
+                    "Value": [
+                        f"${int(float(account.cash)):,.0f}",
+                        f"${int(float(account.buying_power)):,.0f}",
+                        f"${int(float(account.equity)):,.0f}",
+                        f"${int(float(account.portfolio_value)):,.0f}"
+                    ]
+                }
+                df = pd.DataFrame(portfolio_data)
+                st.table(df.to_dict(orient="records"))  # Convert DataFrame to a list of dictionaries
+
+            refresh_portfolio()
+            st.button("Refresh Portfolio", on_click=refresh_portfolio)
+        # ...existing code...
 
     def auto_trade_based_on_sentiment(self, sentiment):
-        # Add company name to each action
         actions = []
         symbol_to_name = self.analyzer.symbol_to_name
         for symbol, sentiment_value in sentiment.items():
             action = None
+            is_market_open = self.alpaca.get_market_status()
             if sentiment_value == 'Positive':
-                order = self.alpaca.buy(symbol, 1)
+                order = self.alpaca.buy(symbol, 1, reason="Sentiment: Positive")
                 action = 'Buy'
             elif sentiment_value == 'Negative':
-                order = self.alpaca.sell(symbol, 1)
+                order = self.alpaca.sell(symbol, 1, reason="Sentiment: Negative")
                 action = 'Sell'
             else:
                 order = None
                 action = 'Hold'
+                logger.info(f"Held {symbol}")
+
+            if order:
+                if not is_market_open:
+                    _, _, next_open, _ = get_market_times(self.alpaca.alpaca)
+                    next_open_time = next_open.strftime('%Y-%m-%d %H:%M:%S') if next_open else "unknown"
+                    logger.warning(f"Market is currently closed. The {action.lower()} order for 1 share of {symbol} has been submitted and will execute when the market opens at {next_open_time}.")
+                else:
+                    logger.info(f"Order executed: {action} 1 share of {symbol}")
+
             actions.append({
                 'symbol': symbol,
                 'company_name': symbol_to_name.get(symbol, ''),
@@ -532,216 +465,81 @@ class TradingApp:
         return actions
 
 def background_auto_trade(app):
-    # This function runs in a background thread and does not require a TTY.
-    # The warning "tcgetpgrp failed: Not a tty" is harmless and can be ignored.
-    # It is likely caused by the environment in which the script is running (e.g., Streamlit, Docker, or a notebook).
-    # No code changes are needed for this warning.
+    # This function runs in a background thread and updates session state
     while True:
         sentiment = app.sentiment.get_news_sentiment(app.analyzer.symbols)
+        symbol_to_name = app.analyzer.symbol_to_name
         actions = []
         for symbol, sentiment_value in sentiment.items():
             action = None
+            is_market_open = app.alpaca.get_market_status()
             if sentiment_value == 'Positive':
-                order = app.alpaca.buy(symbol, 1)
+                order = app.alpaca.buy(symbol, 1, reason="Sentiment: Positive")
                 action = 'Buy'
             elif sentiment_value == 'Negative':
-                order = app.alpaca.sell(symbol, 1)
+                order = app.alpaca.sell(symbol, 1, reason="Sentiment: Negative")
                 action = 'Sell'
             else:
                 order = None
                 action = 'Hold'
-            actions.append({
-                'symbol': symbol,
-                'sentiment': sentiment_value,
-                'action': action
-            })
-        # Append to log file instead of overwriting
-        log_entry = {
-            "timestamp": datetime.now().isoformat(),
-            "actions": actions,
-            "sentiment": sentiment
-        }
-        try:
-            if os.path.exists(AUTO_TRADE_LOG_PATH):
-                with open(AUTO_TRADE_LOG_PATH, "r") as f:
-                    log_data = json.load(f)
-            else:
-                log_data = []
-        except Exception:
-            log_data = []
-        log_data.append(log_entry)
-        with open(AUTO_TRADE_LOG_PATH, "w") as f:
-            json.dump(log_data, f)
-        time.sleep(AUTO_TRADE_INTERVAL)
-
-def load_auto_trade_log():
-    try:
-        with open(AUTO_TRADE_LOG_PATH, "r") as f:
-            return json.load(f)
-    except Exception:
-        return None
-
-class TradingApp:
-    def __init__(self):
-        self.alpaca = AlpacaTrader(st.secrets['ALPACA_API_KEY'], st.secrets['ALPACA_SECRET_KEY'], 'https://paper-api.alpaca.markets')
-        self.sentiment = NewsSentiment(st.secrets['NEWS_API_KEY'])
-        self.analyzer = StockAnalyzer(self.alpaca)
-        self.data = self.analyzer.get_historical_data(self.analyzer.symbols)
-        self.auto_trade_log = []  # Store automatic trade actions
-
-    def display_charts(self):
-        # Dynamically adjust columns based on number of stocks and available width
-        symbols = list(self.data.keys())
-        symbol_to_name = self.analyzer.symbol_to_name
-        n = len(symbols)
-
-        # Calculate columns based on n for best fit
-        if n <= 3:
-            cols = n
-        elif n <= 6:
-            cols = 3
-        elif n <= 8:
-            cols = 4
-        elif n <= 12:
-            cols = 4
-        else:
-            cols = 5
+                logger.info(f"Held {symbol}")
 
-        rows = (n + cols - 1) // cols
-        subplot_titles = [
-            f"{symbol} - {symbol_to_name.get(symbol, '')}" for symbol in symbols
-        ]
-        fig = make_subplots(rows=rows, cols=cols, subplot_titles=subplot_titles)
-        for idx, symbol in enumerate(symbols):
-            df = self.data[symbol]
-            if not df.empty:
-                row = idx // cols + 1
-                col = idx % cols + 1
-                fig.add_trace(
-                    go.Scatter(
-                        x=df.index,
-                        y=df['Close'],
-                        mode='lines',
-                        name=symbol,
-                        hovertemplate=f"%{{x}}<br>{symbol}: %{{y:.2f}}<extra></extra>"
-                    ),
-                    row=row,
-                    col=col
-                )
-        fig.update_layout(
-            title="Top Volume Stocks - Price Charts (Since 2023)",
-            height=max(400 * rows, 600),
-            showlegend=False,
-            dragmode=False,
-        )
-        # Enable scroll-zoom for each subplot (individual zoom)
-        fig.update_layout(
-            xaxis=dict(fixedrange=False),
-            yaxis=dict(fixedrange=False),
-        )
-        for i in range(1, rows * cols + 1):
-            fig.layout[f'xaxis{i}'].update(fixedrange=False)
-            fig.layout[f'yaxis{i}'].update(fixedrange=False)
-        st.plotly_chart(fig, use_container_width=True, config={"scrollZoom": True})
-
-    def manual_trade(self):
-        # Move all user inputs to the sidebar
-        with st.sidebar:
-            st.header("Manual Trade")
-            symbol = st.text_input('Enter stock symbol')
-            qty = int(st.number_input('Enter quantity'))
-            action = st.selectbox('Action', ['Buy', 'Sell'])
-            if st.button('Execute'):
-                if action == 'Buy':
-                    order = self.alpaca.buy(symbol, qty)
+            if order:
+                if not is_market_open:
+                    _, _, next_open, _ = get_market_times(app.alpaca.alpaca)
+                    next_open_time = next_open.strftime('%Y-%m-%d %H:%M:%S') if next_open else "unknown"
+                    logger.warning(f"Market is currently closed. The {action.lower()} order for 1 share of {symbol} has been submitted and will execute when the market opens at {next_open_time}.")
                 else:
-                    order = self.alpaca.sell(symbol, qty)
-                if order:
-                    st.success(f"Order executed: {action} {qty} shares of {symbol}")
-                else:
-                    st.error("Order failed")
-            st.header("Portfolio")
-            st.write("Cash Balance:")
-            st.write(self.alpaca.getCash())
-            st.write("Holdings:")
-            st.write(self.alpaca.getHoldings())
-            st.write("Recent Trades:")
-            st.write(pd.DataFrame(self.alpaca.trades))
+                    logger.info(f"Order executed: {action} 1 share of {symbol}")
 
-    def auto_trade_based_on_sentiment(self, sentiment):
-        # Add company name to each action
-        actions = []
-        symbol_to_name = self.analyzer.symbol_to_name
-        for symbol, sentiment_value in sentiment.items():
-            action = None
-            if sentiment_value == 'Positive':
-                order = self.alpaca.buy(symbol, 1)
-                action = 'Buy'
-            elif sentiment_value == 'Negative':
-                order = self.alpaca.sell(symbol, 1)
-                action = 'Sell'
-            else:
-                order = None
-                action = 'Hold'
             actions.append({
                 'symbol': symbol,
                 'company_name': symbol_to_name.get(symbol, ''),
                 'sentiment': sentiment_value,
                 'action': action
             })
-        self.auto_trade_log = actions
-        return actions
-
-def background_auto_trade(app):
-    # This function runs in a background thread and does not require a TTY.
-    # The warning "tcgetpgrp failed: Not a tty" is harmless and can be ignored.
-    # It is likely caused by the environment in which the script is running (e.g., Streamlit, Docker, or a notebook).
-    # No code changes are needed for this warning.
-    while True:
-        sentiment = app.sentiment.get_news_sentiment(app.analyzer.symbols)
-        actions = []
-        for symbol, sentiment_value in sentiment.items():
-            action = None
-            if sentiment_value == 'Positive':
-                order = app.alpaca.buy(symbol, 1)
-                action = 'Buy'
-            elif sentiment_value == 'Negative':
-                order = app.alpaca.sell(symbol, 1)
-                action = 'Sell'
-            else:
-                order = None
-                action = 'Hold'
-            actions.append({
-                'symbol': symbol,
-                'sentiment': sentiment_value,
-                'action': action
-            })
-        # Append to log file instead of overwriting
+        
+        # Create log entry
         log_entry = {
             "timestamp": datetime.now().isoformat(),
             "actions": actions,
             "sentiment": sentiment
         }
-        try:
-            if os.path.exists(AUTO_TRADE_LOG_PATH):
-                with open(AUTO_TRADE_LOG_PATH, "r") as f:
-                    log_data = json.load(f)
-            else:
-                log_data = []
-        except Exception:
-            log_data = []
-        log_data.append(log_entry)
-        with open(AUTO_TRADE_LOG_PATH, "w") as f:
-            json.dump(log_data, f)
+        
+        # Update session state - need to use a thread lock to safely update
+        if hasattr(threading, "main_thread") and threading.current_thread() is threading.main_thread():
+            # Direct update if in main thread
+            update_auto_trade_log(log_entry)
+        else:
+            # Safer to just store the latest entry, which the main thread will pick up
+            st.session_state["latest_auto_trade_entry"] = log_entry
+            
         time.sleep(AUTO_TRADE_INTERVAL)
 
-def load_auto_trade_log():
-    try:
-        with open(AUTO_TRADE_LOG_PATH, "r") as f:
-            return json.load(f)
-    except Exception:
-        return None
-
+def update_auto_trade_log(log_entry):
+    """Update auto trade log in session state"""
+    if AUTO_TRADE_LOG_KEY not in st.session_state:
+        st.session_state[AUTO_TRADE_LOG_KEY] = []
+    
+    # Append the new entry
+    st.session_state[AUTO_TRADE_LOG_KEY].append(log_entry)
+    
+    # Limit size to avoid memory issues (keep last 50 entries)
+    if len(st.session_state[AUTO_TRADE_LOG_KEY]) > 50:
+        st.session_state[AUTO_TRADE_LOG_KEY] = st.session_state[AUTO_TRADE_LOG_KEY][-50:]
+
+def get_auto_trade_log():
+    """Get the auto trade log from session state"""
+    if AUTO_TRADE_LOG_KEY not in st.session_state:
+        st.session_state[AUTO_TRADE_LOG_KEY] = []
+    
+    # Check if we have a new entry from background thread
+    if "latest_auto_trade_entry" in st.session_state:
+        update_auto_trade_log(st.session_state["latest_auto_trade_entry"])
+        # Clear the latest entry after adding it
+        del st.session_state["latest_auto_trade_entry"]
+        
+    return st.session_state[AUTO_TRADE_LOG_KEY]
 
 def get_market_times(alpaca_api):
     try:
@@ -768,51 +566,85 @@ def main():
         st.session_state["app_instance"] = TradingApp()
     app = st.session_state["app_instance"]
 
+    # Create two columns for market status and portfolio holdings
+    col1, col2 = st.columns([1, 1])
+
+    # Column 1: Market status
+    with col1:
+        is_open, now, next_open, next_close = get_market_times(app.alpaca.alpaca)
+        market_status = "🟢 Market is OPEN" if is_open else "🔴 Market is CLOSED"
+        st.markdown(f"### {market_status}")
+        if now is not None:
+            st.markdown(f"**Current time (ET):** {now.strftime('%Y-%m-%d %H:%M:%S')}")
+        if is_open and next_close is not None:
+            st.markdown(f"**Market closes at:** {next_close.strftime('%Y-%m-%d %H:%M:%S')} ET")
+            seconds_left = int((next_close - now).total_seconds())
+            st.markdown(f"**Time until close:** {pd.to_timedelta(seconds_left, unit='s')}")
+        elif not is_open and next_open is not None:
+            st.markdown(f"**Market opens at:** {next_open.strftime('%Y-%m-%d %H:%M:%S')} ET")
+            seconds_left = int((next_open - now).total_seconds())
+            st.markdown(f"**Time until open:** {pd.to_timedelta(seconds_left, unit='s')}")
+
+    # Column 2: Portfolio holdings bar chart
+    with col2:
+        st.subheader("Portfolio Holdings")
+        holdings_container = st.empty()  # Create a container for dynamic updates
+        def update_holdings():
+            holdings = app.alpaca.getHoldings()
+            if holdings:
+                df = pd.DataFrame(list(holdings.items()), columns=['Ticker', 'Market Value'])
+                fig = go.Figure(
+                    data=[
+                        go.Bar(
+                            x=df['Ticker'],
+                            y=df['Market Value'],
+                            marker=dict(color=df['Market Value'], colorscale='Viridis'),
+                        )
+                    ]
+                )
+                fig.update_layout(
+                    xaxis_title="Ticker",
+                    yaxis_title="$ USD",
+                    height=400,
+                )
+                # Use a unique key by appending the current timestamp
+                holdings_container.plotly_chart(fig, use_container_width=True, key=f"portfolio_holdings_chart_{time.time()}")
+            else:
+                holdings_container.info("No holdings to display.")
+
+        # Periodically refresh the holdings plot
+        update_holdings()
+        st.button("Refresh Holdings", on_click=update_holdings)
+
+    # Initialize auto trade log in session state if needed
+    if AUTO_TRADE_LOG_KEY not in st.session_state:
+        st.session_state[AUTO_TRADE_LOG_KEY] = []
+
     # Only start the background thread once
     if "auto_trade_thread_started" not in st.session_state:
         thread = threading.Thread(target=background_auto_trade, args=(app,), daemon=True)
         thread.start()
         st.session_state["auto_trade_thread_started"] = True
 
-    # Static market clock (no auto-refresh)
-    is_open, now, next_open, next_close = get_market_times(app.alpaca.alpaca)
-    market_status = "🟢 Market is OPEN" if is_open else "🔴 Market is CLOSED"
-    st.markdown(f"### {market_status}")
-    if now is not None:
-        st.markdown(f"**Current time (ET):** {now.strftime('%Y-%m-%d %H:%M:%S')}")
-    if is_open and next_close is not None:
-        st.markdown(f"**Market closes at:** {next_close.strftime('%Y-%m-%d %H:%M:%S')} ET")
-        # Show countdown to close
-        seconds_left = int((next_close - now).total_seconds())
-        st.markdown(f"**Time until close:** {pd.to_timedelta(seconds_left, unit='s')}")
-    elif not is_open and next_open is not None:
-        st.markdown(f"**Market opens at:** {next_open.strftime('%Y-%m-%d %H:%M:%S')} ET")
-        # Show countdown to open
-        seconds_left = int((next_open - now).total_seconds())
-        st.markdown(f"**Time until open:** {pd.to_timedelta(seconds_left, unit='s')}")
-
-    # User inputs and portfolio are now in the sidebar
-    app.manual_trade()
-
     # Main area: plots and data
+    app.manual_trade()
     app.display_charts()
 
     # Read and display latest auto-trade actions
     st.write("Automatic Trading Actions Based on Sentiment (background):")
-    auto_trade_log = load_auto_trade_log()
+    auto_trade_log = get_auto_trade_log()
     if auto_trade_log:
         # Show the most recent entry
         last_entry = auto_trade_log[-1]
         st.write(f"Last checked: {last_entry['timestamp']}")
         df = pd.DataFrame(last_entry["actions"])
-        # Reorder columns for clarity
         if "company_name" in df.columns:
             df = df[["symbol", "company_name", "sentiment", "action"]]
         st.dataframe(df)
         st.write("Sentiment Analysis (latest):")
         st.write(last_entry["sentiment"])
 
-        # Plot buy/sell actions over time (aggregate for all symbols)
+        # Plot buy/sell actions over time
         st.write("Auto-Trading History (Buy/Sell Actions Over Time):")
         history = []
         for entry in auto_trade_log:
@@ -828,36 +660,12 @@ def main():
             hist_df = pd.DataFrame(history)
             if not hist_df.empty:
                 hist_df["timestamp"] = pd.to_datetime(hist_df["timestamp"])
-                # Pivot to get Buy/Sell counts per symbol over time
-                # Avoid FutureWarning by explicitly converting to float after replace
-                hist_df["action_value"] = hist_df["action"].replace({"Buy": 1, "Sell": -1})
-                hist_df["action_value"] = hist_df["action_value"].astype(float)
+                hist_df["action_value"] = hist_df["action"].replace({"Buy": 1, "Sell": -1}).astype(float)
                 pivot = hist_df.pivot_table(index="timestamp", columns="symbol", values="action_value", aggfunc="sum")
                 st.line_chart(pivot.fillna(0))
     else:
         st.info("Waiting for first background auto-trade run...")
 
-# Explanation:
-# In Alpaca:
-# - 'cash' is the actual cash available in your account (uninvested funds).
-# - 'buying_power' is the total amount you can use to buy securities, which may be higher than cash if you have margin enabled.
-#   For a cash account, buying_power == cash.
-#   For a margin account, buying_power can be up to 2x (or 4x for day trading) your cash, depending on regulations and your account status.
-
-# Example usage:
-# account = alpaca.get_account()
-# cash_balance = account.cash
-# buying_power = account.buying_power
-
-# Note:
-# To disable margin on your Alpaca paper account, you must set your account type to "cash" instead of "margin".
-# This cannot be changed via the API or code. You must:
-# 1. Log in to your Alpaca dashboard at https://app.alpaca.markets/
-# 2. Go to "Paper Trading" > "Settings"
-# 3. Set the account type to "Cash" (not "Margin")
-# 4. If you do not see this option, you may need to reset your paper account or contact Alpaca support.
-
-# There is no programmatic/API way to change the margin setting for a paper account.
 
 if __name__ == "__main__":
     main()