first commit hf

.gitignore

@@ -0,0 +1,6 @@
+.streamlit/
+.venv/
+.pyton-version
+auto_trade_log.json
+uv.lock
+pyproject.toml

README.md

@@ -1,14 +1,21 @@
 ---
-title: Stocktrader
-emoji: 🐢
-colorFrom: red
-colorTo: pink
-sdk: gradio
-sdk_version: 5.29.1
+title: Stock Trader
+emoji: 📚
+colorFrom: yellow
+colorTo: purple
+sdk: streamlit
+sdk_version: 1.42.2
 app_file: app.py
 pinned: false
 license: apache-2.0
-short_description: Sample stock trading application
+short_description: 'Sample stock trading application'
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+## Installation Steps
+
+1. uv init
+2. uv add -r requirements.txt
+3. source .venv/bin/activate
+4. streamlit run deeepseek_stocktrader.py
+5. need to add streamlit secrets: .streamlit/secrets.toml
+6. add .streamlit/ to .gitignore

app.py

@@ -0,0 +1,494 @@
+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
+
+from datetime import datetime, timedelta
+import streamlit as st
+import pandas as pd
+import matplotlib.pyplot as plt
+import logging
+import threading
+import time
+import json
+import os
+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)
+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.
+
+AUTO_TRADE_INTERVAL = 10800  # Interval in seconds (e.g., 10800 seconds = 3 hours)
+
+class AlpacaTrader:
+    def __init__(self, API_KEY, API_SECRET, BASE_URL):
+        self.alpaca = alpaca.REST(API_KEY, API_SECRET, BASE_URL)
+        self.cash = 0
+        self.holdings = {}
+        self.trades = []
+
+    def get_market_status(self):
+        return self.alpaca.get_clock().is_open
+
+    def buy(self, symbol, qty):
+        try:
+            # Ensure at least $1000 in cash before buying
+            account = self.alpaca.get_account()
+            cash_balance = float(account.cash)
+            if cash_balance < 1000:
+                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}")
+            return order
+        except Exception as e:
+            logger.error(f"Error buying {symbol}: {e}")
+            return None
+
+    def sell(self, symbol, qty):
+        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}")
+            return order
+        except Exception as e:
+            logger.error(f"Error selling {symbol}: {e}")
+            return None
+
+    def getHoldings(self):
+        positions = self.alpaca.list_positions()
+        for position in positions:
+            self.holdings[position.symbol] = position.market_value
+        return self.holdings
+
+    def getCash(self):
+        return self.alpaca.get_account().cash
+
+    def update_portfolio(self, symbol, price, qty, action):
+        if action == 'buy':
+            self.cash -= price * qty
+            if symbol in self.holdings:
+                self.holdings[symbol] += price * qty
+            else:
+                self.holdings[symbol] = price * qty
+        elif action == 'sell':
+            self.cash += price * qty
+            self.holdings[symbol] -= price * qty
+            if self.holdings[symbol] <= 0:
+                del self.holdings[symbol]
+        self.trades.append({'symbol': symbol, 'price': price, 'qty': qty, 'action': action, 'time': datetime.now()})
+
+class NewsSentiment:
+    def __init__(self, API_KEY):
+        '''
+        Hutto, C.J. & Gilbert, E.E. (2014). VADER: A Parsimonious Rule-based Model for Sentiment Analysis of Social Media Text. Eighth International Conference on Weblogs and Social Media (ICWSM-14). Ann Arbor, MI, June 2014.
+        '''
+        self.newsapi = NewsApiClient(api_key=API_KEY)
+        self.sia = SentimentIntensityAnalyzer()
+
+
+    def get_news_sentiment(self, symbols):
+        '''
+        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:
+            try:
+                articles = self.newsapi.get_everything(q=symbol,
+                                                       language='en',
+                                                       sort_by='publishedAt',  # <-- fixed argument name
+                                                       page=1)
+                compound_score = 0
+                for article in articles['articles'][:5]:  # Check first 5 articles
+                    # print(f'article= {article}')
+                    score = self.sia.polarity_scores(article['title'])['compound']
+                    compound_score += score
+                avg_score = compound_score / 5 if articles['articles'] else 0
+                if avg_score > 0.1:
+                    sentiment[symbol] = 'Positive'
+                elif avg_score < -0.1:
+                    sentiment[symbol] = 'Negative'
+                else:
+                    sentiment[symbol] = 'Neutral'
+            except Exception as e:
+                logger.error(f"Error getting news for {symbol}: {e}")
+                sentiment[symbol] = 'Neutral'
+        return sentiment
+
+
+
+
+class StockAnalyzer:
+    def __init__(self, alpaca):
+        self.alpaca = alpaca
+        self.symbols = self.get_top_volume_stocks()
+        # Build a symbol->name mapping for use in plots/tables
+        self.symbol_to_name = self.get_symbol_to_name()
+
+    def get_symbol_to_name(self):
+        # Get mapping from symbol to company name using Alpaca asset info
+        assets = self.alpaca.alpaca.list_assets(status='active')
+        return {asset.symbol: asset.name for asset in assets}
+
+    def get_bars(self, alp_api, symbols, timeframe='1D'):
+        bars_data = {}
+        try:
+            bars = alp_api.get_bars(list(symbols), timeframe).df
+            for symbol in symbols:
+                symbol_bars = bars[bars['symbol'] == symbol]
+                if not symbol_bars.empty:
+                    bar_info = symbol_bars.iloc[-1]
+                    # Handle index type for timestamp
+                    if isinstance(bar_info.name, tuple):
+                        timestamp = bar_info.name[1].isoformat()
+                    else:
+                        timestamp = bar_info.name.isoformat()
+                    bars_data[symbol] = {
+                        'bar_data': {
+                            'volume': bar_info['volume'],
+                            'open': bar_info['open'],
+                            'high': bar_info['high'],
+                            'low': bar_info['low'],
+                            'close': bar_info['close'],
+                            'timestamp': timestamp
+                        }
+                    }
+                else:
+                    logger.warning(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}")
+            for symbol in symbols:
+                bars_data[symbol] = {'bar_data': None}
+        return bars_data
+
+    def assetswithconditions(self,stock_assets):
+        cond = {
+            'class': ['us_equity'],
+            'exchange': ['NASDAQ', 'NYSE'],
+            'status': ['active'],
+            'tradable': [True],
+            'marginable': [True],
+            'shortable': [True],
+            'easy_to_borrow': [True],
+            'fractionable': [True]
+        }
+        assets_with_conditions = []
+        asset_symbol_dict = {}
+        
+        for asset in stock_assets:
+            # Skip symbols with '.' or '/' (preferred shares, warrants, etc.)
+            if '.' in asset.symbol or '/' in asset.symbol:
+                continue
+
+            if (asset.__getattr__('class') in cond['class'] and 
+                asset.exchange in cond['exchange'] and
+                asset.status in cond['status'] and
+                asset.tradable in cond['tradable'] and
+                asset.marginable in cond['marginable'] and
+                asset.shortable in cond['shortable'] and 
+                asset.easy_to_borrow in cond['easy_to_borrow'] and
+                asset.fractionable in cond['fractionable']
+                ):
+                assets_with_conditions.append(asset)
+                
+                asset_no_comma = asset.name.replace(',', '')
+                asset_first_word = asset_no_comma.split()[0]
+
+                asset_symbol_dict[asset.symbol] = asset._raw
+                asset_symbol_dict[asset.symbol]['firstWord'] = asset_first_word
+                
+                sorted_dict = dict(sorted(asset_symbol_dict.items()))
+        # print(f'Length of Alpaca assets with conditions = {len(assets_with_conditions)}')
+        # print(f'assets_with_conditions = {assets_with_conditions}')
+        return assets_with_conditions, sorted_dict
+
+
+    def get_top_volume_stocks(self,num_stocks=10):
+        try:
+            # Get all tradable assets
+            assets = self.alpaca.alpaca.list_assets(status='active')
+            # tradable_assets = {asset.symbol: {} for asset in assets if asset.tradable}
+            # print(f'tradable_assets = {tradable_assets}')
+
+            assets_with_conditions, sorted_dict = self.assetswithconditions(assets)
+            # print(f'sorted_dict = {sorted_dict}')
+            # Fetch bar data for all tradable assets
+            # print(f'sorted_dict.keys()={sorted_dict.keys()}')
+            tradable_assets = self.get_bars(self.alpaca.alpaca, sorted_dict.keys(), timeframe='1D')
+
+            # Extract volume and calculate the top 10 stocks by volume
+            volume_data = {
+                symbol: info['bar_data']['volume']
+                for symbol, info in tradable_assets.items()
+                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}')
+
+            return top_volume_stocks
+        except Exception as e:
+            logger.error(f"Error fetching top volume stocks: {e}")
+            return []
+
+    def get_historical_data(self, symbols):
+        data = {}
+        for symbol in symbols:
+            try:
+                # Pull historical data from 2000-01-01 to today, daily interval
+                ticker = yf.Ticker(symbol)
+                hist = ticker.history(start='2023-01-01', end=datetime.now().strftime('%Y-%m-%d'), interval='1d')
+                data[symbol] = hist
+            except Exception as e:
+                logger.error(f"Error getting data for {symbol}: {e}")
+        return data
+
+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):
+        # Create 12 individual dynamic price plots in a 4x3 grid using Plotly (3 columns, 4 rows)
+        symbols = list(self.data.keys())
+        symbol_to_name = self.analyzer.symbol_to_name
+        n = len(symbols)
+        cols = 3
+        rows = 4
+        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=2000,
+            showlegend=False,
+            dragmode=False,  # Disable global dragmode
+        )
+        # 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
+
+def main():
+    st.title("Stock Trading Application")
+
+    if not st.secrets['ALPACA_API_KEY'] or not st.secrets['NEWS_API_KEY']:
+        st.error("Please configure your API keys in secrets.toml")
+        return
+
+    app = TradingApp()
+
+    # Start background thread only once (on first run)
+    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
+
+    if app.alpaca.get_market_status():
+        st.write("Market is open")
+    else:
+        st.write("Market is closed")
+
+    # User inputs and portfolio are now in the sidebar
+    app.manual_trade()
+
+    # Main area: plots and data
+    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()
+    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)
+        st.write("Auto-Trading History (Buy/Sell Actions Over Time):")
+        history = []
+        for entry in auto_trade_log:
+            ts = entry["timestamp"]
+            for act in entry["actions"]:
+                if act["action"] in ("Buy", "Sell"):
+                    history.append({
+                        "timestamp": ts,
+                        "symbol": act["symbol"],
+                        "action": act["action"]
+                    })
+        if history:
+            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)
+                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()

requirements.txt

@@ -0,0 +1,13 @@
+alpaca-py
+yfinance
+streamlit
+alpaca-trade-api
+alpha_vantage==2.3.1
+lxml
+newsapi-python
+vaderSentiment
+streamlit
+pandas
+matplotlib
+plotly
+sklearn