Update app.py

app.py

@@ -1,6 +1,6 @@
 import numpy as np
-import pandas as pd
 import yfinance as yf
+import pandas as pd
 import plotly.graph_objects as go
 import streamlit as st
 from datetime import datetime, timedelta
@@ -9,6 +9,7 @@ from sklearn.cluster import KMeans
 import matplotlib.pyplot as plt
 
 # 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')
 
@@ -38,14 +39,12 @@ with st.sidebar.expander("How to use:", expanded=False):
     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.")
 
@@ -58,12 +57,11 @@ with st.sidebar.expander("Volume Profile and KMeans", expanded=True):
 
 # Define functions for different analyses
 def calculate_pivot_points(df, window):
-    # Ensure calculations are Series-based to avoid multi-column issues
     df['Pivot'] = df['Close'].rolling(window=window).mean()
-    df['R1'] = (2 * df['Pivot']) - df['Low'].rolling(window=window).min().reindex(df.index, method='ffill')
-    df['S1'] = (2 * df['Pivot']) - df['High'].rolling(window=window).max().reindex(df.index, method='ffill')
-    df['R2'] = df['Pivot'] + (df['High'].rolling(window=window).max().reindex(df.index, method='ffill') - df['Low'].rolling(window=window).min().reindex(df.index, method='ffill'))
-    df['S2'] = df['Pivot'] - (df['High'].rolling(window=window).max().reindex(df.index, method='ffill') - df['Low'].rolling(window=window).min().reindex(df.index, method='ffill'))
+    df['R1'] = 2 * df['Pivot'] - df['Low'].rolling(window=window).min()
+    df['S1'] = 2 * df['Pivot'] - df['High'].rolling(window=window).max()
+    df['R2'] = df['Pivot'] + (df['High'].rolling(window=window).max() - df['Low'].rolling(window=window).min())
+    df['S2'] = df['Pivot'] - (df['High'].rolling(window=window).max() - df['Low'].rolling(window=window).min())
     return df
 
 def find_levels(data, window):
@@ -76,9 +74,20 @@ def check_significant_break(data, support, resistance):
     breaks_below_support = (data['Close'] < support.shift(1)) & (data['Volume'] > data['Volume'].rolling(window=30).mean())
     return breaks_above_resistance, breaks_below_support
 
+# Updated function to use positional indexing via .iloc and .values
 def prepare_data_for_trendlines(data, lookback_period):
-    data['Swing_High'] = data['High'][argrelextrema(data['High'].values, np.greater_equal, order=lookback_period)[0]]
-    data['Swing_Low'] = data['Low'][argrelextrema(data['Low'].values, np.less_equal, order=lookback_period)[0]]
+    swing_highs = pd.Series(index=data.index, dtype=float)
+    swing_lows = pd.Series(index=data.index, dtype=float)
+    
+    high_positions = argrelextrema(data['High'].values, np.greater_equal, order=lookback_period)[0]
+    low_positions = argrelextrema(data['Low'].values, np.less_equal, order=lookback_period)[0]
+    
+    # Use .iloc with .values to ensure scalar assignments
+    swing_highs.iloc[high_positions] = data['High'].iloc[high_positions].values
+    swing_lows.iloc[low_positions] = data['Low'].iloc[low_positions].values
+    
+    data['Swing_High'] = swing_highs
+    data['Swing_Low'] = swing_lows
     return data
 
 def calculate_fibonacci_levels(data, lookback_period):
@@ -107,8 +116,7 @@ def calculate_kmeans_clusters(data, n_days, num_clusters):
 
 # Run the analysis
 if st.sidebar.button('Run Analysis'):
-    # Explicitly set auto_adjust=False to avoid yfinance default changes
-    data = yf.download(ticker, start=start_date, end=end_date, auto_adjust=False)
+    data = yf.download(ticker, start=start_date, end=end_date)
 
     if not data.empty:
         # Calculate Pivot Points
@@ -134,11 +142,11 @@ if st.sidebar.button('Run Analysis'):
         # 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 Points** are short-term trend indicators used to determine potential support and resistance levels based on the high, low, and close prices of previous periods.
         - **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 Resistance (R2)**: Obtained by adding the range (High - Low) to the pivot point.
         - **Second Support (S2)**: Found by subtracting the range from the pivot point.
         """)
         
@@ -162,10 +170,7 @@ if st.sidebar.button('Run Analysis'):
         # 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.
+        **Support and Resistance Levels** are determined using a rolling window approach to calculate the dynamic minimum (support) and maximum (resistance) prices over a given period.
         """)
         
         fig2 = go.Figure()
@@ -209,8 +214,7 @@ if st.sidebar.button('Run Analysis'):
         # 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.
+        **Fibonacci Retracement Levels** are horizontal lines indicating potential support and resistance based on Fibonacci ratios.
         """)
         
         fig4 = go.Figure()
@@ -231,12 +235,7 @@ if st.sidebar.button('Run Analysis'):
         # 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.
+        **Trendlines** are drawn using regression on swing highs and lows to indicate potential support and resistance.
         """)
         
         fig5 = go.Figure()
@@ -266,8 +265,7 @@ if st.sidebar.button('Run Analysis'):
         # 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.
+        **Volume Profile** is a charting tool that shows the amount of volume traded at different price levels over a specified period.
         """)
         
         fig6, (ax1, ax2) = plt.subplots(nrows=1, ncols=2, figsize=(20, 5), gridspec_kw={'width_ratios': [3, 1]})
@@ -293,13 +291,12 @@ if st.sidebar.button('Run Analysis'):
         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)
+        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.
+        **KMeans Clustering** partitions the price data into clusters to identify significant price levels.
         """)
         
         fig7 = go.Figure()
@@ -328,4 +325,4 @@ hide_streamlit_style = """
 footer {visibility: hidden;}
 </style>
 """
-st.markdown(hide_streamlit_style, unsafe_allow_html=True)
+st.markdown(hide_streamlit_style, unsafe_allow_html=True)