clocks update

app.py

@@ -273,14 +273,170 @@ class TradingApp:
         symbol_to_name = self.analyzer.symbol_to_name
         n = len(symbols)
 
-        # Use Streamlit's layout to get available width and adjust columns accordingly
-        # Default to 3 columns, but adjust for small or large n
-        min_col_width = 350  # px, minimum width per plot for readability
-        max_cols = max(1, min(6, n))  # Don't exceed 6 columns for readability
-
-        # Try to get the container width from Streamlit (fallback to 1200px)
-        container_width = st.get_option("deprecation.showPyplotGlobalUse")  # Not a real width, just placeholder
-        # Since Streamlit does not provide actual window width, use st.columns to adapt layout
+        # 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})
+
+    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}")
+                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)
+            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
+
+# Replace deprecated st.experimental_set_query_params with st.query_params
+st.query_params()  # This is a no-op but ensures Streamlit doesn't rerun due to query params
+
+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
@@ -431,6 +587,18 @@ def load_auto_trade_log():
 # Add this at the top after imports to suppress Streamlit reruns on widget interaction
 st.experimental_set_query_params()  # This is a no-op but ensures Streamlit doesn't rerun due to query params
 
+def get_market_times(alpaca_api):
+    try:
+        clock = alpaca_api.get_clock()
+        is_open = clock.is_open
+        now = pd.Timestamp(clock.timestamp).tz_convert('America/New_York')
+        next_close = pd.Timestamp(clock.next_close).tz_convert('America/New_York')
+        next_open = pd.Timestamp(clock.next_open).tz_convert('America/New_York')
+        return is_open, now, next_open, next_close
+    except Exception as e:
+        logger.error(f"Error fetching market times: {e}")
+        return None, None, None, None
+
 def main():
     st.title("Stock Trading Application")
 
@@ -450,10 +618,26 @@ def main():
         thread.start()
         st.session_state["auto_trade_thread_started"] = True
 
-    if app.alpaca.get_market_status():
-        st.write("Market is open")
-    else:
-        st.write("Market is closed")
+    # Dynamic market clock
+    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')}")
+
+    # Add auto-refresh for the clock every 5 seconds
+    st.experimental_rerun()
+    time.sleep(5)
 
     # User inputs and portfolio are now in the sidebar
     app.manual_trade()