Update app.py

app.py

@@ -8,7 +8,8 @@ from scipy.signal import argrelextrema
 from sklearn.cluster import KMeans
 import matplotlib.pyplot as plt
 
-# Streamlit app setup
+# Streamlit app
+
 st.set_page_config(page_title="Identifying Key Support and Resistance In Price Levels", layout="wide")
 st.title('Key Support and Resistance In Price Levels')
 
@@ -23,53 +24,37 @@ This tool aims to identify key support and resistance price levels in stocks usi
 7. **KMeans Clustering**: A machine learning algorithm used to partition the dataset into clusters, identifying patterns and grouping similar price movements together to highlight significant price levels.
 """)
 
-# Initialize session state for data persistence
-if 'data' not in st.session_state:
-    st.session_state.data = None
-if 'results' not in st.session_state:
-    st.session_state.results = {}
-
-# Sidebar for input parameters
+# Sidebar: How to use and Input Parameters
 st.sidebar.title('Input Parameters')
 
-with st.sidebar:
-    st.header("How to use:")
-    st.markdown("""
-    1. **Enter Ticker**: Specify a stock ticker or crypto pair.
-    2. **Set Dates**: Choose the date range for analysis.
-    3. **Adjust Parameters**: Modify methodology parameters as needed.
-    4. **Select Analysis**: Choose the analysis type to display results.
-    """)
-
-    # Expander for ticker and date settings
-    with st.expander("Ticker and Date Settings", expanded=True):
-        ticker = st.text_input('Stock Ticker or Crypto Pair', 'AAPL', help="Enter stock ticker (e.g., AAPL) or crypto pair (e.g., BTC-USD).")
-        start_date = st.date_input('Start Date', pd.to_datetime('2023-01-01'))
-        end_date = st.date_input('End Date', datetime.now() + timedelta(days=1))
-
-    # Expander for methodology-specific parameters
-    with st.expander("Pivot Points and Levels", expanded=True):
-        window_period = st.slider('Window Period for Pivot Points and Levels', min_value=10, max_value=60, value=30, help="Set the window period for calculating pivot points and support/resistance levels.")
-
-    with st.expander("Trendlines and Fibonacci Levels", expanded=True):
-        lookback_period = st.slider('Lookback Period for Trendlines and Fibonacci', min_value=10, max_value=60, value=30, help="Set the lookback period for calculating trendlines and Fibonacci retracement levels.")
-
-    with st.expander("Volume Profile and KMeans", expanded=True):
-        n_days = st.slider('Lookback Period for Volume Profile and KMeans (Days)', min_value=30, max_value=365, value=60, help="Set the number of days for calculating volume profile and KMeans clustering.")
-        num_clusters = st.slider('Number of Clusters for KMeans', min_value=2, max_value=10, value=3, help="Set the number of clusters for KMeans analysis.")
-
-    # Select the page (analysis type)
-    analysis_type = st.radio("Select Analysis", ["Pivot Points", "Support and Resistance", "Swing Highs and Lows", "Fibonacci Retracement Levels", "Trendlines", "Volume Profile", "KMeans Clustering"])
-
-# Function to fetch and cache data
-@st.cache_data(show_spinner=False)
-def get_data(ticker, start_date, end_date):
-    data = yf.download(ticker, start=start_date, end=end_date)
-    if data.empty:
-        st.error("No data found for the given ticker and date range.")
-    return data
+st.sidebar.subheader('How to use:')
+
+st.sidebar.markdown("""
+1. **Enter Ticker**: Specify a stock ticker or crypto pair.
+2. **Set Dates**: Choose the date range for analysis.
+3. **Adjust Parameters**: Modify methodology parameters as needed.
+4. **Run Analysis**: Click 'Run' to generate results.
+""")
+
+# Expander for ticker and date settings
+with st.sidebar.expander("Ticker and Date Settings", expanded=True):
+    st.write("Specify the ticker and date range for analysis.")
+    ticker = st.text_input('Stock Ticker or Crypto Pair', 'AAPL', help="Enter stock ticker (e.g., AAPL) or crypto pair (e.g., BTC-USD).")
+    start_date = st.date_input('Start Date', pd.to_datetime('2023-01-01'))
+    end_date = st.date_input('End Date', datetime.now() + timedelta(days=1))
+
+# Expander for methodology-specific parameters
+with st.sidebar.expander("Pivot Points and Levels", expanded=True):
+    window_period = st.slider('Window Period for Pivot Points and Levels', min_value=10, max_value=60, value=30, help="Set the window period for calculating pivot points and support/resistance levels.")
 
-# Functions for different analyses
+with st.sidebar.expander("Trendlines and Fibonacci Levels", expanded=True):
+    lookback_period = st.slider('Lookback Period for Trendlines and Fibonacci', min_value=10, max_value=60, value=30, help="Set the lookback period for calculating trendlines and Fibonacci retracement levels.")
+
+with st.sidebar.expander("Volume Profile and KMeans", expanded=True):
+    n_days = st.slider('Lookback Period for Volume Profile and KMeans (Days)', min_value=30, max_value=365, value=60, help="Set the number of days for calculating volume profile and KMeans clustering.")
+    num_clusters = st.slider('Number of Clusters for KMeans', min_value=2, max_value=10, value=3, help="Set the number of clusters for KMeans analysis.")
+
+# Define functions for different analyses
 def calculate_pivot_points(df, window):
     df['Pivot'] = df['Close'].rolling(window=window).mean()
     df['R1'] = 2 * df['Pivot'] - df['Low'].rolling(window=window).min()
@@ -117,241 +102,226 @@ def calculate_kmeans_clusters(data, n_days, num_clusters):
     cluster_centers = kmeans.cluster_centers_[:, 1] * (np.max(filtered_data['Close']) - np.min(filtered_data['Close'])) + np.min(filtered_data['Close'])
     return cluster_centers
 
-# Cache results based on analysis type
-def cache_results_in_session(data, analysis_type, window_period, lookback_period, n_days, num_clusters):
-    if analysis_type not in st.session_state.results:
-        st.session_state.results[analysis_type] = {}
+# Run the analysis
+if st.sidebar.button('Run Analysis'):
+    data = yf.download(ticker, start=start_date, end=end_date)
 
-    if analysis_type == "Pivot Points" and 'result' not in st.session_state.results[analysis_type]:
-        st.session_state.results[analysis_type]['result'] = calculate_pivot_points(data.copy(), window_period)
-    elif analysis_type == "Support and Resistance" and 'result' not in st.session_state.results[analysis_type]:
+    if not data.empty:
+        # Calculate Pivot Points
+        df_pivot = calculate_pivot_points(data.copy(), window_period)
+        df_pivot = df_pivot.dropna()
+
+        # Calculate Support and Resistance Levels
         support, resistance = find_levels(data.copy(), window_period)
         breaks_above_resistance, breaks_below_support = check_significant_break(data.copy(), support, resistance)
-        st.session_state.results[analysis_type]['result'] = (support, resistance, breaks_above_resistance, breaks_below_support)
-    elif analysis_type == "Swing Highs and Lows" and 'result' not in st.session_state.results[analysis_type]:
-        st.session_state.results[analysis_type]['result'] = prepare_data_for_trendlines(data.copy(), lookback_period)
-    elif analysis_type == "Fibonacci Retracement Levels" and 'result' not in st.session_state.results[analysis_type]:
-        st.session_state.results[analysis_type]['result'] = calculate_fibonacci_levels(data.copy(), lookback_period)
-    elif analysis_type == "Volume Profile" and 'result' not in st.session_state.results[analysis_type]:
-        st.session_state.results[analysis_type]['result'] = calculate_volume_profile(data.copy(), n_days)
-    elif analysis_type == "KMeans Clustering" and 'result' not in st.session_state.results[analysis_type]:
-        st.session_state.results[analysis_type]['result'] = calculate_kmeans_clusters(data.copy(), n_days, num_clusters)
-
-# Run analysis and cache results
-if st.sidebar.button('Run Analysis'):
-    if st.session_state.data is None:
-        st.session_state.data = get_data(ticker, start_date, end_date)
-
-    if not st.session_state.data.empty:
-        cache_results_in_session(st.session_state.data, analysis_type, window_period, lookback_period, n_days, num_clusters)
-
-        data = st.session_state.data
-        result = st.session_state.results[analysis_type]['result']
-
-        if analysis_type == "Pivot Points":
-            st.write("### Pivot Points")
-            st.markdown("""
-            **Pivot Points** are short-term trend indicators used to determine potential support and resistance levels. The central pivot point, as well as derived support and resistance levels, are calculated using the high, low, and close prices of a previous period (usually the previous day for day trading).
-            - **Pivot Point (P)**: The average of the high, low, and close of the previous trading period. 
-            - **First Resistance (R1)**: Calculated by doubling the pivot point and then subtracting the previous low.
-            - **First Support (S1)**: Derived by doubling the pivot point and then subtracting the previous high.
-            - **Second Resistance (R2)**: Obtained by adding the difference of high and low (the range) to the pivot point.
-            - **Second Support (S2)**: Found by subtracting the range from the pivot point.
-            """)
-            
-            fig1 = go.Figure()
-            fig1.add_trace(go.Scatter(x=result.index, y=result['Close'], mode='lines', name='Close Price'))
-            fig1.add_trace(go.Scatter(x=result.index, y=result['Pivot'], mode='lines', name='Pivot', line=dict(dash='dash', color='black')))
-            fig1.add_trace(go.Scatter(x=result.index, y=result['R1'], mode='lines', name='Resistance 1', line=dict(dash='dash', color='red')))
-            fig1.add_trace(go.Scatter(x=result.index, y=result['S1'], mode='lines', name='Support 1', line=dict(dash='dash', color='green')))
-            fig1.add_trace(go.Scatter(x=result.index, y=result['R2'], mode='lines', name='Resistance 2', line=dict(dash='dash', color='orange')))
-            fig1.add_trace(go.Scatter(x=result.index, y=result['S2'], mode='lines', name='Support 2', line=dict(dash='dash', color='blue')))
-            fig1.update_layout(
-                title=f'{ticker} Price with Pivot Points and Support/Resistance Levels',
-                xaxis_title='Date',
-                yaxis_title='Price',
-                legend_title='Legend',
-                width=1200, 
-                height=600
-            )
-            st.plotly_chart(fig1, use_container_width=True)
-
-        elif analysis_type == "Support and Resistance":
-            support, resistance, breaks_above_resistance, breaks_below_support = result
-
-            st.write("### Rolling Midpoint Range")
-            st.markdown("""
-            **Support and Resistance Levels** This method uses a rolling window to identify these levels. This provides a dynamic approach to pinpointing key price levels.
-            - **Support Level**: Calculated as the rolling minimum price over the specified window period. It acts as a floor where buying interest is strong enough to prevent further price declines.
-            - **Resistance Level**: Calculated as the rolling maximum price over the specified window period. It acts as a ceiling where selling interest prevents the price from rising further.
-            In this analysis, the support and resistance levels are determined using a rolling window approach. Significant breaks above resistance and below support are highlighted, especially when accompanied by higher-than-average trading volumes, which could indicate potential breakout or breakdown scenarios.
-            """)
-            
-            fig2 = go.Figure()
-            fig2.add_trace(go.Scatter(x=data.index, y=data['Close'], mode='lines', name='Stock Price'))
-            fig2.add_trace(go.Scatter(x=data.index, y=support, mode='lines', name='Support', line=dict(dash='dash', color='green')))
-            fig2.add_trace(go.Scatter(x=data.index, y=resistance, mode='lines', name='Resistance', line=dict(dash='dash', color='red')))
-            fig2.add_trace(go.Scatter(x=data[breaks_above_resistance].index, y=data['Close'][breaks_above_resistance], mode='markers', name='Break Above Resistance', marker=dict(color='blue')))
-            fig2.add_trace(go.Scatter(x=data[breaks_below_support].index, y=data['Close'][breaks_below_support], mode='markers', name='Break Below Support', marker=dict(color='purple')))
-            fig2.update_layout(
-                title=f'{ticker} Price with Support and Resistance Levels',
-                xaxis_title='Date',
-                yaxis_title='Price',
-                legend_title='Legend',
-                width=1200, 
-                height=600
-            )
-            st.plotly_chart(fig2, use_container_width=True)
-
-        elif analysis_type == "Swing Highs and Lows":
-            st.write("### Swing Highs and Lows")
-            st.markdown("""
-            **Swing Highs and Lows** are the highest and lowest points in the price action over a specified period.
-            - **Swing High**: A peak where the price is higher than the surrounding prices.
-            - **Swing Low**: A trough where the price is lower than the surrounding prices.
-            """)
-            
-            fig3 = go.Figure()
-            fig3.add_trace(go.Scatter(x=result.index, y=result['Close'], mode='lines', name='Close Price'))
-            fig3.add_trace(go.Scatter(x=result.index, y=result['Swing_High'], mode='markers', name='Swing Highs', marker=dict(color='red')))
-            fig3.add_trace(go.Scatter(x=result.index, y=result['Swing_Low'], mode='markers', name='Swing Lows', marker=dict(color='green')))
-            fig3.update_layout(
-                title=f'{ticker} with Swing Highs & Lows',
-                xaxis_title='Date',
-                yaxis_title='Price',
-                legend_title='Legend',
-                width=1200, 
-                height=600
-            )
-            st.plotly_chart(fig3, use_container_width=True)
-
-        elif analysis_type == "Fibonacci Retracement Levels":
-            fib_levels, levels = result
-
-            st.write("### Fibonacci Retracement Levels")
-            st.markdown("""
-            **Fibonacci Retracement Levels** are horizontal lines that indicate where support and resistance are likely to occur. They are based on Fibonacci numbers and are used to predict the future movement of asset prices. 
-            - **Levels**: 23.6%, 38.2%, 50%, 61.8%, and 78.6% represent key points where the price could potentially reverse.
-            """)
-            
-            fig4 = go.Figure()
-            fig4.add_trace(go.Scatter(x=data.index, y=data['Close'], mode='lines', name='Stock Price'))
-            color_list = ['red', 'orange', 'yellow', 'green', 'blue', 'indigo', 'violet']
-            for i, (level, color) in enumerate(zip(levels, color_list)):
-                fig4.add_trace(go.Scatter(x=data.index, y=fib_levels[:, i], mode='lines', name=f'Fib {level:.3f}', line=dict(color=color)))
-            fig4.update_layout(
-                title=f'{ticker} with Fibonacci Retracement Levels',
-                xaxis_title='Date',
-                yaxis_title='Price',
-                legend_title='Legend',
-                width=1200, 
-                height=600
-            )
-            st.plotly_chart(fig4, use_container_width=True)
-
-        elif analysis_type == "Trendlines":
-            st.write("### Trendlines with Regression Analysis")
-            st.markdown("""
-            **Trendlines** are straight lines drawn on a price chart to connect two or more price points. They help identify the direction of the market trend and potential areas of support and resistance. In this analysis, trendlines are determined using regression analysis to fit the lines through swing highs and lows.
-            - **Upper Trendline**: Connects higher highs using linear regression to fit a line through these points. This line acts as a resistance level.
-            - **Lower Trendline**: Connects lower lows using linear regression to fit a line through these points. This line acts as a support level.
-            1. **Swing Highs and Lows Identification**: First, local maxima (swing highs) and minima (swing lows) are identified using a specified lookback period.
-            2. **Linear Regression**: A linear regression is then applied to the swing highs to form the upper trendline and to the swing lows to form the lower trendline. 
-            3. **Visualization**: The trendlines are plotted along with the stock's closing prices to represent of potential resistance and support levels.
-            """)
-            
-            fig5 = go.Figure()
-            fig5.add_trace(go.Scatter(x=result.index, y=result['Close'], mode='lines', name='Close Price'))
-            
-            swing_highs = result['Swing_High'].dropna()
-            swing_lows = result['Swing_Low'].dropna()
-
-            if len(swing_highs) > 1 and len(swing_lows) > 1:
-                upper_m, upper_b = np.polyfit(swing_highs.index.map(pd.Timestamp.toordinal), swing_highs.values, 1)
-                lower_m, lower_b = np.polyfit(swing_lows.index.map(pd.Timestamp.toordinal), swing_lows.values, 1)
-                result['Upper_Trendline'] = upper_m * result.index.map(pd.Timestamp.toordinal) + upper_b
-                result['Lower_Trendline'] = lower_m * result.index.map(pd.Timestamp.toordinal) + lower_b
-                fig5.add_trace(go.Scatter(x=result.index, y=result['Upper_Trendline'], mode='lines', name='Upper Trendline', line=dict(color='orange')))
-                fig5.add_trace(go.Scatter(x=result.index, y=result['Lower_Trendline'], mode='lines', name='Lower Trendline', line=dict(color='blue')))
-            
-            fig5.update_layout(
-                title=f'{ticker} with Trendlines',
-                xaxis_title='Date',
-                yaxis_title='Price',
-                legend_title='Legend',
-                width=1200, 
-                height=600
-            )
-            st.plotly_chart(fig5, use_container_width=True)
-
-        elif analysis_type == "Volume Profile":
-            price_bins, volume_profile = result
-
-            st.write("### Volume Profile")
-            st.markdown("""
-            **Volume Profile** is a charting tool that shows the amount of volume traded at different price levels over a specified period. It helps identify areas of high trading activity, which can act as support or resistance. 
-            - **High Volume Areas**: Indicate significant trading activity and can act as strong support or resistance levels.
-            """)
-            
-            fig6, (ax1, ax2) = plt.subplots(nrows=1, ncols=2, figsize=(20, 5), gridspec_kw={'width_ratios': [3, 1]})
-            ax1.plot(data['Close'], label="Close Price")
-            current_price = data['Close'].iloc[-1]
-            support_idx = np.argmax(volume_profile[:np.digitize(current_price, price_bins)])
-            resistance_idx = np.argmax(volume_profile[np.digitize(current_price, price_bins):]) + np.digitize(current_price, price_bins)
-            support_price = price_bins[support_idx]
-            resistance_price = price_bins[resistance_idx]
-            ax1.axhline(y=support_price, color='g', linestyle='--', label='Support')
-            ax1.axhline(y=resistance_price, color='r', linestyle='--', label='Resistance')
-            ax1.annotate(f'Support: {support_price:.2f}', 
-                         xy=(data.index[-1], support_price), 
-                         xytext=(data.index[-1], support_price - 5), 
-                         arrowprops=dict(facecolor='green', arrowstyle='->'),
-                         color='green', fontsize=12)
-            ax1.annotate(f'Resistance: {resistance_price:.2f}', 
-                         xy=(data.index[-1], resistance_price), 
-                         xytext=(data.index[-1], resistance_price + 5), 
-                         arrowprops=dict(facecolor='red', arrowstyle='->'),
-                         color='red', fontsize=12)
-            ax1.legend()
-            ax1.set_title(f'{ticker} Price Data')
-            ax2.barh(price_bins[:-1], volume_profile, height=(price_bins[1] - price_bins[0]), color='blue', edgecolor='none')
-            ax2.set_title('Volume Profile')
-            st.pyplot(fig6,  use_container_width=True)
-
-        elif analysis_type == "KMeans Clustering":
-            cluster_centers = result
-
-            st.write("### KMeans Clusters")
-            st.markdown("""
-            **KMeans Clustering** is a machine learning algorithm used to partition a dataset into clusters. In the context of stock prices, it helps identify patterns and group similar price movements together.
-            - **Clusters**: Represent different regimes or phases in the stock price movements.
-            """)
-            
-            fig7 = go.Figure()
-            fig7.add_trace(go.Scatter(x=data.index, y=data['Close'], mode='lines', name='Close Price'))
-            for center in cluster_centers:
-                fig7.add_trace(go.Scatter(x=[data.index[-1]], y=[center], mode='markers+text', name=f'Cluster Center: {center:.2f}', text=[f'{center:.2f}'], textposition='top center'))
-                fig7.add_shape(type="line",
-                               x0=data.index[0], x1=data.index[-1], y0=center, y1=center,
-                               line=dict(color='Red', dash="dash"))
-            fig7.update_layout(
-                title=f'{ticker} with KMeans Clustering (Last {n_days} Days)',
-                xaxis_title='Date',
-                yaxis_title='Price',
-                legend_title='Legend',
-                width=1200, 
-                height=600
-            )
-            st.plotly_chart(fig7, use_container_width=True)
+
+        # Calculate Swing Highs and Lows
+        data_with_trendlines = prepare_data_for_trendlines(data.copy(), lookback_period)
+
+        # Calculate Fibonacci Retracement Levels
+        fib_levels, levels = calculate_fibonacci_levels(data.copy(), lookback_period)
+
+        # Calculate Volume Profile
+        price_bins, volume_profile = calculate_volume_profile(data.copy(), n_days)
+
+        # Calculate KMeans Clusters
+        cluster_centers = calculate_kmeans_clusters(data.copy(), n_days, num_clusters)
+
+        # Plot Pivot Points
+        st.write("### Pivot Points")
+        st.markdown("""
+        **Pivot Points** are short-term trend indicators used to determine potential support and resistance levels. The central pivot point, as well as derived support and resistance levels, are calculated using the high, low, and close prices of a previous period (usually the previous day for day trading).
+        - **Pivot Point (P)**: The average of the high, low, and close of the previous trading period. 
+        - **First Resistance (R1)**: Calculated by doubling the pivot point and then subtracting the previous low.
+        - **First Support (S1)**: Derived by doubling the pivot point and then subtracting the previous high.
+        - **Second Resistance (R2)**: Obtained by adding the difference of high and low (the range) to the pivot point.
+        - **Second Support (S2)**: Found by subtracting the range from the pivot point.
+        """)
+        
+        fig1 = go.Figure()
+        fig1.add_trace(go.Scatter(x=df_pivot.index, y=df_pivot['Close'], mode='lines', name='Close Price'))
+        fig1.add_trace(go.Scatter(x=df_pivot.index, y=df_pivot['Pivot'], mode='lines', name='Pivot', line=dict(dash='dash', color='black')))
+        fig1.add_trace(go.Scatter(x=df_pivot.index, y=df_pivot['R1'], mode='lines', name='Resistance 1', line=dict(dash='dash', color='red')))
+        fig1.add_trace(go.Scatter(x=df_pivot.index, y=df_pivot['S1'], mode='lines', name='Support 1', line=dict(dash='dash', color='green')))
+        fig1.add_trace(go.Scatter(x=df_pivot.index, y=df_pivot['R2'], mode='lines', name='Resistance 2', line=dict(dash='dash', color='orange')))
+        fig1.add_trace(go.Scatter(x=df_pivot.index, y=df_pivot['S2'], mode='lines', name='Support 2', line=dict(dash='dash', color='blue')))
+        fig1.update_layout(
+            title=f'{ticker} Price with Pivot Points and Support/Resistance Levels',
+            xaxis_title='Date',
+            yaxis_title='Price',
+            legend_title='Legend',
+            width=1200,  # Set desired width
+            height=600   # Set desired height
+        )
+        st.plotly_chart(fig1, use_container_width=True)
+
+        # Plot Support and Resistance Levels using Rolling Midpoint Range
+        st.write("### Rolling Midpoint Range")
+        st.markdown("""
+        **Support and Resistance Levels** This method uses a rolling window to identify these levels. This provides a dynamic approach to pinpointing key price levels.
+        - **Support Level**: Calculated as the rolling minimum price over the specified window period. It acts as a floor where buying interest is strong enough to prevent further price declines.
+        - **Resistance Level**: Calculated as the rolling maximum price over the specified window period. It acts as a ceiling where selling interest prevents the price from rising further.
+        In this analysis, the support and resistance levels are determined using a rolling window approach. Significant breaks above resistance and below support are highlighted, especially when accompanied by higher-than-average trading volumes, which could indicate potential breakout or breakdown scenarios.
+        """)
+        
+        fig2 = go.Figure()
+        fig2.add_trace(go.Scatter(x=data.index, y=data['Close'], mode='lines', name='Stock Price'))
+        fig2.add_trace(go.Scatter(x=data.index, y=support, mode='lines', name='Support', line=dict(dash='dash', color='green')))
+        fig2.add_trace(go.Scatter(x=data.index, y=resistance, mode='lines', name='Resistance', line=dict(dash='dash', color='red')))
+        fig2.add_trace(go.Scatter(x=data[breaks_above_resistance].index, y=data['Close'][breaks_above_resistance], mode='markers', name='Break Above Resistance', marker=dict(color='blue')))
+        fig2.add_trace(go.Scatter(x=data[breaks_below_support].index, y=data['Close'][breaks_below_support], mode='markers', name='Break Below Support', marker=dict(color='purple')))
+        fig2.update_layout(
+            title=f'{ticker} Price with Support and Resistance Levels',
+            xaxis_title='Date',
+            yaxis_title='Price',
+            legend_title='Legend',
+            width=1200,  # Set desired width
+            height=600   # Set desired height
+        )
+        st.plotly_chart(fig2, use_container_width=True)
+
+        # Plot Swing Highs and Lows
+        st.write("### Swing Highs and Lows")
+        st.markdown("""
+        **Swing Highs and Lows** are the highest and lowest points in the price action over a specified period.
+        - **Swing High**: A peak where the price is higher than the surrounding prices.
+        - **Swing Low**: A trough where the price is lower than the surrounding prices.
+        """)
+        
+        fig3 = go.Figure()
+        fig3.add_trace(go.Scatter(x=data_with_trendlines.index, y=data_with_trendlines['Close'], mode='lines', name='Close Price'))
+        fig3.add_trace(go.Scatter(x=data_with_trendlines.index, y=data_with_trendlines['Swing_High'], mode='markers', name='Swing Highs', marker=dict(color='red')))
+        fig3.add_trace(go.Scatter(x=data_with_trendlines.index, y=data_with_trendlines['Swing_Low'], mode='markers', name='Swing Lows', marker=dict(color='green')))
+        fig3.update_layout(
+            title=f'{ticker} with Swing Highs & Lows',
+            xaxis_title='Date',
+            yaxis_title='Price',
+            legend_title='Legend',
+            width=1200,  # Set desired width
+            height=600   # Set desired height
+        )
+        st.plotly_chart(fig3, use_container_width=True)
+
+        # Plot Fibonacci Retracement Levels
+        st.write("### Fibonacci Retracement Levels")
+        st.markdown("""
+        **Fibonacci Retracement Levels** are horizontal lines that indicate where support and resistance are likely to occur. They are based on Fibonacci numbers and are used to predict the future movement of asset prices. 
+        - **Levels**: 23.6%, 38.2%, 50%, 61.8%, and 78.6% represent key points where the price could potentially reverse.
+        """)
+        
+        fig4 = go.Figure()
+        fig4.add_trace(go.Scatter(x=data.index, y=data['Close'], mode='lines', name='Stock Price'))
+        color_list = ['red', 'orange', 'yellow', 'green', 'blue', 'indigo', 'violet']
+        for i, (level, color) in enumerate(zip(levels, color_list)):
+            fig4.add_trace(go.Scatter(x=data.index, y=fib_levels[:, i], mode='lines', name=f'Fib {level:.3f}', line=dict(color=color)))
+        fig4.update_layout(
+            title=f'{ticker} with Fibonacci Retracement Levels',
+            xaxis_title='Date',
+            yaxis_title='Price',
+            legend_title='Legend',
+            width=1200,  # Set desired width
+            height=600   # Set desired height
+        )
+        st.plotly_chart(fig4, use_container_width=True)
+
+        # Plot Trendlines
+        st.write("### Trendlines with Regression Analysis")
+        st.markdown("""
+        **Trendlines** are straight lines drawn on a price chart to connect two or more price points. They help identify the direction of the market trend and potential areas of support and resistance. In this analysis, trendlines are determined using regression analysis to fit the lines through swing highs and lows.
+        - **Upper Trendline**: Connects higher highs using linear regression to fit a line through these points. This line acts as a resistance level.
+        - **Lower Trendline**: Connects lower lows using linear regression to fit a line through these points. This line acts as a support level.
+        1. **Swing Highs and Lows Identification**: First, local maxima (swing highs) and minima (swing lows) are identified using a specified lookback period.
+        2. **Linear Regression**: A linear regression is then applied to the swing highs to form the upper trendline and to the swing lows to form the lower trendline. 
+        3. **Visualization**: The trendlines are plotted along with the stock's closing prices to represent of potential resistance and support levels.
+        """)
+        
+        fig5 = go.Figure()
+        fig5.add_trace(go.Scatter(x=data_with_trendlines.index, y=data_with_trendlines['Close'], mode='lines', name='Close Price'))
+        
+        swing_highs = data_with_trendlines['Swing_High'].dropna()
+        swing_lows = data_with_trendlines['Swing_Low'].dropna()
+
+        if len(swing_highs) > 1 and len(swing_lows) > 1:
+            upper_m, upper_b = np.polyfit(swing_highs.index.map(pd.Timestamp.toordinal), swing_highs.values, 1)
+            lower_m, lower_b = np.polyfit(swing_lows.index.map(pd.Timestamp.toordinal), swing_lows.values, 1)
+            data_with_trendlines['Upper_Trendline'] = upper_m * data_with_trendlines.index.map(pd.Timestamp.toordinal) + upper_b
+            data_with_trendlines['Lower_Trendline'] = lower_m * data_with_trendlines.index.map(pd.Timestamp.toordinal) + lower_b
+            fig5.add_trace(go.Scatter(x=data_with_trendlines.index, y=data_with_trendlines['Upper_Trendline'], mode='lines', name='Upper Trendline', line=dict(color='orange')))
+            fig5.add_trace(go.Scatter(x=data_with_trendlines.index, y=data_with_trendlines['Lower_Trendline'], mode='lines', name='Lower Trendline', line=dict(color='blue')))
+        
+        fig5.update_layout(
+            title=f'{ticker} with Trendlines',
+            xaxis_title='Date',
+            yaxis_title='Price',
+            legend_title='Legend',
+            width=1200,  # Set desired width
+            height=600   # Set desired height
+        )
+        st.plotly_chart(fig5, use_container_width=True)
+
+        # Plot Volume Profile
+        st.write("### Volume Profile")
+        st.markdown("""
+        **Volume Profile** is a charting tool that shows the amount of volume traded at different price levels over a specified period. It helps identify areas of high trading activity, which can act as support or resistance. 
+        - **High Volume Areas**: Indicate significant trading activity and can act as strong support or resistance levels.
+        """)
+        
+        fig6, (ax1, ax2) = plt.subplots(nrows=1, ncols=2, figsize=(20, 5), gridspec_kw={'width_ratios': [3, 1]})
+        ax1.plot(data['Close'], label="Close Price")
+        current_price = data['Close'].iloc[-1]
+        support_idx = np.argmax(volume_profile[:np.digitize(current_price, price_bins)])
+        resistance_idx = np.argmax(volume_profile[np.digitize(current_price, price_bins):]) + np.digitize(current_price, price_bins)
+        support_price = price_bins[support_idx]
+        resistance_price = price_bins[resistance_idx]
+        ax1.axhline(y=support_price, color='g', linestyle='--', label='Support')
+        ax1.axhline(y=resistance_price, color='r', linestyle='--', label='Resistance')
+        ax1.annotate(f'Support: {support_price:.2f}', 
+                     xy=(data.index[-1], support_price), 
+                     xytext=(data.index[-1], support_price - 5), 
+                     arrowprops=dict(facecolor='green', arrowstyle='->'),
+                     color='green', fontsize=12)
+        ax1.annotate(f'Resistance: {resistance_price:.2f}', 
+                     xy=(data.index[-1], resistance_price), 
+                     xytext=(data.index[-1], resistance_price + 5), 
+                     arrowprops=dict(facecolor='red', arrowstyle='->'),
+                     color='red', fontsize=12)
+        ax1.legend()
+        ax1.set_title(f'{ticker} Price Data')
+        ax2.barh(price_bins[:-1], volume_profile, height=(price_bins[1] - price_bins[0]), color='blue', edgecolor='none')
+        ax2.set_title('Volume Profile')
+        st.pyplot(fig6,  use_container_width=True)
+
+        # Plot KMeans Clusters
+        st.write("### KMeans Clusters")
+        st.markdown("""
+        **KMeans Clustering** is a machine learning algorithm used to partition a dataset into clusters. In the context of stock prices, it helps identify patterns and group similar price movements together.
+        - **Clusters**: Represent different regimes or phases in the stock price movements.
+        """)
+        
+        fig7 = go.Figure()
+        fig7.add_trace(go.Scatter(x=data.index, y=data['Close'], mode='lines', name='Close Price'))
+        for center in cluster_centers:
+            fig7.add_trace(go.Scatter(x=[data.index[-1]], y=[center], mode='markers+text', name=f'Cluster Center: {center:.2f}', text=[f'{center:.2f}'], textposition='top center'))
+            fig7.add_shape(type="line",
+                           x0=data.index[0], x1=data.index[-1], y0=center, y1=center,
+                           line=dict(color='Red', dash="dash"))
+        fig7.update_layout(
+            title=f'{ticker} with KMeans Clustering (Last {n_days} Days)',
+            xaxis_title='Date',
+            yaxis_title='Price',
+            legend_title='Legend',
+            width=1200,  # Set desired width
+            height=600   # Set desired height
+        )
+        st.plotly_chart(fig7, use_container_width=True)
 
     else:
         st.write("No data found for the given ticker and date range.")
 
-# Hide Streamlit style
 hide_streamlit_style = """
 <style>
 #MainMenu {visibility: hidden;}
 footer {visibility: hidden;}
 </style>
 """
-st.markdown(hide_streamlit_style, unsafe_allow_html=True)
+st.markdown(hide_streamlit_style, unsafe_allow_html=True)