import pandas as pd
import pytz

# Read SPY 1m data downloaded from Databento
df = pd.read_csv('SPY-1m-databento.csv')

### ------------ DATA CLEANING ---------------
# Clean timestamp strings first
df['ts_event'] = df['ts_event'].str.rstrip('.')  # Remove trailing dots

# Convert to datetime with ISO8601 format handling
df['timestamp'] = pd.to_datetime(
    df['ts_event'], 
    utc=True, 
    format='ISO8601',  # Handles various timestamp formats
    errors='coerce'  # Convert unparseable times to NaT
)

# Check for failed conversions
if df['timestamp'].isna().any():
    num_bad = df['timestamp'].isna().sum()
    print(f"Warning: {num_bad} timestamps could not be parsed")
    df = df.dropna(subset=['timestamp'])  # Remove invalid rows

# Cleanup original column
df.drop(columns='ts_event', inplace=True)

# Convert to NY timezone and set as index
df['timestamp'] = df['timestamp'].dt.tz_convert('America/New_York')
df.set_index('timestamp', inplace=True)

# Drop unnecessary columns
df.drop(columns=['rtype', 'publisher_id', 'instrument_id'], inplace=True)

# Optional: Sort index for time-series safety
df = df.sort_index()

# Optional: Filter by date (uncomment and modify as needed)
# df = df.loc['2023-04-01':'2023-06-30']

df.head()

import matplotlib.pyplot as plt

# Calculate point range for each 1-minute bar
df['range'] = df['high'] - df['low']

# Get hour for each row from timestamp and add as column
df['hour'] = df.index.hour

# Group by hour and calculate average volatility (point range)
minute_volatility = df.groupby('hour')['range'].mean()

# minute_volatility.head(20)

# Plot the average range per hour
minute_volatility.plot(kind='bar', color='steelblue')
plt.title('Average 1 Minute Point Range (Volatility) by Hour - SPY')
plt.xlabel('Hour of Day (New York Time)')
plt.ylabel('Average Point Range')
plt.xticks(rotation=0)
plt.grid(axis='y', linestyle='--', alpha=0.7)
plt.tight_layout()
plt.show()

# Resample the data to hourly OHLC (Open-High-Low-Close)
hourly = df.resample('h').agg({
    'open': 'first',
    'high': 'max',
    'low': 'min',
    'close': 'last'
})

# Extract hour from the index (New York time)
hourly['hour'] = hourly.index.hour

# Calculate candle body size
hourly['body'] = abs(hourly['open'] - hourly['close'])

# Calculate average body size by hour
hourly_body = hourly.groupby('hour')['body'].mean()

# Plot
import matplotlib.pyplot as plt
hourly_body.plot(kind='bar', color='steelblue')
plt.title('Average 1 Hour Body Point Range (Size) by Hour - SPY')
plt.xlabel('Hour of Day (New York Time)')
plt.ylabel('Average Point Range')
plt.xticks(rotation=0)
plt.grid(axis='y', linestyle='--', alpha=0.7)
plt.tight_layout()
plt.show()

# Trend Strength = Size of Body / Size of Candle (Top and bottom of wicks)

# Calculate candle range (high - low) FIRST!
hourly['range'] = hourly['high'] - hourly['low']

# Only include NY session Data (uncomment if needed)
# hourly = hourly.between_time('09:00', '16:00')

temp = hourly.copy()

# Avoid divide-by-zero
temp = temp[temp['range'] != 0]
temp = temp[temp['body'] != 0]

temp['trend_strength'] = temp['body'] / temp['range']

hourly_trend_strength = temp.groupby('hour')['trend_strength'].mean()

# Plot trend strength
hourly_trend_strength.plot(kind='bar', color='steelblue')
plt.title('Average Hourly Trend Strength Ratio (1-Hour Candles)')
plt.xlabel('Hour of Day (New York Time)')
plt.ylabel('|Close - Open| / (High - Low)')
plt.xticks(rotation=0)
plt.grid(axis='y', linestyle='--', alpha=0.7)
plt.tight_layout()
plt.show()

# Calculate Chop
temp['chop'] = temp['range'] / temp['body']

hourly_chop = temp.groupby('hour')['chop'].mean()

# Plot chop
hourly_chop.plot(kind='bar', color='steelblue')
plt.title('Average Hourly Wick to Body Ratio (Chop) (1-Hour Candles)')
plt.xlabel('Hour of Day (New York Time)')
plt.ylabel('|High - Low| / (Close - Open)')
plt.xticks(rotation=0)
plt.grid(axis='y', linestyle='--', alpha=0.7)
plt.tight_layout()
plt.show()

# Add a color column depending on the candle close
hourly['color'] = hourly.apply(lambda row: 'green' if row['close'] > row['open'] else 'red', axis=1)

# Count number of green and red candles for each hour
hourly_color_counts = hourly.groupby(['hour', 'color']).size().unstack(fill_value=0)

hourly_color_counts['green_rate'] = hourly_color_counts['green'] / (hourly_color_counts['green'] + hourly_color_counts['red'])
hourly_color_counts['red_rate'] = hourly_color_counts['red'] / (hourly_color_counts['green'] + hourly_color_counts['red'])

hourly_color_counts.head(20)

# Green candle close chart
hourly_color_counts['green_rate'].plot(kind='bar', color='limegreen')
plt.title('Green Candle Rate by Hour')
plt.xlabel('Hour of Day (New York Time)')
plt.ylabel('Green Rate')
plt.ylim(0.4, 0.6)  # Zoom in to highlight variation
plt.xticks(rotation=0)
plt.grid(axis='y', linestyle='--', alpha=0.7)
plt.tight_layout()
plt.show()

# Red candle close chart
hourly_color_counts['red_rate'].plot(kind='bar', color='lightcoral')
plt.title('Red Candle Rate by Hour')
plt.xlabel('Hour of Day (New York Time)')
plt.ylabel('Red Rate')
plt.ylim(0.4, 0.6)  # Zoom in to highlight variation
plt.xticks(rotation=0)
plt.grid(axis='y', linestyle='--', alpha=0.7)
plt.tight_layout()
plt.show()

from IPython.display import display

# Format table as %
hourly_table = hourly_color_counts.copy()
hourly_table['green_rate'] = (hourly_table['green_rate'] * 100).round(2)
hourly_table['red_rate'] = (hourly_table['red_rate'] * 100).round(2)

# Rename table columns
hourly_table.columns = ['Green Count', 'Red Count', 'Green Rate (%)', 'Red Rate (%)']

display(hourly_table.sort_index())

# Filter green and red candles
green_1hr_candles = hourly[hourly['color'] == 'green'].copy()
red_1hr_candles = hourly[hourly['color'] == 'red'].copy()

# Group and get average body size
green_1hr_body_avg = green_1hr_candles.groupby('hour')['body'].mean()
red_1hr_body_avg = red_1hr_candles.groupby('hour')['body'].mean()

avg_1hr_body_by_color = pd.DataFrame({
    'Green Avg Body': green_1hr_body_avg,
    'Red Avg Body': red_1hr_body_avg
})

avg_1hr_body_by_color.plot(kind='bar', figsize=(10, 5), color=['limegreen', 'lightcoral'])
plt.title('Average Candle Body Size by Hour')
plt.xlabel('Hour of Day (New York Time)')
plt.ylabel('Average Body Size (Points)')
plt.xticks(rotation=0)
plt.grid(axis='y', linestyle='--', alpha=0.7)
plt.tight_layout()
plt.show()
# avg_1hr_body_by_color.head(20)
display(avg_1hr_body_by_color)

# -------------- CALCULATE WICK CANDLES POINT RANGES---------------

# Add full range column if not done already
hourly['range'] = hourly['high'] - hourly['low']

# Filter by green and red candles
green_candles = hourly[hourly['color'] == 'green']
red_candles = hourly[hourly['color'] == 'red']

# Group by hour and calculate average full range
green_range = green_candles.groupby('hour')['range'].mean()
red_range = red_candles.groupby('hour')['range'].mean()

# Combine into one DataFrame
avg_range_by_color = pd.DataFrame({
    'Green Candle Range': green_range,
    'Red Candle Range': red_range
})

avg_range_by_color.plot(kind='bar', color=['limegreen', 'lightcoral'])
plt.title('Average Full Candle Range by Hour (Green vs Red Candles)')
plt.xlabel('Hour of Day (New York Time)')
plt.ylabel('Range (High - Low)')
plt.xticks(rotation=0)
plt.grid(axis='y', linestyle='--', alpha=0.7)
plt.tight_layout()
plt.show()


# -------------- CALCULATE # OF RED AND GREEN HOURS ---------------

avg_1hr_body_by_color['Dominant Side'] = avg_1hr_body_by_color.apply(
    lambda row: 'Green' if row['Green Avg Body'] > row['Red Avg Body'] else 'Red', axis=1
)

avg_1hr_body_by_color['Green > Red'] = avg_1hr_body_by_color['Green Avg Body'] > avg_1hr_body_by_color['Red Avg Body']
dominance_summary = avg_1hr_body_by_color['Green > Red'].value_counts()
dominance_summary_df = dominance_summary.reset_index()
dominance_summary_df.columns = ['Green > Red', 'Count']

display(dominance_summary_df)

# -------------- CALCULATE EXPECTED GAIN PER HOUR BY COLOR---------------
expected = avg_1hr_body_by_color.copy()

# Get win rates from hourly_color_counts
expected['Green Win Rate'] = hourly_color_counts['green_rate']
expected['Red Win Rate'] = hourly_color_counts['red_rate']

# Calculate expected gain
expected['Green Expected Gain'] = expected['Green Win Rate'] * expected['Green Avg Body']
expected['Red Expected Gain'] = expected['Red Win Rate'] * expected['Red Avg Body']

expected[['Green Expected Gain', 'Red Expected Gain']].plot(kind='bar', color=['limegreen', 'lightcoral'])

plt.title('Expected Gain per Hour (Win Rate × Avg Body Size)')
plt.xlabel('Hour of Day (New York Time)')
plt.ylabel('Expected Gain (Points)')
plt.xticks(rotation=0)
plt.grid(axis='y', linestyle='--', alpha=0.7)
plt.tight_layout()
plt.show()

# -------------- CALCULATE EXPECTED RAW GAIN PER HOUR -------------------
hourly['raw_gain'] = hourly['close'] - hourly['open']

# Group by hour and calculate average raw gain
raw_gain_by_hour = hourly.groupby('hour')['raw_gain'].mean()

raw_gain_df = pd.DataFrame({'Raw Gain': raw_gain_by_hour})

raw_gain_df.plot(kind='bar', color='steelblue')
plt.axhline(0, color='black', linewidth=1, linestyle='--')
plt.title('Average Raw Gain per Hour (Close - Open)')
plt.xlabel('Hour of Day (New York Time)')
plt.ylabel('Avg Raw Gain (Points)')
plt.xticks(rotation=0)
plt.grid(axis='y', linestyle='--', alpha=0.7)
plt.tight_layout()
plt.show()

raw_gain_df_rounded = raw_gain_df.round(4)
display(raw_gain_df_rounded)

# firstly I would calculate hourly returns
hourly['hourly_return'] = hourly['close'].pct_change() * 100
hourly.dropna(inplace=True)

# then I would add previous hour's return as a feature
hourly['prev_hour_return'] = hourly['hourly_return'].shift(1)
hourly.dropna(inplace=True)

# by which I would need to group by previous hour's return direction
hourly['prev_hour_direction'] = hourly['prev_hour_return'].apply(
    lambda x: 'up' if x > 0 else 'down')

# then it would be necessary to calculate average next hour return grouped by previous hour direction
momentum_effect = hourly.groupby(['hour', 'prev_hour_direction'])['hourly_return'].mean().unstack()

# this should plot the results
plt.figure(figsize=(12, 6))
momentum_effect.plot(kind='bar')
plt.title('Average Hourly Return Following Up/Down Hours')
plt.xlabel('Hour of Day (New York Time)')
plt.ylabel('Average Return (%)')
plt.axhline(0, color='black', linestyle='--', alpha=0.5)
plt.grid(axis='y', linestyle='--', alpha=0.7)
plt.legend(title='Previous Hour')
plt.tight_layout()
plt.show()

# here I would need to display the numerics and this would display numeric results
display(momentum_effect.round(3))

/tmp/ipykernel_3114/1605033132.py:2: FutureWarning: The default fill_method='pad' in Series.pct_change is deprecated and will be removed in a future version. Either fill in any non-leading NA values prior to calling pct_change or specify 'fill_method=None' to not fill NA values.
  hourly['hourly_return'] = hourly['close'].pct_change() * 100

<Figure size 1200x600 with 0 Axes>

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt


df['hour'] = df.index.hour

# her I would calculate average volume per minute by hour
volume_by_hour = df.groupby('hour')['volume'].mean()

# then I would plot average volume by hour
plt.figure(figsize=(10, 6))
volume_by_hour.plot(kind='bar', color='darkgreen')
plt.title('Average Minute Volume by Hour - SPY')
plt.xlabel('Hour of Day (New York Time)')
plt.ylabel('Average Volume per Minute')
plt.xticks(rotation=0)
plt.grid(axis='y', linestyle='--', alpha=0.7)
plt.tight_layout()
plt.show()

# after I would need to calculate hourly volume as percentage of daily volume
daily_volume = df.resample('1D')['volume'].sum()

# then convert the index to a column for merging
daily_volume = daily_volume.rename('daily_volume').reset_index()

# here I would need to ensure the 'date' column in df is of the same type as the index in daily_volume
df['date'] = pd.to_datetime(df.index.date).tz_localize('America/New_York')

# lastly I would merge the DataFrames
df_with_daily = df.merge(
    daily_volume,
    left_on='date',
    right_on=daily_volume.columns[0],  # Dynamically use the correct column name
    how='left'
)

# then calculate volume percentage
df_with_daily['volume_pct'] = (df_with_daily['volume'] / df_with_daily['daily_volume']) * 100

# here I would need to group by hour and calculate mean percentage
volume_pct_by_hour = df_with_daily.groupby('hour')['volume_pct'].mean()

# lastly I would plot volume percentage by hour
plt.figure(figsize=(10, 6))
volume_pct_by_hour.plot(kind='bar', color='seagreen')
plt.title('Average Minute Volume as % of Daily Volume by Hour - SPY')
plt.xlabel('Hour of Day (New York Time)')
plt.ylabel('% of Daily Volume (per minute)')
plt.xticks(rotation=0)
plt.grid(axis='y', linestyle='--', alpha=0.7)
plt.tight_layout()
plt.show()

# here I would create a DataFrame for analysis
first_hour = df.copy()
first_hour['date'] = first_hour.index.date
first_hour['time'] = first_hour.index.time

# then filter for first hour (9:30-10:30) and rest of day (10:30-16:00)
first_hour_data = first_hour[first_hour['time'] <= pd.to_datetime('10:30').time()]
rest_of_day = first_hour[
    (first_hour['time'] > pd.to_datetime('10:30').time()) & 
    (first_hour['time'] <= pd.to_datetime('16:00').time())
]

# as a result I would calculate returns for first hour and rest of day by date
first_hour_returns = first_hour_data.groupby('date').apply(
    lambda x: (x['close'].iloc[-1] / x['open'].iloc[0] - 1) * 100 if len(x) > 0 else None
)
rest_of_day_returns = rest_of_day.groupby('date').apply(
    lambda x: (x['close'].iloc[-1] / x['open'].iloc[0] - 1) * 100 if len(x) > 0 else None
)

# then combine into DataFrame
returns_df = pd.DataFrame({
    'first_hour': first_hour_returns,
    'rest_of_day': rest_of_day_returns
})
returns_df.dropna(inplace=True)

# which is why I calculate correlation
first_rest_corr = returns_df['first_hour'].corr(returns_df['rest_of_day'])

# then for the results I would create scatter plot
plt.figure(figsize=(8, 8))
plt.scatter(returns_df['first_hour'], returns_df['rest_of_day'], 
            alpha=0.5, color='darkblue')
plt.axhline(y=0, color='r', linestyle='-', alpha=0.3)
plt.axvline(x=0, color='r', linestyle='-', alpha=0.3)
plt.grid(True, linestyle='--', alpha=0.7)
plt.title(f'First Hour vs Rest of Day Returns (Correlation: {first_rest_corr:.3f})')
plt.xlabel('First Hour Return (%)')
plt.ylabel('Rest of Day Return (%)')
plt.tight_layout()
plt.show()

# then categorize first hour by direction and magnitude
returns_df['first_hour_dir'] = returns_df['first_hour'].apply(
    lambda x: 'strong_up' if x > 0.5 else 
              'weak_up' if x > 0 else 
              'weak_down' if x > -0.5 else 'strong_down'
)

# in half I would calculate average rest-of-day return grouped by first hour pattern
rest_of_day_by_first = returns_df.groupby('first_hour_dir')['rest_of_day'].agg(['mean', 'std', 'count'])
rest_of_day_by_first['sem'] = rest_of_day_by_first['std'] / np.sqrt(rest_of_day_by_first['count'])

# then lastly plot bar chart
plt.figure(figsize=(10, 6))
rest_of_day_by_first['mean'].plot(kind='bar', yerr=rest_of_day_by_first['sem'], 
                                   color=['darkgreen', 'lightgreen', 'pink', 'darkred'])
plt.axhline(0, color='black', linestyle='-', alpha=0.3)
plt.title('Rest of Day Returns Based on First Hour Performance')
plt.xlabel('First Hour Pattern')
plt.ylabel('Average Rest of Day Return (%)')
plt.grid(axis='y', linestyle='--', alpha=0.7)
plt.tight_layout()
plt.show()

# then at the bottom I would display statistics
display(rest_of_day_by_first.round(3))

/tmp/ipykernel_3114/3975178415.py:14: DeprecationWarning: DataFrameGroupBy.apply operated on the grouping columns. This behavior is deprecated, and in a future version of pandas the grouping columns will be excluded from the operation. Either pass `include_groups=False` to exclude the groupings or explicitly select the grouping columns after groupby to silence this warning.
  first_hour_returns = first_hour_data.groupby('date').apply(
/tmp/ipykernel_3114/3975178415.py:17: DeprecationWarning: DataFrameGroupBy.apply operated on the grouping columns. This behavior is deprecated, and in a future version of pandas the grouping columns will be excluded from the operation. Either pass `include_groups=False` to exclude the groupings or explicitly select the grouping columns after groupby to silence this warning.
  rest_of_day_returns = rest_of_day.groupby('date').apply(

# here I would need to ensure index is tz-naive by removing timezone info if present
df.index = df.index.tz_localize(None) if df.index.tz is not None else df.index

# then create a DataFrame for end-of-day analysis
eod = df.copy()
eod['date'] = eod.index.date
eod['time'] = eod.index.time

# after I would need to filter for last hour (15:00-16:00) and entire day
last_hour = eod[(eod['time'] >= pd.to_datetime('15:00').time()) & 
                (eod['time'] <= pd.to_datetime('16:00').time())]

# then calculate daily and last hour returns
daily_df = df.resample('1D').agg({'open': 'first', 'close': 'last'})
daily_df['daily_return'] = (daily_df['close'] / daily_df['open'] - 1) * 100
daily_df['next_day_return'] = daily_df['daily_return'].shift(-1)

last_hour_returns = last_hour.groupby('date').apply(
    lambda x: (x['close'].iloc[-1] / x['open'].iloc[0] - 1) * 100 if len(x) > 0 else None
)

# which is why I would combine into DataFrame
eod_df = pd.DataFrame({
    'last_hour_return': last_hour_returns,
    'next_day_return': daily_df['next_day_return']
})
eod_df.dropna(inplace=True)

# then calculate correlation
eod_corr = eod_df['last_hour_return'].corr(eod_df['next_day_return'])

# lassly create scatter plot
plt.figure(figsize=(8, 8))
plt.scatter(eod_df['last_hour_return'], eod_df['next_day_return'], 
            alpha=0.5, color='darkblue')
plt.axhline(y=0, color='r', linestyle='-', alpha=0.3)
plt.axvline(x=0, color='r', linestyle='-', alpha=0.3)
plt.grid(True, linestyle='--', alpha=0.7)
plt.title(f'Last Hour Return vs Next Day Return (Correlation: {eod_corr:.3f})')
plt.xlabel('Last Hour Return (%)')
plt.ylabel('Next Day Return (%)')
plt.tight_layout()
plt.show()

# which inturn would mean to categorize last hour performance
eod_df['last_hour_dir'] = eod_df['last_hour_return'].apply(
    lambda x: 'strong_up' if x > 0.3 else 
              'weak_up' if x > 0 else 
              'weak_down' if x > -0.3 else 'strong_down'
)

# then calculate average next day return grouped by last hour pattern
next_day_by_last = eod_df.groupby('last_hour_dir')['next_day_return'].agg(['mean', 'std', 'count'])
next_day_by_last['sem'] = next_day_by_last['std'] / np.sqrt(next_day_by_last['count'])

# lastly plot bar chart
plt.figure(figsize=(10, 6))
next_day_by_last['mean'].plot(kind='bar', yerr=next_day_by_last['sem'], 
                              color=['darkgreen', 'lightgreen', 'pink', 'darkred'])
plt.axhline(0, color='black', linestyle='-', alpha=0.3)
plt.title('Next Day Returns Based on Last Hour Performance')
plt.xlabel('Last Hour Pattern')
plt.ylabel('Average Next Day Return (%)')
plt.grid(axis='y', linestyle='--', alpha=0.7)
plt.tight_layout()
plt.show()

# then display statistics at the bottom 
display(next_day_by_last.round(3))

/tmp/ipykernel_3114/1845835898.py:18: DeprecationWarning: DataFrameGroupBy.apply operated on the grouping columns. This behavior is deprecated, and in a future version of pandas the grouping columns will be excluded from the operation. Either pass `include_groups=False` to exclude the groupings or explicitly select the grouping columns after groupby to silence this warning.
  last_hour_returns = last_hour.groupby('date').apply(

	open	high	low	close	volume	symbol
timestamp
2018-05-01 04:04:00-04:00	264.57	264.57	264.57	264.57	20	SPY
2018-05-01 04:09:00-04:00	264.50	264.50	264.50	264.50	400	SPY
2018-05-01 04:10:00-04:00	264.54	264.54	264.54	264.54	2500	SPY
2018-05-01 04:17:00-04:00	264.47	264.47	264.47	264.47	1100	SPY
2018-05-01 04:25:00-04:00	264.53	264.53	264.53	264.53	300	SPY

	Green Count	Red Count	Green Rate (%)	Red Rate (%)
hour
4	893	864	50.83	49.17
5	910	845	51.85	48.15
6	916	841	52.13	47.87
7	882	876	50.17	49.83
8	878	880	49.94	50.06
9	932	826	53.01	46.99
10	908	850	51.65	48.35
11	952	806	54.15	45.85
12	943	815	53.64	46.36
13	928	830	52.79	47.21
14	942	816	53.58	46.42
15	865	893	49.20	50.80
16	935	823	53.19	46.81
17	768	975	44.06	55.94
18	875	863	50.35	49.65
19	587	567	50.87	49.13

	Green Avg Body	Red Avg Body
hour
0	NaN	NaN
1	NaN	NaN
2	NaN	NaN
3	NaN	NaN
4	0.502206	0.527457
5	0.393172	0.409728
6	0.403319	0.412283
7	0.429580	0.484178
8	0.690000	0.700080
9	0.927484	0.944050
10	0.990413	1.155388
11	0.815294	0.888939
12	0.688849	0.782215
13	0.708599	0.780512
14	0.773949	0.812243
15	0.984341	0.997945
16	0.423107	0.435632
17	0.174388	0.168359
18	0.309360	0.285620
19	0.285026	0.257619
20	NaN	NaN
21	NaN	NaN
22	NaN	NaN
23	NaN	NaN

	Raw Gain
hour
0	NaN
1	NaN
2	NaN
3	NaN
4	-0.0044
5	0.0068
6	0.0129
7	-0.0257
8	-0.0058
9	0.0481
10	-0.0471
11	0.0339
12	0.0069
13	0.0055
14	0.0377
15	-0.0226
16	0.0211
17	-0.0173
18	0.0139
19	0.0184
20	NaN
21	NaN
22	NaN
23	NaN

prev_hour_direction	down	up
hour
4	0.018	0.008
5	0.001	0.006
6	0.006	0.003
7	-0.010	-0.000
8	0.020	-0.019
9	0.017	0.010
10	-0.013	-0.004
11	0.007	0.014
12	-0.001	0.007
13	-0.007	0.003
14	0.009	0.011
15	-0.003	-0.005
16	0.003	0.007
17	-0.001	-0.010
18	0.005	0.008
19	0.016	-0.002

Intraday Volatility and Trend Analysis of SPY for Trading¶

Introduction¶

📁 Data Source & Collection¶

❓ Questions for SPY¶

📚 Resources¶

📈 Exploratory Data Analysis & Visualizations¶

1. Which hours have the highest 1 minute volatility (point range)?¶

2. Which hours have the largest moves (body point range)?¶

3. Which hours have the strongest trends?¶

4. What is the probability of an hourly candle closing green (bullish) or red (bearish) at each hour of the trading day?¶

5. What is the average point size of green vs red candles per hour?¶

6. What is the expceted gain per hour?¶

7. What is the intraday momentum pattern (average returns in consecutive hours)?¶

8. How do volume patterns vary throughout the trading day?¶

9. How do first hour trading patterns affect the rest of the day?¶

10. What are the end-of-day momentum patterns?¶

Conclusion¶

References¶

	mean	std	count	sem
first_hour_dir
strong_down	-0.012	1.128	272	0.068
strong_up	-0.028	1.088	287	0.064
weak_down	0.022	0.637	545	0.027
weak_up	0.024	0.625	654	0.024

	mean	std	count	sem
last_hour_dir
strong_down	0.204	1.656	199	0.117
strong_up	-0.163	1.268	160	0.100
weak_down	-0.009	0.978	503	0.044
weak_up	0.047	0.968	510	0.043