Create app.py

app.py

@@ -0,0 +1,240 @@
+import streamlit as st
+import yfinance as yf
+import pandas as pd
+import numpy as np
+import plotly.graph_objs as go
+from datetime import datetime, timedelta
+from plotly.subplots import make_subplots
+
+# Set Streamlit page configuration
+st.set_page_config(page_title="Pivot Point-RSI Volatility Trading Strategy", layout="wide")
+
+# App title
+st.title("Pivot Point-RSI Volatility Trading Strategy")
+
+# Description of the app
+st.markdown('''
+This tool executes a trading strategy that combines Pivot Points, RSI, and ATR to identify buy and sell signals. 
+It works by calculating support and resistance levels using Pivot Points, determining market momentum through RSI, and adjusting 
+stop-loss and target levels based on market volatility using ATR. 
+
+The strategy finds the best possible parameters through optimization. 
+You can also manually input your own settings. The app provides buy/sell signals, an equity curve, and performance metrics based on historical data to help evaluate the strategy.
+''')
+
+# Sidebar: How to use the app
+with st.sidebar.expander("How to Use", expanded=False):
+    st.write('''
+    1. Select the asset and date range for backtesting.
+    2. Click "Run Strategy" to generate results.
+    3. View the equity curve, buy/sell signals, and performance metrics.
+    4. Adjust the parameters post-run to fine-tune results.
+    ''')
+
+# Sidebar: Select Ticker and Date Range
+with st.sidebar.expander("Select Ticker and Date Range", expanded=True):
+    ticker = st.text_input("Asset Symbol", value="ASML.AS", help="Ticker Symbol or Cryptocurrency Pair (e.g., AAPL, BTC-USD)")
+    start_date = st.date_input("Start Date", value=datetime(2020, 1, 1), help="Select the start date for historical data.")
+    end_date = st.date_input("End Date", value=datetime.today() + timedelta(days=1), help="Select the end date for historical data.")
+
+# Download data
+@st.cache_data
+def download_data(ticker, start, end):
+    data = yf.download(ticker, start=start, end=end)
+    return data
+
+# Function to execute and cache strategy results
+@st.cache_data
+def execute_strategy(data, strategy_params):
+    data_with_signals = trading_strategy(data.copy(), **strategy_params)
+    profit, equity_curve, accuracy_rate = backtest_strategy(data_with_signals)
+    return data_with_signals, profit, equity_curve, accuracy_rate, strategy_params
+
+# Trading strategy function
+def trading_strategy(data, rsi_period, rsi_oversold, rsi_overbought, atr_period, stop_loss_multiplier, target_multiplier, tolerance):
+    data['high24'] = data['High'].rolling(window=24).max()
+    data['low24'] = data['Low'].rolling(window=24).min()
+    data['close24'] = data['Close'].rolling(window=24).mean()
+
+    data['pivot'] = (data['high24'] + data['low24'] + data['close24']) / 3
+    data['support'] = (2 * data['pivot'].rolling(window=12).min()) - data['high24']
+    data['resistance'] = (2 * data['pivot'].rolling(window=12).max()) - data['low24']
+
+    delta = data['Close'].diff()
+    up, down = delta.copy(), delta.copy()
+    up[up < 0] = 0
+    down[down > 0] = 0
+
+    roll_up1 = up.ewm(span=rsi_period).mean()
+    roll_down1 = down.abs().ewm(span=rsi_period).mean()
+    RS1 = roll_up1 / roll_down1
+    data['rsi'] = 100.0 - (100.0 / (1.0 + RS1))
+
+    data['HL'] = data['High'] - data['Low']
+    data['absHC'] = abs(data['High'] - data['Close'].shift())
+    data['absLC'] = abs(data['Low'] - data['Close'].shift())
+    data['TR'] = data[['HL', 'absHC', 'absLC']].max(axis=1)
+    data['atr'] = data['TR'].rolling(window=atr_period).mean()
+
+    data['signal'] = np.where(
+        (data['Close'] >= data['support'] * (1 - tolerance)) & (data['Close'] <= data['support'] * (1 + tolerance)) & (data['rsi'] < rsi_oversold), 'Buy',
+        np.where((data['Close'] >= data['resistance'] * (1 - tolerance)) & (data['Close'] <= data['resistance'] * (1 + tolerance)) & (data['rsi'] > rsi_overbought), 'Sell', 'Hold')
+    )
+
+    data['stop_loss'] = data['Close'] - stop_loss_multiplier * data['atr']
+    data['target'] = data['Close'] + target_multiplier * data['atr']
+
+    return data
+
+# Backtest function
+def backtest_strategy(data):
+    initial_capital = 100000  
+    position = 0  
+    capital = initial_capital
+    equity_curve = []
+    correct_signals = 0
+    total_signals = 0
+
+    for index, row in data.iterrows():
+        if row['signal'] == 'Buy' and position == 0:
+            position = 1
+            entry_price = row['Close']
+            stop_loss = row['stop_loss']
+            target = row['target']
+                
+        elif row['signal'] == 'Sell' and position == 0:
+            position = -1
+            entry_price = row['Close']
+            stop_loss = row['stop_loss']
+            target = row['target']
+                
+        if position == 1:
+            if row['Low'] <= stop_loss:  
+                capital += (stop_loss - entry_price) * 100  
+                position = 0
+            elif row['High'] >= target:  
+                capital += (target - entry_price) * 100
+                position = 0
+            elif row['signal'] == 'Sell':  
+                capital += (row['Close'] - entry_price) * 100
+                position = 0
+                
+        elif position == -1:
+            if row['High'] >= stop_loss:  
+                capital += (entry_price - stop_loss) * 100  
+                position = 0
+            elif row['Low'] <= target:  
+                capital += (entry_price - target) * 100
+                position = 0
+            elif row['signal'] == 'Buy':  
+                capital += (entry_price - row['Close']) * 100
+                position = 0
+                
+        equity_curve.append(capital)
+
+    final_profit = equity_curve[-1] - initial_capital
+    return final_profit, equity_curve, 0
+
+# Optimized parameters (fixed)
+optimized_params = {
+    'rsi_period': 13,
+    'rsi_oversold': 30,
+    'rsi_overbought': 70,
+    'atr_period': 14,
+    'stop_loss_multiplier': 2.25,
+    'target_multiplier': 4.5,
+    'tolerance': 0.01
+}
+
+# Run button to initiate the strategy
+run_button = st.sidebar.button("Run Strategy")
+
+# Running the strategy
+if run_button:
+    # Download data
+    data = download_data(ticker, start_date, end_date)
+
+    # Execute the strategy with optimized parameters
+    data_with_signals, profit, equity_curve, _, best_params = execute_strategy(data, optimized_params)
+
+    # Cache results in session state
+    st.session_state['data_with_signals'] = data_with_signals
+    st.session_state['equity_curve'] = equity_curve
+    st.session_state['best_params'] = best_params
+
+    # Display optimized parameters
+    st.json(best_params)
+
+# If session state contains data, allow for post-run parameter adjustments
+if 'data_with_signals' in st.session_state:
+    st.sidebar.markdown("### Adjust Parameters Post-Run")
+
+    adjusted_rsi_period = st.sidebar.slider("RSI Period", 5, 30, st.session_state['best_params']['rsi_period'], step=1, help="RSI period defines the sensitivity of the RSI. Lower values make the RSI more sensitive to price changes, generating more signals. Higher values smooth out price movements, reducing the number of signals.")
+    adjusted_stop_loss_multiplier = st.sidebar.slider("Stop Loss Multiplier", 1.0, 3.0, st.session_state['best_params']['stop_loss_multiplier'], step=0.1, help="Stop Loss Multiplier adjusts how far the stop-loss is set from the entry price. Lower values keep the stop-loss closer, reducing risk but increasing the chance of being stopped out. Higher values place the stop-loss further away, allowing more flexibility but with higher potential risk.")
+    adjusted_target_multiplier = st.sidebar.slider("Target Multiplier", 1.0, 5.0, st.session_state['best_params']['target_multiplier'], step=0.1, help="Target Multiplier adjusts how far the profit target is set from the entry price. Lower values take profits earlier but reduce potential gains. Higher values aim for larger profits but increase the chance of price reversal before hitting the target.")
+    adjusted_tolerance = st.sidebar.slider("Signal Tolerance", 0.0, 0.05, st.session_state['best_params']['tolerance'], step=0.01, help="Signal Tolerance adjusts how strictly the strategy follows support and resistance levels. Lower values make signals more precise but reduce their frequency. Higher values increase the frequency of signals by being more lenient, which can lead to false signals.")
+
+    # Recalculate the strategy with adjusted parameters
+    updated_params = {
+        'rsi_period': adjusted_rsi_period,
+        'rsi_oversold': 30,
+        'rsi_overbought': 70,
+        'atr_period': 14,
+        'stop_loss_multiplier': adjusted_stop_loss_multiplier,
+        'target_multiplier': adjusted_target_multiplier,
+        'tolerance': adjusted_tolerance
+    }
+
+    updated_data = trading_strategy(st.session_state['data_with_signals'].copy(), **updated_params)
+
+    # Plotting with adjustments for easier comparison of x-axis
+    fig = make_subplots(rows=3, cols=1, shared_xaxes=True,
+                        subplot_titles=("Price and Bollinger Bands", "RSI", "Equity Curve"),
+                        vertical_spacing=0.12)  # Increased vertical spacing
+
+    # Price and signal plot
+    fig.add_trace(go.Scatter(x=updated_data.index, y=updated_data['Close'], mode='lines', name='Close Price'))
+    fig.add_trace(go.Scatter(x=updated_data.index, y=updated_data['support'], mode='lines', name='Support Level', line=dict(dash='dash')))
+    fig.add_trace(go.Scatter(x=updated_data.index, y=updated_data['resistance'], mode='lines', name='Resistance Level', line=dict(dash='dash')))
+
+    # Buy/Sell Signals with increased marker size
+    buy_signals = updated_data[updated_data['signal'] == 'Buy']
+    sell_signals = updated_data[updated_data['signal'] == 'Sell']
+    fig.add_trace(go.Scatter(x=buy_signals.index, y=buy_signals['Close'], mode='markers', name='Buy Signal', 
+                             marker=dict(color='green', symbol='triangle-up', size=12)))  # Increased size
+    fig.add_trace(go.Scatter(x=sell_signals.index, y=sell_signals['Close'], mode='markers', name='Sell Signal', 
+                             marker=dict(color='red', symbol='triangle-down', size=12)))  # Increased size
+
+    # RSI Plot with black line, red upper threshold, and green lower threshold
+    fig.add_trace(go.Scatter(x=updated_data.index, y=updated_data['rsi'], mode='lines', name='RSI', line=dict(color='black')), row=2, col=1)
+    fig.add_shape(type="line", x0=updated_data.index[0], x1=updated_data.index[-1], y0=30, y1=30, 
+                  line=dict(dash='dash', color='green'), row=2, col=1)  # Lower threshold in green
+    fig.add_shape(type="line", x0=updated_data.index[0], x1=updated_data.index[-1], y0=70, y1=70, 
+                  line=dict(dash='dash', color='red'), row=2, col=1)  # Upper threshold in red
+
+    # Equity Curve Plot
+    fig.add_trace(go.Scatter(x=updated_data.index, y=st.session_state['equity_curve'], mode='lines', name='Equity Curve'), row=3, col=1)
+
+    # Move the legend outside the plot and increase gap
+    fig.update_layout(
+        title=f'{ticker} Strategy with Adjusted Parameters',
+        xaxis_title='Date',
+        yaxis_title='Price',
+        legend=dict(orientation="h", yanchor="bottom", y=1.05, xanchor="center", x=0.5, traceorder='normal', valign='top', borderwidth=0),
+        height=1000,  # Increase the height for better visibility
+        margin=dict(t=30, b=30),  # Adjust margins for better spacing
+        font=dict(size=12),  # Adjust font size for better readability
+        # Subplot title style adjustment for black color
+        annotations=[dict(font=dict(color="black", size=14)) for _ in range(3)]  # Adjusts all subplot titles to black
+    )
+
+    # Display the chart
+    st.plotly_chart(fig, use_container_width=True)
+
+hide_streamlit_style = """
+<style>
+#MainMenu {visibility: hidden;}
+footer {visibility: hidden;}
+</style>
+"""
+st.markdown(hide_streamlit_style, unsafe_allow_html=True)