Add application file

app.py

@@ -0,0 +1,197 @@
+import streamlit as st
+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")
+st.markdown("""
+This app demonstrates an extended MACD-RSI based trading strategy on SPY with the following features:
+- **Multiple Simultaneous Positions:** Each buy signal creates a new position.
+- **Dynamic Trailing Stop:** Each open position is updated with a trailing stop.
+- **Configurable Parameters:** Adjust strategy parameters via the sidebar.
+- **Buy Rule:**  
+  Buy 15% of available cash when:
+  - The MACD line crosses above its signal line.
+  - RSI is below 50.
+  - No buy has been executed in the last 2 days.
+- **Sell Rule:**  
+  For each position:
+  - **Partial Sell:** Sell 40% of the position when the price reaches 1.08× the entry price and RSI is above 50.
+  - **Trailing Stop Exit:** If the price falls below the position’s dynamic trailing stop, sell the entire position.
+""")
+
+st.sidebar.header("Strategy Parameters")
+buy_fraction = st.sidebar.slider("Buy Fraction (of available cash)", 0.05, 0.50, 0.15, 0.05)
+sell_fraction = st.sidebar.slider("Partial Sell Fraction", 0.10, 0.90, 0.40, 0.05)
+target_multiplier = st.sidebar.slider("Target Multiplier", 1.01, 1.20, 1.08, 0.01)
+trailing_stop_pct = st.sidebar.slider("Trailing Stop (%)", 0.01, 0.20, 0.08, 0.01)
+min_days_between_buys = st.sidebar.number_input("Minimum Days Between Buys", min_value=1, max_value=10, value=2)
+
+@st.cache_data
+def load_data(ticker, period="1y"):
+    data = yf.download(ticker, period=period)
+    data.dropna(inplace=True)
+    return data
+
+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'])
+data['MACD'] = macd_indicator.macd()
+data['MACD_signal'] = macd_indicator.macd_signal()
+
+rsi_indicator = RSIIndicator(close=data['Close'], window=14)
+data['RSI'] = rsi_indicator.rsi()
+
+# Initialize signal flags for plotting
+data['Buy'] = False
+data['Sell'] = False
+
+# Backtesting parameters
+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
+completed_trades = []
+
+# Backtesting simulation loop
+for i in range(1, len(data)):
+    today = data.index[i]
+    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.
+    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]
+    
+    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:
+        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 = {
+                "entry_date": today,
+                "entry_price": price,
+                "allocated": allocation,
+                "shares": shares_bought,
+                "highest": price,  # track highest price achieved for this position
+                "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 ---
+    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.
+            shares_to_sell = pos["shares"] * sell_fraction
+            sell_value = shares_to_sell * price
+            cash += sell_value
+            pos["allocated"] -= shares_to_sell * pos["entry_price"]
+            pos["shares"] -= shares_to_sell
+            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"],
+                    "exit_date": today,
+                    "entry_price": pos["entry_price"],
+                    "exit_price": price,
+                    "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.
+        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}")
+            completed_trades.append({
+                "entry_date": pos["entry_date"],
+                "exit_date": today,
+                "entry_price": pos["entry_price"],
+                "exit_price": price,
+                "allocated": pos["allocated"]
+            })
+            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):
+        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)
+
+# Build performance DataFrame for visualization.
+performance = pd.DataFrame({
+    'Date': data.index[1:len(equity_curve)+1],
+    'Equity': equity_curve
+}).set_index('Date')
+
+st.subheader("Equity Curve")
+fig, ax = plt.subplots(figsize=(10, 4))
+ax.plot(performance.index, performance['Equity'], label="Total Equity")
+ax.set_xlabel("Date")
+ax.set_ylabel("Equity ($)")
+ax.legend()
+st.pyplot(fig)
+
+st.subheader("SPY Price with Buy/Sell Signals")
+fig2, ax2 = plt.subplots(figsize=(10, 4))
+ax2.plot(data.index, data['Close'], label="SPY Close Price", color='black')
+ax2.scatter(data.index[data['Buy']], data['Close'][data['Buy']], marker="^", color="green", label="Buy Signal", s=100)
+ax2.scatter(data.index[data['Sell']], data['Close'][data['Sell']], marker="v", color="red", label="Sell Signal", s=100)
+ax2.set_xlabel("Date")
+ax2.set_ylabel("Price ($)")
+ax2.legend()
+st.pyplot(fig2)
+
+st.subheader("Strategy Performance Metrics")
+final_equity = equity_curve[-1]
+return_pct = ((final_equity - initial_capital) / initial_capital) * 100
+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.*
+""")