Add Alpaca trading strategy and backtesting functionality to app.py

- Introduced MLTrader class for executing trading strategies based on sentiment analysis.
- Integrated Alpaca API for trading operations, including position sizing and order management.
- Added execute_alpaca_trading function to run and backtest the trading strategy using YahooDataBacktesting.
- Updated tools list to include Alpaca Trading Executor for enhanced trading capabilities.

app.py

@@ -15,6 +15,13 @@ from statsmodels.tsa.arima.model import ARIMA
 import torch
 import re
 from typing import List, Union
+from datetime import datetime
+from lumibot.brokers import Alpaca
+from lumibot.backtesting import YahooDataBacktesting
+from lumibot.strategies.strategy import Strategy
+from alpaca_trade_api import REST
+from timedelta import Timedelta
+from finbert_utils import estimate_sentiment
 
 # Load environment variables from .env
 load_dotenv()
@@ -26,6 +33,17 @@ access_token = os.getenv("API_KEY")
 if not NEWSAPI_KEY or not access_token:
     raise ValueError("NEWSAPI_KEY or API_KEY not found in .env file.")
 
+# Alpaca credentials
+API_KEY = "PKWJW14IWRJMLJ4CSZ6V"
+API_SECRET = "zJOGwUvhYBfYJQRz6jc309PLNfTQ4VcxuygFxxfh"
+BASE_URL = "https://paper-api.alpaca.markets/v2"
+
+ALPACA_CREDS = {
+    "API_KEY": API_KEY,
+    "API_SECRET": API_SECRET,
+    "PAPER": True
+}
+
 # Initialize the model and tokenizer for the HuggingFace pipeline
 tokenizer = AutoTokenizer.from_pretrained("google/gemma-2b-it", token=access_token)
 model = AutoModelForCausalLM.from_pretrained(
@@ -78,7 +96,6 @@ def predict_stock_price(ticker, days=5):
     if hist.empty:
         return {"error": f"No data found for ticker {ticker}"}
 
-    
     model = ARIMA(hist["Close"], order=(5, 1, 0))
     model_fit = model.fit()
     forecast = model_fit.forecast(steps=days)
@@ -95,6 +112,80 @@ def compare_stocks(ticker1, ticker2):
     }
     return comparison
 
+def execute_alpaca_trading():
+    class MLTrader(Strategy):
+        def initialize(self, symbol: str = "SPY", cash_at_risk: float = .5):
+            self.symbol = symbol
+            self.sleeptime = "24H"
+            self.last_trade = None
+            self.cash_at_risk = cash_at_risk
+            self.api = REST(base_url=BASE_URL, key_id=API_KEY, secret_key=API_SECRET)
+
+        def position_sizing(self):
+            cash = self.get_cash()
+            last_price = self.get_last_price(self.symbol)
+            quantity = round(cash * self.cash_at_risk / last_price, 0)
+            return cash, last_price, quantity
+
+        def get_dates(self):
+            today = self.get_datetime()
+            three_days_prior = today - Timedelta(days=3)
+            return today.strftime('%Y-%m-%d'), three_days_prior.strftime('%Y-%m-%d')
+
+        def get_sentiment(self):
+            today, three_days_prior = self.get_dates()
+            news = self.api.get_news(symbol=self.symbol, 
+                                     start=three_days_prior, 
+                                     end=today)
+            news = [ev.__dict__["_raw"]["headline"] for ev in news]
+            probability, sentiment = estimate_sentiment(news)
+            return probability, sentiment
+
+        def on_trading_iteration(self):
+            cash, last_price, quantity = self.position_sizing()
+            probability, sentiment = self.get_sentiment()
+
+            if cash > last_price:
+                if sentiment == "positive" and probability > .999:
+                    if self.last_trade == "sell":
+                        self.sell_all()
+                    order = self.create_order(
+                        self.symbol,
+                        quantity,
+                        "buy",
+                        type="bracket",
+                        take_profit_price=last_price * 1.20,
+                        stop_loss_price=last_price * .95
+                    )
+                    self.submit_order(order)
+                    self.last_trade = "buy"
+                elif sentiment == "negative" and probability > .999:
+                    if self.last_trade == "buy":
+                        self.sell_all()
+                    order = self.create_order(
+                        self.symbol,
+                        quantity,
+                        "sell",
+                        type="bracket",
+                        take_profit_price=last_price * .8,
+                        stop_loss_price=last_price * 1.05
+                    )
+                    self.submit_order(order)
+                    self.last_trade = "sell"
+
+    start_date = datetime(2021, 1, 1)
+    end_date = datetime(2024, 10, 1)
+    broker = Alpaca(ALPACA_CREDS)
+    strategy = MLTrader(name='mlstrat', broker=broker, 
+                        parameters={"symbol": "SPY", 
+                                    "cash_at_risk": .5})
+    strategy.backtest(
+        YahooDataBacktesting, 
+        start_date, 
+        end_date, 
+        parameters={"symbol": "SPY", "cash_at_risk": .5}
+    )
+    return "Alpaca trading strategy executed and backtested."
 
 # Define LangChain tools
 stock_data_tool = Tool(
@@ -133,13 +224,20 @@ stock_comparator_tool = Tool(
     description="Compare the recent performance of two stocks given their tickers, e.g., 'AAPL,MSFT'."
 )
 
+alpaca_trading_tool = Tool(
+    name="Alpaca Trading Executor",
+    func=execute_alpaca_trading,
+    description="Run a trading strategy using Alpaca API and backtest results."
+)
+
 tools = [
     stock_data_tool, 
     stock_news_tool, 
     moving_average_tool, 
     sentiment_tool, 
     stock_prediction_tool, 
-    stock_comparator_tool
+    stock_comparator_tool,
+    alpaca_trading_tool
 ]
 
 # Set up a prompt template with history
@@ -170,20 +268,20 @@ New question: {input}
 class CustomPromptTemplate(BaseChatPromptTemplate):
     template: str
     tools: List[Tool]
-    
+
     def format_messages(self, **kwargs) -> str:
         intermediate_steps = kwargs.pop("intermediate_steps")
         thoughts = ""
         for action, observation in intermediate_steps:
             thoughts += action.log
             thoughts += f"\nObservation: {observation}\nThought: "
-            
+
         kwargs["agent_scratchpad"] = thoughts
         kwargs["tools"] = "\n".join([f"{tool.name}: {tool.description}" for tool in self.tools])
         kwargs["tool_names"] = ", ".join([tool.name for tool in self.tools])
         formatted = self.template.format(**kwargs)
         return [HumanMessage(content=formatted)]
-    
+
 prompt_with_history = CustomPromptTemplate(
     template=template_with_history,
     tools=tools,
@@ -205,7 +303,7 @@ class CustomOutputParser(AgentOutputParser):
         action = match.group(1).strip()
         action_input = match.group(2)
         return AgentAction(tool=action, tool_input=action_input.strip(" ").strip('"'), log=llm_output)
-    
+
 output_parser = CustomOutputParser()
 
 # Initialize HuggingFace pipeline
@@ -240,8 +338,4 @@ if st.button("Submit"):
                 st.write(response)
             except Exception as e:
                 st.error(f"An error occurred: {e}")
-                # Log the full LLM output for debugging
-                if hasattr(e, "output"):
-                    st.write("Raw Output:", e.output)
-    else:
-        st.warning("Please enter a query.")
+                # Log the full LLM