Create app.py

app.py

@@ -0,0 +1,330 @@
+import streamlit as st
+import yfinance as yf
+import pandas as pd
+import numpy as np
+from plotly.subplots import make_subplots
+import plotly.graph_objects as go
+
+# Set Streamlit page configuration (wide layout)
+st.set_page_config(
+    page_title="High Frequency Price Reversals",
+    layout="wide"
+)
+
+# App title
+st.title("Price Reversals")
+
+# Detailed purpose description
+st.write("This tool identifies and analyzes **high-frequency price reversals** for a given ticker or crypto pair. It calculates the number of reversals per day, their magnitude, and the time between each reversal. The analysis runs across three live intraday intervals: 60-minute, 5-minute, and 1-minute bars. Reversals help distinguish routine market noise from shifts driven by news or fundamental changes.")
+
+# Brief purpose description
+with st.expander("Methodology",  expanded=False):
+    st.markdown(r"""
+##### What is a Price Reversal?
+
+A **price reversal** is defined as a change in direction between consecutive candles.  
+For example, if a bullish candle (Close > Open) is followed by a bearish candle (Close < Open), that marks a reversal. The reverse scenario is treated the same way.
+
+##### Reversal Detection Logic
+
+1. Label each candle as bullish or bearish:
+$$
+\text{IsBull} = \text{Close} > \text{Open}
+$$
+
+2. A reversal occurs when the current candle has a different direction than the previous one:
+$$
+\text{Reversal} = \text{IsBull}_t \neq \text{IsBull}_{t-1}
+$$
+
+##### Daily Reversal Counts
+
+For each date:
+- Count the number of reversals.
+- Count the number of non-reversals.
+- Calculate the daily reversal percentage:
+$$
+\text{ReversalPct} = \frac{\text{ReversalCount}}{\text{ReversalCount} + \text{NonReversalCount}}
+$$
+
+##### Reversal Magnitude
+
+For each reversal, we measure how much the price changed during that candle. In other words, we calculate the absolute difference between the closing and opening prices:
+$$
+\text{ReversalMagnitude} = |\text{Close} - \text{Open}|
+$$
+
+Each day, we summarize these values by computing the smallest, median, and largest price changes. This helps us see the typical size of a reversal.
+
+##### Time Between Reversals
+
+We also measure the duration (in minutes) between one reversal and the next. For every day, we calculate the shortest, median, and longest time gaps between reversals. This measure how long the market goes without a reversal.
+""", unsafe_allow_html=True)
+
+# Sidebar user inputs
+st.sidebar.header("User Inputs")
+ticker_input = st.sidebar.text_input(
+    label="Ticker",
+    value="CVNA",
+    help="Enter a valid ticker symbol or cryptopair (e.g. 'CVNA', 'BTC-USD', etc.)"
+)
+run_button = st.sidebar.button(
+    label="Run Analysis",
+    help="Click to generate plots for the selected ticker."
+)
+
+# Execute only when "Run Analysis" is clicked
+if run_button:
+    if not ticker_input.strip():
+        st.error("Please enter a valid ticker.")
+    else:
+        with st.spinner("Running analysis..."):
+            try:
+                # Define ticker and interval settings
+                ticker = ticker_input.strip().upper()
+                period_mapping = {
+                    "60m": "720d",
+                    "5m": "60d",
+                    "1m": "8d"
+                }
+                intervals = ["60m", "5m", "1m"]
+
+                # Loop over each interval
+                for freq in intervals:
+                    st.markdown(f"## {freq} Interval Analysis - {ticker}")
+                    if freq == "60m":
+                        st.write("Analysis using 60-minute data. This interval provides a broader view of market trends.")
+                    elif freq == "5m":
+                        st.write("Analysis using 5-minute data. This interval provides a balance between overall trends and finer details.")
+                    elif freq == "1m":
+                        st.write("Analysis using 1-minute data. This interval reveals fine details in price reversals.")
+                
+                    period = period_mapping[freq]
+                    df = yf.download(ticker, period=period, interval=freq)
+
+                    # Flatten multi-level columns if needed
+                    if isinstance(df.columns, pd.MultiIndex):
+                        df.columns = df.columns.get_level_values(0)
+
+                    df.dropna(inplace=True)
+                    df.index.name = None
+
+                    # Compute reversal indicator
+                    df['IsBull'] = df['Close'] > df['Open']
+                    df['Reversal'] = df['IsBull'] != df['IsBull'].shift(1)
+                    df['Reversal'] = df['Reversal'].fillna(False)
+
+                    # Prepare daily counts
+                    df['Date'] = df.index.date
+                    daily_counts = df.groupby('Date')['Reversal'].agg(
+                        ReversalCount=lambda x: x.astype(int).sum(),
+                        NonReversalCount=lambda x: (~x).astype(int).sum()
+                    )
+                    daily_counts['ReversalPct'] = daily_counts['ReversalCount'] / (
+                        daily_counts['ReversalCount'] + daily_counts['NonReversalCount']
+                    )
+                    dates = pd.to_datetime(daily_counts.index)
+
+                    # Reversal magnitude analysis
+                    df['ReversalMagnitude'] = np.abs(df['Close'] - df['Open'])
+                    rev_mags = df[df['Reversal']].copy()
+                    rev_mags['Date'] = rev_mags.index.date
+                    mag_stats = rev_mags.groupby('Date')['ReversalMagnitude'].agg(['min', 'median', 'max'])
+
+                    # Time between reversals analysis
+                    reversal_times = df.index[df['Reversal']].to_series()
+                    reversal_time_diffs = reversal_times.diff().dropna().dt.total_seconds() / 60
+                    reversal_time_df = pd.DataFrame({
+                        'TimeBetween': reversal_time_diffs,
+                        'Date': reversal_times.iloc[1:].dt.date
+                    })
+                    time_stats = reversal_time_df.groupby('Date')['TimeBetween'].agg(['min', 'median', 'max'])
+
+                    # Create a figure with 4 rows (subplots)
+                    fig = make_subplots(
+                        rows=4, cols=1,
+                        shared_xaxes=True,
+                        subplot_titles=(
+                            f"{ticker} Close Price with Reversal Points",
+                            "Daily Reversal Counts & Reversal %",
+                            "Daily Reversal Magnitude Summary",
+                            "Daily Time Between Reversals (Minutes)"
+                        ),
+                        specs=[
+                            [{}],
+                            [{"secondary_y": True}],
+                            [{}],
+                            [{}]
+                        ]
+                    )
+
+                    # Subplot 1: Price with reversal markers
+                    fig.add_trace(
+                        go.Scatter(
+                            x=df.index,
+                            y=df['Close'],
+                            mode='lines',
+                            name='Close Price',
+                            line=dict(color='blue')
+                        ),
+                        row=1, col=1
+                    )
+                    reversal_points = df[df['Reversal']]
+                    fig.add_trace(
+                        go.Scatter(
+                            x=reversal_points.index,
+                            y=reversal_points['Close'],
+                            mode='markers',
+                            name='Reversal',
+                            marker=dict(color='red', size=6, opacity=0.5)
+                        ),
+                        row=1, col=1
+                    )
+                    non_reversal_points = df[~df['Reversal']]
+                    fig.add_trace(
+                        go.Scatter(
+                            x=non_reversal_points.index,
+                            y=non_reversal_points['Close'],
+                            mode='markers',
+                            name='Not Reversal',
+                            marker=dict(color='green', size=4, opacity=0.5)
+                        ),
+                        row=1, col=1
+                    )
+
+                    # Subplot 2: Daily reversal counts (stacked bar) and reversal percentage line
+                    fig.add_trace(
+                        go.Bar(
+                            x=dates,
+                            y=daily_counts['ReversalCount'],
+                            name='Reversal',
+                            marker_color='red'
+                        ),
+                        row=2, col=1, secondary_y=False
+                    )
+                    fig.add_trace(
+                        go.Bar(
+                            x=dates,
+                            y=daily_counts['NonReversalCount'],
+                            name='Not Reversal',
+                            marker_color='green',
+                            opacity=0.6
+                        ),
+                        row=2, col=1, secondary_y=False
+                    )
+                    fig.add_trace(
+                        go.Scatter(
+                            x=dates,
+                            y=daily_counts['ReversalPct'],
+                            mode='lines',
+                            name='Reversal %',
+                            line=dict(color='white')
+                        ),
+                        row=2, col=1, secondary_y=True
+                    )
+
+                    # Subplot 3: Reversal magnitude stats
+                    fig.add_trace(
+                        go.Scatter(
+                            x=mag_stats.index,
+                            y=mag_stats['median'],
+                            mode='lines',
+                            name='Median',
+                            line=dict(color='orange')
+                        ),
+                        row=3, col=1
+                    )
+                    fig.add_trace(
+                        go.Scatter(
+                            x=mag_stats.index,
+                            y=mag_stats['min'],
+                            mode='lines',
+                            name='Min',
+                            line=dict(dash='dash', color='gray')
+                        ),
+                        row=3, col=1
+                    )
+                    fig.add_trace(
+                        go.Scatter(
+                            x=mag_stats.index,
+                            y=mag_stats['max'],
+                            mode='lines',
+                            name='Max',
+                            line=dict(dash='dash', color='white')
+                        ),
+                        row=3, col=1
+                    )
+
+                    # Subplot 4: Time between reversals stats
+                    fig.add_trace(
+                        go.Scatter(
+                            x=time_stats.index,
+                            y=time_stats['median'],
+                            mode='lines',
+                            name='Median',
+                            line=dict(color='purple')
+                        ),
+                        row=4, col=1
+                    )
+                    fig.add_trace(
+                        go.Scatter(
+                            x=time_stats.index,
+                            y=time_stats['min'],
+                            mode='lines',
+                            name='Min',
+                            line=dict(dash='dash', color='gray')
+                        ),
+                        row=4, col=1
+                    )
+                    fig.add_trace(
+                        go.Scatter(
+                            x=time_stats.index,
+                            y=time_stats['max'],
+                            mode='lines',
+                            name='Max',
+                            line=dict(dash='dash', color='white')
+                        ),
+                        row=4, col=1
+                    )
+
+                    # Update layout with dark theme, white titles, and gridlines with alpha 0.2
+                    fig.update_layout(
+                        height=1800,
+                        width=1700,
+                        title_text=f"{ticker} Analysis ({freq} Data)",
+                        title_font_color='white',
+                        barmode='stack',
+                        template='plotly_dark',
+                        paper_bgcolor='#0e1117',
+                        plot_bgcolor='#0e1117',
+                        legend=dict(font=dict(color='white'))
+                    )
+
+                    # Update all axes to set white titles and gridlines with alpha 0.2
+                    fig.update_xaxes(
+                        title_font_color='white',
+                        gridcolor='rgba(255, 255, 255, 0.2)'
+                    )
+                    fig.update_yaxes(
+                        title_font_color='white',
+                        gridcolor='rgba(255, 255, 255, 0.2)'
+                    )
+                    
+                    fig.for_each_annotation(lambda a: a.update(font=dict(color='white')))
+
+                    # Display the figure in Streamlit
+                    st.plotly_chart(fig, use_container_width=True)
+
+            except Exception:
+                st.error("An error occurred. Please check your input and try again.")
+                
+# Hide default Streamlit style
+st.markdown(
+    """
+    <style>
+    #MainMenu {visibility: hidden;}
+    footer {visibility: hidden;}
+    </style>
+    """,
+    unsafe_allow_html=True
+)