Update app.py

app.py

@@ -3,8 +3,6 @@ import yfinance as yf
 import pandas as pd
 import numpy as np
 import matplotlib.pyplot as plt
-from ta.trend import MACD
-from ta.momentum import RSIIndicator
 from datetime import timedelta
 
 st.title("Extended MACD-RSI Combo Strategy for SPY")
@@ -41,23 +39,22 @@ data_load_state = st.text("Loading SPY data...")
 data = load_data("SPY", period="1y")
 data_load_state.text("Loading SPY data...done!")
 
-# Calculate technical indicators: MACD and RSI
-macd_indicator = MACD(close=data['Close'])
-macd_val = macd_indicator.macd()
-macd_signal_val = macd_indicator.macd_signal()
+# --- Manual Calculation of Technical Indicators ---
 
-# If the returned MACD is a DataFrame, extract the first column.
-if isinstance(macd_val, pd.DataFrame):
-    macd_val = macd_val.iloc[:, 0]
-if isinstance(macd_signal_val, pd.DataFrame):
-    macd_signal_val = macd_signal_val.iloc[:, 0]
+# Calculate MACD manually
+data['EMA12'] = data['Close'].ewm(span=12, adjust=False).mean()
+data['EMA26'] = data['Close'].ewm(span=26, adjust=False).mean()
+data['MACD'] = data['EMA12'] - data['EMA26']
+data['MACD_signal'] = data['MACD'].ewm(span=9, adjust=False).mean()
 
-# Assign the MACD values to the DataFrame.
-data['MACD'] = macd_val
-data['MACD_signal'] = macd_signal_val
-
-rsi_indicator = RSIIndicator(close=data['Close'], window=14)
-data['RSI'] = rsi_indicator.rsi()
+# Calculate RSI manually
+delta = data['Close'].diff()
+gain = delta.where(delta > 0, 0)
+loss = -delta.where(delta < 0, 0)
+avg_gain = gain.rolling(window=14).mean()
+avg_loss = loss.rolling(window=14).mean()
+rs = avg_gain / avg_loss
+data['RSI'] = 100 - (100 / (1 + rs))
 
 # Initialize signal flags for plotting
 data['Buy'] = False
@@ -67,14 +64,8 @@ data['Sell'] = False
 initial_capital = 100000
 cash = initial_capital
 equity_curve = []
-
-# To enforce the buy cooldown, track the last buy date.
 last_buy_date = None
-
-# List to track open positions; each position is a dictionary with details.
-open_positions = []  # keys: entry_date, entry_price, shares, allocated, highest, trailing_stop
-
-# Lists to store completed trades for analysis
+open_positions = []
 completed_trades = []
 
 # Backtesting simulation loop
@@ -83,59 +74,44 @@ for i in range(1, len(data)):
     price = data['Close'].iloc[i]
     rsi_today = data['RSI'].iloc[i]
     
-    # --- Check for a buy signal ---
-    # Signal: MACD crossover (yesterday below signal, today above signal) and RSI below 50.
+    # Check for buy signal
     macd_today = data['MACD'].iloc[i]
     signal_today = data['MACD_signal'].iloc[i]
-    macd_yesterday = data['MACD'].iloc[i - 1]
-    signal_yesterday = data['MACD_signal'].iloc[i - 1]
+    macd_yesterday = data['MACD'].iloc[i-1]
+    signal_yesterday = data['MACD_signal'].iloc[i-1]
     
     buy_condition = (macd_yesterday < signal_yesterday) and (macd_today > signal_today) and (rsi_today < 50)
     
-    # Enforce cooldown: if a buy occurred recently, skip.
-    if last_buy_date is not None and (today - last_buy_date).days < min_days_between_buys:
-        buy_condition = False
-
-    if buy_condition:
+    if buy_condition and (last_buy_date is None or (today - last_buy_date).days >= min_days_between_buys):
         allocation = cash * buy_fraction
         if allocation > 0:
             shares_bought = allocation / price
             cash -= allocation
             last_buy_date = today
-            # Initialize the open position with its own trailing stop.
-            position = {
+            open_positions.append({
                 "entry_date": today,
                 "entry_price": price,
                 "allocated": allocation,
                 "shares": shares_bought,
-                "highest": price,  # track highest price achieved for this position
+                "highest": price,
                 "trailing_stop": price * (1 - trailing_stop_pct)
-            }
-            open_positions.append(position)
+            })
             data.at[today, 'Buy'] = True
-            st.write(f"Buy: {today.date()} | Price: {price:.2f} | Shares: {shares_bought:.2f}")
 
-    # --- Update open positions for trailing stops and partial sell targets ---
+    # Update positions and check sell conditions
     positions_to_remove = []
     for idx, pos in enumerate(open_positions):
-        # Update the highest price if the current price is higher.
         if price > pos["highest"]:
             pos["highest"] = price
-            # Update trailing stop: trailing stop is highest price * (1 - trailing_stop_pct)
             pos["trailing_stop"] = pos["highest"] * (1 - trailing_stop_pct)
         
-        # Check for partial sell condition:
-        target_price = pos["entry_price"] * target_multiplier
-        if price >= target_price and rsi_today > 50:
-            # Sell a fraction of this position.
+        # Partial sell condition
+        if price >= pos["entry_price"] * target_multiplier and rsi_today > 50:
             shares_to_sell = pos["shares"] * sell_fraction
-            sell_value = shares_to_sell * price
-            cash += sell_value
-            pos["allocated"] -= shares_to_sell * pos["entry_price"]
+            cash += shares_to_sell * price
             pos["shares"] -= shares_to_sell
+            pos["allocated"] -= shares_to_sell * pos["entry_price"]
             data.at[today, 'Sell'] = True
-            st.write(f"Partial Sell: {today.date()} | Price: {price:.2f} | Shares Sold: {shares_to_sell:.2f}")
-            # If the position is nearly closed, mark it for complete removal.
             if pos["shares"] < 0.001:
                 completed_trades.append({
                     "entry_date": pos["entry_date"],
@@ -145,14 +121,11 @@ for i in range(1, len(data)):
                     "allocated": pos["allocated"]
                 })
                 positions_to_remove.append(idx)
-            # Continue to next position without checking trailing stop.
             continue
         
-        # Check trailing stop: if current price falls below the trailing stop, sell the entire position.
+        # Trailing stop exit
         if price < pos["trailing_stop"]:
-            sell_value = pos["shares"] * price
-            cash += sell_value
-            st.write(f"Trailing Stop Hit: {today.date()} | Price: {price:.2f} | Shares Sold: {pos['shares']:.2f}")
+            cash += pos["shares"] * price
             completed_trades.append({
                 "entry_date": pos["entry_date"],
                 "exit_date": today,
@@ -162,21 +135,20 @@ for i in range(1, len(data)):
             })
             positions_to_remove.append(idx)
     
-    # Remove positions that have been fully closed (reverse sort indices to remove safely)
-    for idx in sorted(positions_to_remove, reverse=True):
+    for idx in reversed(positions_to_remove):
         del open_positions[idx]
     
-    # Calculate the current value of all open positions.
-    position_value = sum([pos["shares"] * price for pos in open_positions])
-    total_equity = cash + position_value
-    equity_curve.append(total_equity)
+    # Update equity curve
+    position_value = sum(pos["shares"] * price for pos in open_positions)
+    equity_curve.append(cash + position_value)
 
-# Build performance DataFrame for visualization.
+# Build performance DataFrame
 performance = pd.DataFrame({
     'Date': data.index[1:len(equity_curve)+1],
     'Equity': equity_curve
 }).set_index('Date')
 
+# Plot results
 st.subheader("Equity Curve")
 fig, ax = plt.subplots(figsize=(10, 4))
 ax.plot(performance.index, performance['Equity'], label="Total Equity")
@@ -195,13 +167,14 @@ ax2.set_ylabel("Price ($)")
 ax2.legend()
 st.pyplot(fig2)
 
-st.subheader("Strategy Performance Metrics")
+# Display performance metrics
 final_equity = equity_curve[-1]
 return_pct = ((final_equity - initial_capital) / initial_capital) * 100
+st.subheader("Strategy Performance Metrics")
 st.write(f"**Initial Capital:** ${initial_capital:,.2f}")
 st.write(f"**Final Equity:** ${final_equity:,.2f}")
 st.write(f"**Return:** {return_pct:.2f}%")
 
 st.markdown("""
 *This extended demo is for educational purposes only and does not constitute financial advice. Always test your strategies extensively before trading with real money.*
-""")
+""")